Decide how the human interrupts a Turn and sends a message while a Turn is working

[Sandstorm831]

Question

What does interrupting a live Turn leave behind (the Session continuing for the human's next message, versus today's cancelled Step Attempt and halted Run), and what happens to a message the human sends while a Turn is working (native Steer, a queued next Turn, or an emulation on Harnesses without native Steer)? Decide the behaviour per Step kind and per Harness, what Secant records, and whether any Harness transport must change, superseding or amending the recorded Interrupt and Steer decisions where needed.

[Sandstorm831]

Starting context

Input	Why it matters	Authority
The human's ask, raised while grilling Decide how model and effort are chosen and changed within a Harness Session	Escape stops the Turn and the human types on in the same Session; Enter mid-Turn queues a message picked up without interrupting	Canonical (source report)
Establish how T3 Code and the native Claude Code and Codex clients interrupt a Turn and queue a message typed mid-Turn	What each native client, T3 Code, and Secant's current transports do, and that no transport change is needed	Research
Run lifecycle glossary (Steer, Interrupt, Agent step, Interactive agent step)	The recorded rules this may supersede: Interrupt halts the Run; Steer is native-only and never emulated	Canonical
Live Run control, section Turn interrupt and steer; #118, #148	How interrupt-turn and steer-turn work today, and the steer evidence the research found in conflict with the SDK reference	Canonical (current behaviour)
The resolution of Decide how model and effort are chosen and changed within a Harness Session, once closed	A change made mid-Turn applies from the next Turn; any Claude Code transport decision taken there	Canonical decision

Reading rule

Read the research Answer and its capability table first. Decide per Step kind (Agent step, Interactive agent step) what Interrupt leaves behind,
then what a mid-Turn message does per Harness, then what is recorded. Four facts are untested and need a live Harness session: whether SIGTERM keeps
the partial Turn in the resumed context, whether SIGINT keeps a -p stream-json process alive, whether a raw interrupt control request works
without the SDK's initialize, and the version floor for Claude Code's headless mid-Turn pickup. If the decision turns on any, spin out a task
ticket rather than guessing. Presentation (keys, the queued-message display) belongs to the Run Workbench prototype.

[Sandstorm831]

Resolution

Interrupt ends only the Turn, and a message sent while a Turn is working is a native Steer, in both agent Step kinds; the Turn lasts until every Steer is delivered. Recorded as ADR 0035 in PR #257, which also amends ADR 0022 inline and the Run lifecycle glossary.

1. Interrupt, per Step kind.
   • Interactive agent step: the Turn ends interrupted, the Run returns to blocked, and the human's next message goes into the same Session. No Attempt is published. An interrupted Entry Turn is never re-sent.
   • Agent step: the Attempt stays open and the Run is blocked on the human's message, which starts a human-origin follow-up Turn in the same Session and Attempt. The Attempt takes its outcome from its last Turn: a clean end advances the Routing without the human, and a failure takes the ordinary retry policy. A second Interrupt is the only way to hold the Step again. Rejected: a human-held Agent step, which would quietly become an Interactive one.
   • An Agent call made in an interrupted Turn is still dropped (ADR 0032). Closing Secant and Ctrl+C still halt the Run (ADR 0019).
2. Steer is widened to mean native mid-Turn delivery of the human's own text, at the Harness's next boundary, and it is offered in both Step kinds.
   • Codex uses turn/steer with a Secant-minted clientUserMessageId, echoed as the userMessage item's clientId.
   • Claude Code uses a stdin user frame on the existing transport, stamped with a uuid, tracked through result.user_message_uuids and the command_lifecycle frames (msg_lifecycle_v1). queued_turn_count is not used.
   • Delivered means the text reached the model, not that the model followed it. Rejected: a client-side queue (emulation), and a separate queue key.
3. The Turn stretches. It ends at the first boundary after which no accepted Steer is pending, so one Secant Turn may span several native exchanges, and the human's message always beats a pending step_done.
   • A Codex steered text taken into history after the last model request (stop hooks, compaction, a failing Turn) is re-delivered by the Codex Adapter with a native turn/start inside the same Turn. That start carries an empty input if Codex accepts one, and otherwise the same text.
   • A Steer that arrives after the Turn has ended is rejected and its draft kept.
4. Interrupt drops undelivered Steers. Each settles dropped and its text returns to the compose. Codex discards them itself; Claude Code is sent cancel_queued: true.
5. Claude Code stops with the raw control_request interrupt. It needs no Agent SDK, just the same stdin wire as ADR 0034's set_model. The fallback is SIGTERM plus --resume, and SIGINT is rejected. With the request, the Claude Code interruption becomes confirmed active-turn. An Interrupt stops foreground tool work only, because a backgrounded shell can outlive it.
6. Recording in run.db:
   • each Steer's text, time, and settlement (delivered in the Turn, after a boundary, re-delivered, or dropped);
   • the stop used;
   • follow-up Turns as human-origin Turns in the Attempt.
7. Harness Interface. steer keeps its ControlReceipt, and the Turn event stream gains a delivered-or-dropped Steer lifecycle. Pending Steers are published as dropped before the producer closes, so terminal ordering is unchanged. Pending-Steer state and the native ids stay private to each Adapter, and execution still sees one result per Turn.
8. Headless is unchanged. Ctrl+C remains a halt. The new docs/headless-parity.md lists the TUI-only capabilities (Interactive agent steps, Interrupt, the follow-up after it, Steer) and is pointed to from src/headless/AGENTS.md.

Superseded:

• the glossary's Interrupt rule (the Attempt ends cancelled and the Run halted) and its Steer definition;
• Spec: M3 stories 18–19 and its deferral of a Session-preserving Claude Code interrupt;
• Spec: M4 story 19.

Evidence

• Claude Code live interrupt and mid-Turn send, recorded on 2.1.284:
  • SIGTERM loses streamed text.
  • SIGINT exits and loses queued messages.
  • The raw interrupt answers without initialize, keeps the process and the partial text, and turns a mid-tool result into "rejected".
  • Frames written during a tool call are taken in the same exchange; frames written during text run as a second exchange.
  • cancel_queued works raw.
• A Codex source read at the pinned commit covered the clientUserMessageId echo, the leftover-input window, and clear_pending on interrupt.
• Still unknown: Windows; a stop while a tool waits on Secant's permission bridge; pickup within multi-tool and MCP rounds; whether Codex accepts turn/start with empty input. These go to the spec's recorded fixtures.

No-decision fixes surfaced (for the first Amendment):

• the stale "closed after each human Turn" comments at src/run/execution/agent.ts:369 and :918 (the research note is corrected in docs(adr): interrupt ends only the Turn and a mid-Turn message is a native Steer (#255) #257);
• the redundant Codex thread/resume before every human Turn on a live connection;
• a timed-out or erroring Codex turn/steer or turn/interrupt ending the whole Turn lost (codex.ts:1091-1150);
• a possible already-fired abort signal after a rejected interrupt (agent.ts:462, inferred, not traced end to end);
• the Workbench hiding Steer during Interactive agent steps although the Application accepts it.

Left to the Run Workbench prototype: the keys, how delivered and dropped Steers are shown, the restored draft, and the waiting-after-Interrupt state.

[Sandstorm831]

Resolution addendum: second live recording

A second live round ran on Claude Code 2.1.284 against a stand-in copied from Secant's permission bridge. It confirms the decision; nothing changes.

• Stop during a permission wait.
  • The raw interrupt is honoured in 3 of 3 runs and answers in milliseconds.
  • The process stays alive, and the next frame runs in the same Session.
  • Claude Code sends the bridge an MCP notifications/cancelled for the pending approval, and the tool never runs.
  • The SIGTERM fallback in the same state exits with no result. During shutdown it re-sends the same approval on a new MCP session, and --resume adds a synthetic "outcome is unknown" tool result. The spec should have the bridge ignore approvals for an already-expired request.
• Steer in multi-tool and MCP rounds.
  • A frame is taken at the end of the whole tool round, never between two calls in it.
  • This holds for a single slow MCP call and for a Bash call waiting on approval.
  • Every case stayed in the same Turn and was listed in user_message_uuids.

ADR 0035 is tightened in PR #257 to say both.

Still unknown, for the spec:

• Windows (a human check);
• whether Codex accepts a turn/start with empty input (the spec's Codex fixture);
• SIGINT during a permission wait (moot, since SIGINT is rejected);
• whether the SIGTERM re-sent approval always happens;
• pickup when a tool call is denied.