Decisions: the calls only you can make, in one queue

An agent at a real fork (a schema, a data migration, a tradeoff that turns on taste) has two bad options today. It can stop and ask inline, which pulls you out of your own work to read a transcript and reconstruct the question. Or it can pick alone, and you find out after code depends on the choice. cast decide is the third option: the agent writes the question, the options and its reasoning into a card, the card waits in your queue, and you clear the queue when you sit down. Each answer goes back to the session that asked, as a normal message.

Because a queued question costs you almost nothing to receive, the bar for asking drops. A choice the agent would have made silently and mentioned in passing goes to the queue instead, where you can overrule it before it matters.

One question, 2 to 9 options (mapped to keys 1 to 9), and the context: what the agent found, what each option costs, and why it cannot pick. Text after :: in an option becomes the consequence printed under its label, so you compare outcomes where you click.

$ cast decide "Which schema wins?" \
    -o "Frontmatter wins :: the daemon changes" \
    -o "Path wins :: old links break" \
    --report id-audit.html \
    --context - <<'EOF'
The daemon writes note ids from the file path. The web index derives
them from frontmatter. A rename keeps one id and changes the other, so
the same note indexes twice. Either side can be authoritative.
EOF

Decision posted: Which schema wins?
  id: sd-41
  1. Frontmatter wins: the daemon changes
  2. Path wins: old links break
  report: https://codecast.sh/a/id-audit

Blocking: end your turn now. The answer arrives as a user message.

The CLI pushes back on lazy cards. It refuses a bare question outright: a card needs --context, --report, --doc or --card. It prints the card back to the agent so the agent sees what you will see, and it warns when there is no report and under 200 characters of context, or when no option says what happens if chosen. Posting the same question again from the same session updates the open row instead of adding a duplicate, so a crashed and retried agent does not spam the queue.

Blocking is the default: the agent posts and ends its turn, and the session stays parked until you answer. Nothing is locked; the CLI tells the agent to stop, and the agent's instructions say the same. --advisory --default n lets the agent carry on with option n while your answer can still override it. In the session view an advisory ask folds to one pill above the composer, so the thread stays the main event, and it sorts after every blocking ask in your queue.

The rule the agent is given is the interesting part: advisory only when the default is cheap to undo. Answers often land an hour later and disagree, and everything built on the default in that hour is work to unwind. If reversing would cost more than waiting, block.

Your queue lives at /questions on the web and in the phone app, and every card also renders inline in the conversation that asked. The order is a rule, not a score: blocked asks whose session can still take an answer come first, then blocked asks on a stopped session, then advisory asks. Inside each group the oldest leads, because a parked agent costs more the longer it waits. Each ask shows its age two ways, wall clock and messages the session has written since; a blocking ask with traffic after it usually means someone already answered in the thread.

An answer marks the row answered at once and sends a user message into the asking session, Decision: <label>, rendered as an answer linked back to the ask. Answering from a shell (cast decide answer sd-41 2) writes the same message. The first answer wins; a second changes nothing. Permission prompts and an agent's own terminal questions wait in the same queue, with one safety detail: on a permission card the digits are off and only y and n answer, so a digit meant for the previous card can never approve a command.

A decision that deserves proof gets a page. --report publishes an HTML or markdown file through the same path as cast publish and embeds it under the question. --option-page n=file.html gives each option its own page, so two designs sit side by side. --doc attaches a long markdown body. Beyond a single choice, --kind multi|rank|form asks for several, an order, or a short form, --line asks for one line of text, and --spec takes the whole decision as JSON with cost, risk and evidence per option. A card with any of these links to its own page at /decisions/sd-N.

A posted decision belongs to the agent until someone answers. When the facts change, cast decide edit rewrites the question, options, context or report in place, keeping the id, the age and the spot in your queue. When the question stops mattering, cast decide cancel withdraws it and the conversation shows it as withdrawn. Staleness is measured, not hoped for: each ask records the session's message count when posted, and after 2 hours or 30 messages the CLI tells the agent to edit or cancel it. Once answered, a card cannot be edited; to change course you send the session a message.

$ cast decide edit --context - <<'EOF'      # new facts: rewrite the open card
The load test finished: exponential lost 0 events, fixed lost 3.
EOF
$ cast decide cancel                        # the question no longer applies
$ cast decide ls                            # this session's asks, answers, staleness

A stack groups related asks, like everything a launch needs from you, into a checklist with an id such as ds-7. An agent creates one and appends to it with --stack, or you tick cards in the queue and group them yourself. A stack can carry a due time (--due tomorrow; overdue stacks sort first), an auto default (--auto-default 24h answers advisory members with their declared default after the deadline, from a server job every 5 minutes; blocking members never answer themselves), and a delegate role that answers every open category for its members, while protected questions (production, billing, data, access) still come to a person.