fix(cli): keep one-shot system-reminder prefixes out of shell mode - #12605

Local real-environment verification: PR head d46a3b4 vs merge base ffea2d0

Summary: Both halves of the fix work in the real TUI:

• A shell-mode submission no longer carries the one-shot reminder, and the reminder reaches the next model turn.
• Ctrl+Q-queued entries route on the intent recorded when they were submitted.

Two things from the real runs matter for the merge decision, and neither needs to block:

1. Enter while the model is responding skips this fix entirely. That is the path the footer labels "Enter to steer". Those entries leave through the steer drain (drainQueue), so on both arms a command typed in shell mode is still sent to the model as a prompt, even when shell mode stays on the whole time. The PR description does list the steer drain as out of scope. In practice, though, it is the most common way to queue while a turn runs, and there is no follow-up issue for it yet. A one-line candidate fix is below, measured in the real TUI.
2. R1-4 (Shell-mode commands never hold the session busy: streamingState reads Idle while the command runs, so the queue drain admits a concurrent model turn #12664) reproduces in the real TUI on a Ctrl+Q mixed queue. While the shell command runs, the queued prompt starts as a concurrent model turn. When the command finishes, the UI shows idle while the model request is still open, Esc does nothing, and the reply arrives about 20 s later.

Setup

• Two worktrees: d46a3b4 (PR head) and ffea2d0 (the merge base it merged in).
• Each arm: pnpm install --frozen-lockfile, npm run build, npm run bundle, then the real dist/cli.js is run in a PTY.
• Driven with the repo's own integration-tests/terminal-capture (node-pty + xterm.js).
• integration-tests/fake-openai-server stands in for the model. It holds any prompt containing HOLD_TURN open for 20 s, so the queue can be exercised mid-turn. Every main-loop request body is recorded, and routing is judged from that ledger plus the screen.
• The CLI runs with its own HOME, in a fresh git repo. macOS arm64, Node 22.

Scenario matrix

Finding 1: the Enter / steer path still sends shell-mode commands to the model (pre-existing, not addressed)

When a model stream ends with no tool calls, client.ts runs takeSteerInput() → getSteerInput: drainSteerAtBoundary → midTurnDrainRef → useMessageQueue.drainQueue. drainQueue returns plain text for every entry that is not deferred-until-idle, and ignores shellMode. So an entry queued with Enter never reaches popNextSubmission, and the new intent field is never read. In s2b the footer reads shell mode enabled · ⏳1 queued and shell mode is never turned off. The command still goes to the model (ledger request #1: user content echo PR12605_QUEUED_SHELL_RAN).

Candidate fix: let the steer drain leave shell-intent entries for the queue drain, which already routes them correctly:

@@ packages/cli/src/ui/hooks/useMessageQueue.ts (drainQueue)
-        (includeDeferred || !message.deferUntilIdle);
+        (includeDeferred || !message.deferUntilIdle) &&
+        message.shellMode !== true;

Measured in the real TUI (rebuilt bundle, same driver):

• s2 and s2b now run in bash (✓ Shell Command … PR12605_QUEUED_SHELL_RAN, and the command never appears in a model request).
• s3 still goes to the model.
• The three suites this PR names stay green: 546/546.

Nothing in the suites tests this, so it would need its own test. There is also one trade-off: at a steer boundary, a later model-intent entry can overtake an earlier shell entry, which then waits for the turn to end. This can land here or as a follow-up. If it becomes a follow-up, please open the issue the bot suggested so the gap is tracked.

Finding 2: R1-4 / #12664 confirmed end to end

s5q on the PR arm, probing the screen at fixed times:

• During sleep 8, the UI shows the prompt HOLD_TURN summarize the diff running as a model turn (spinner, esc to cancel) next to the running Shell Command.
• About 8 s later the command finishes. The spinner is gone, the prompt reads idle, and the fake server still has the request open.
• Esc changes nothing. The reply MODEL_REPLY_HOLD_DONE arrives about 20 s after the request started.

The merge base took the same input as one blob (itself mis-routed: a shell command sent to the model), and Esc cancelled it. This agrees with the attribution in #12664: the idle-state overwrite is pre-existing, and this PR makes a mixed Ctrl+Q queue walk into it routinely. It is already tracked as P1 with need-discussion, so I don't see it as blocking here.

Unit-level red/green check

In packages/cli: vitest run src/ui/AppContainer.test.tsx src/ui/hooks/use-llm-stream.test.tsx src/ui/hooks/useMessageQueue.test.ts

• PR head: 546/546 passed.
• The three production files reverted to ffea2d0, tests kept: 27 failed. These are all the new fix(cli): system-reminder prefixes reach bash in shell mode #11626 cases (both shell-mode reminder cases, both intent-routing directions, homogeneous batching, restore, the Ctrl+Q shell pin, the drain metadata pin), plus existing cases whose assertions now expect the fourth addMessage argument.
• The tree was restored afterwards.

Not covered

• The recovered-agents notice was not triggered live (it needs a paused background agent from an earlier session). It uses the same gating pattern as the worktree notice verified in s1, and the unit suite pins it.
• Linux and Windows were not run locally; CI on this head is green.

Recommendation

OK to merge as the fix for the reminder half of #11626 and for Ctrl+Q queue routing. Neither finding is a regression in what the PR touches:

• Finding 1 is pre-existing and was scoped out.
• Finding 2 is tracked in Shell-mode commands never hold the session busy: streamingState reads Idle while the command runs, so the queue drain admits a concurrent model turn #12664.

Before or right after merging:

• Narrow the description's "queued submissions now carry the shell intent" to the Ctrl+Q / popNextSubmission path.
• Either take the one-line drainQueue candidate with a test, or file it as a follow-up. Without it, the everyday way of queuing a shell command while a turn runs still sends the command to the model.

@qwen-code /triage