@@ -565,7 +565,7 @@ Each starts an agent loop in the REPL.
 | Command | Action |
 |---|---|
 | `/queue <task>` | Queue a task to run when the current one finishes. |
-| `/steer <guidance>` | Mid-task steering applied on the next turn. |
+| `/steer <guidance>` | Steer the running local turn; reported as accepted, applied (with the boundary reached and any tool calls withheld), or refused. A hosted chat turn cannot acknowledge live steering, so the note is deferred to the next turn and says so. Never changes tool permissions. |
 | `/btw <note>` | Contextual side note (accumulates into context). |
 
 ### Context & limits
 
@@ -1,5 +1,5 @@
 <!-- GENERATED FILE: run `npm run docs:generate`; do not edit by hand. -->
-<!-- manifest-digest: sha256:528c55f5f15ba474ef4fb931cea11a1f1275bd261aa7503c08bd9ad09b230e51 -->
+<!-- manifest-digest: sha256:b25a192ef11940201fd63b69039524d88d114192cb22b095875eacbddd4ce065 -->
 # Generated command reference
 
 This reference is generated from the validated, versioned command manifest. Availability is evaluated at runtime; a listed command may still require authentication, a hosted capability, or local tooling.
@@ -527,7 +527,7 @@ Permission: `unknown` · Availability: `runtime-dependent` · Telemetry: `slash.
 
 #### `/steer <guidance>`
 
-mid\-task steering for the next turn
+steer the running turn if its brain acknowledges it, else the next turn
 
 Permission: `unknown` · Availability: `runtime-dependent` · Telemetry: `slash.steer`
 
 
@@ -53,6 +53,7 @@ import { chooseBackend, type BackendPath } from "../core/backend.js";
 import { OllamaBrain } from "../core/brain_ollama.js";
 import { isLocalModelId, localModelId, ollamaTagFromId, resolveHostedModel, resolveLocalModel } from "../core/local_ollama.js";
 import type { Brain } from "../core/brain.js";
+import { SteerChannel, formatSteerAck } from "../core/steer_channel.js";
 import type { RunOptions, ToolResult } from "../core/tool_executor.js";
 import { ToolExecutor } from "../core/tool_executor.js";
 import { ConsoleShell, classifyConsoleInput, type ConsoleInput } from "./console_input.js";
@@ -113,8 +114,13 @@ export interface TurnSkillOptions {
   exec?: ToolExecutor;
   /** Host-observed results only; no model text or shell output. */
   onToolResult?: (tool: ObservedTool) => void;
+  /** Console /steer routing for this turn (#283). Never serialized to Cloud. */
+  steer?: SteerChannel;
 }
 
+/** Why a hosted chat turn only takes steering for the next turn (#283). */
+export const HOSTED_STEER_DEFERRED = "this hosted chat route has no live control acknowledgement";
+
 export const DEFAULT_CHAT_TURN_DEADLINE_MS = 30 * 60_000;
 /** A positive override is useful for tests and operators; 0 cannot disable it. */
 export function chatTurnDeadlineMs(env: Readonly<Record<string, string | undefined>> = process.env): number {
@@ -519,8 +525,11 @@ export async function runTurn(
       getRegistry().markLocalUnmetered();
       // The signal used to be dropped here, so the REPL Ctrl+C controller could
       // not reach a local turn at all: the abort fired and nothing observed it.
-      return await runLocalTurn(ctx, brief, boundedSignal.signal, { lifecycle, onPulsePaint, deadlineAt, ...(skillOpts.exec ? { exec: skillOpts.exec } : {}), ...(skillOpts.onToolResult ? { onToolResult: skillOpts.onToolResult } : {}) }, run.guard);
+      return await runLocalTurn(ctx, brief, boundedSignal.signal, { lifecycle, onPulsePaint, deadlineAt, ...(skillOpts.exec ? { exec: skillOpts.exec } : {}), ...(skillOpts.onToolResult ? { onToolResult: skillOpts.onToolResult } : {}), ...(skillOpts.steer ? { steer: skillOpts.steer } : {}) }, run.guard);
     }
+    // /agent/chat/stream exposes no control acknowledgement, so a steer typed
+    // during this turn is kept for the next one rather than reported as live.
+    skillOpts.steer?.markNextTurnOnly(HOSTED_STEER_DEFERRED);
     // The cloud REPL turn streams from /agent/chat/stream, where the SERVER runs
     // the tools. This host executes nothing on that path, so it can enforce
     // nothing on it either. Say so rather than let the Policy line above read as
@@ -807,6 +816,13 @@ export interface LocalTurnDeps {
    * workspace. `false` disables it for a deliberate embed. */
   failureBudget?: ToolFailureBudget | false;
   onToolResult?: (tool: ObservedTool) => void;
+  /** Live /steer routing: attached once the brain runs (#283). */
+  steer?: SteerChannel;
+}
+
+/** What the brain is told when the host refuses a call selected before a steer. */
+export function staleAfterSteerResult(name: string): ToolResult {
+  return { output: `[tool ${name} not executed: superseded by operator steering accepted before it ran]`, exitCode: 1 };
 }
 
 export async function runLocalTurn(
@@ -879,6 +895,7 @@ export async function runLocalTurn(
   try {
     pulse.start();
     iterator = brain.run(task)[Symbol.asyncIterator]();
+    deps.steer?.attach(brain);
     for (;;) {
       const next = await boundedLocalOperation(
         () => iterator!.next(),
@@ -936,6 +953,22 @@ export async function runLocalTurn(
           const note = origin ? failures?.repeatNote(key) : null;
           brain.sendToolResult(ev.id, note && result.exitCode !== 0 ? { ...result, output: `${result.output}\n${note}` } : result);
         };
+        // A steer the brain accepted but has not yet put in front of the
+        // model means this call was selected before it. It is answered
+        // without prompting or executing, and counts as no failure (#283).
+        const supersededBySteer = (): boolean => {
+          if (!deps.steer?.hasPendingSteer()) return false;
+          deps.steer.noteToolSkipped(ev.name);
+          deliver(staleAfterSteerResult(ev.name), null);
+          return true;
+        };
+        if (supersededBySteer()) {
+          lastMeaningfulAt = Date.now();
+          modelOutput.reset();
+          noteStreamingActivity(lifecycle);
+          pulse.start();
+          continue;
+        }
         // Same repeated-failure budget as hostLoop, checked before any prompt
         // or execution: a spent operation is refused once, then stops the turn.
         failures?.noteModelRound(brain.modelRound?.());
@@ -1002,13 +1035,16 @@ export async function runLocalTurn(
           };
           if (!approved) {
             deliver({ output: `[tool ${ev.name} blocked: permission denied]`, exitCode: 1 }, "approval");
-          } else {
+          } else if (!supersededBySteer()) {
+            // Approval can take a while; a steer accepted during the prompt is
+            // checked above, so an approved-but-stale write still never runs.
             let result = await execute();
             // Read-only transient failures only; a mutation is never replayed.
             for (let retry = 0; retry < TRANSIENT_READ_AUTO_RETRIES; retry += 1) {
-              if (controller.signal.aborted || !hostMayRetry(ev.name, classifyToolFailure(ev.name, result))) break;
+              if (controller.signal.aborted || deps.steer?.hasPendingSteer() || !hostMayRetry(ev.name, classifyToolFailure(ev.name, result))) break;
               result = await execute();
             }
+            deps.steer?.noteToolFinished(ev.name);
             deliver(result, "execution");
           }
         }
@@ -1043,6 +1079,13 @@ export async function runLocalTurn(
   if (terminalError) throw terminalError;
   const settled = lifecycle.outcome;
   if (settled) return settled;
+  // Ctrl+C while the model is generating closes the brain, which ends its
+  // stream without a done event. That is a cancellation, not a stream the
+  // server cut short, and must settle the same way a cancelled tool wait does.
+  const cancelReason: unknown = signal?.aborted ? signal.reason ?? new DOMException("turn cancelled", "AbortError") : null;
+  if (cancelReason && isAbortError(cancelReason)) {
+    return finalizeThrownTurn(lifecycle, cancelReason, ctx.cfg.baseUrl, partialOutput);
+  }
   const incomplete = new StreamIncompleteError();
   lifecycle.finalize("incomplete", {
     message: incomplete.message,
@@ -1096,15 +1139,17 @@ function switchDisposition(target: ModelTarget, brief: string, queueCount: numbe
 }
 
 /** Build a prompt with optional steering and btw context prepended.
- *  Clears steering and btwNotes in the returned result so callers
- *  can use single-shot semantics.  Exported for testing. */
+ *  Several steering notes keep their order, one line each. Clears steering
+ *  and btwNotes in the returned result so callers can use single-shot
+ *  semantics.  Exported for testing. */
 export function buildPromptContext(
   base: string,
-  steering: string | null,
+  steering: string | readonly string[] | null,
   btwNotes: string[],
 ): { prompt: string; steering: string | null; btwNotes: string[] } {
   const ctxParts: string[] = [];
-  if (steering) ctxParts.push(`STEERING: ${steering}`);
+  const steers = steering === null ? [] : typeof steering === "string" ? [steering] : steering;
+  for (const steer of steers) if (steer) ctxParts.push(`STEERING: ${steer}`);
   if (btwNotes.length) ctxParts.push(`NOTE: ${btwNotes.join("; ")}`);
   const prompt = ctxParts.length ? ctxParts.join("\n") + "\n\n" + base : base;
   return { prompt, steering: null, btwNotes: [] };
@@ -1310,7 +1355,12 @@ export async function repl(ctx: AppContext, skillOpts: TurnSkillOptions = {}): P
   let pasteAcc = "";
   let carry = ""; // partial escape sequence held across chunk boundaries
   const queue: ConsoleInput[] = [];
-  let steering: string | null = null;
+  // /steer during a turn goes to that turn's brain when it can acknowledge
+  // it; everything else waits for the next turn and is reported as such.
+  const steerChannel = new SteerChannel((ack) => {
+    process.stdout.write((busy ? "\n" : "") + formatSteerAck(ack) + "\n");
+    if (!busy) repaint();
+  });
   const btwNotes: string[] = [];
   let turnAbort: AbortController | null = null; // live while a local/cloud turn runs
   // Live while a slash command (e.g. /audit, /doctor) is in flight — kept
@@ -1366,10 +1416,16 @@ export async function repl(ctx: AppContext, skillOpts: TurnSkillOptions = {}): P
         } finally { turnAbort = null; }
       }
       const text = input.text;
-      const built = authContinuation ? { prompt: text, steering, btwNotes } : buildPromptContext(text, steering, btwNotes);
+      // An auth continuation replays the saved task verbatim; kept notes wait.
+      const carriedSteers = authContinuation ? [] : steerChannel.takeNextTurnNotes();
+      const built = authContinuation ? { prompt: text } : buildPromptContext(text, carriedSteers, btwNotes);
       const beforeChanges = observedWorkspaceChanges(ctx.flags.cwd);
       const toolResults: ObservedTool[] = [];
-      if (!authContinuation) { steering = built.steering; btwNotes.length = 0; }
+      if (!authContinuation) btwNotes.length = 0;
+      const steerTurn = steerChannel.beginTurn();
+      // How the turn ended, for its steering: a cancel drops unapplied notes
+      // (reported); a failure the operator may retry keeps the carried ones.
+      let steerEnd: "ended" | "cancelled" | "retryable" = "ended";
       viewerState = createViewerState();
       viewerOpen = false;
       viewerLastLines = 0;
@@ -1381,6 +1437,7 @@ export async function repl(ctx: AppContext, skillOpts: TurnSkillOptions = {}): P
           if (authRepair.submissionBlocked) {
             process.stdout.write("Account changed or could not be verified. Use /auth new before sending another hosted task.\n");
             if (!buf.value) buf.insert(text);
+            steerEnd = "retryable";
             return "failed";
           }
           await authRepair.captureAccount();
@@ -1443,13 +1500,14 @@ export async function repl(ctx: AppContext, skillOpts: TurnSkillOptions = {}): P
               viewerOpen = false;
               break;
           }
-        }, redrawInput, { ...skillOpts, onToolResult: tool => toolResults.push(tool) });
+        }, redrawInput, { ...skillOpts, onToolResult: tool => toolResults.push(tool), steer: steerChannel });
         const afterChanges = observedWorkspaceChanges(ctx.flags.cwd);
         continuation.recordTurn(text, toolResults, afterChanges.filter(change => !beforeChanges.includes(change)), outcome.state, !sharedShellResult && !authContinuation);
         if (ctx.flags.json) process.stdout.write(turnOutcomeJson(outcome) + "\n");
         if (outcome.state === "cancelled") {
           queue.length = 0;
           if (!ctx.flags.json) process.stdout.write("\n" + theme.dim("✗ turn aborted") + "\n");
+          steerEnd = "cancelled";
           return "aborted";
         }
         return "completed";
@@ -1462,6 +1520,7 @@ export async function repl(ctx: AppContext, skillOpts: TurnSkillOptions = {}): P
           const outcome = turnOutcomeForError(err);
           if (ctx.flags.json && outcome) process.stdout.write(turnOutcomeJson(outcome) + "\n");
           else process.stdout.write("\n" + theme.dim("✗ turn aborted") + "\n");
+          steerEnd = "cancelled";
           return "aborted";
         }
         // ChatTurnError means the Renderer already painted "✗ <msg>" for the
@@ -1493,9 +1552,18 @@ export async function repl(ctx: AppContext, skillOpts: TurnSkillOptions = {}): P
           buf.clear();
           buf.insert(recovered);
         }
+        // A hosted auth failure saved the prompt with its notes already in it.
+        if (!authFailure) steerEnd = "retryable";
         return "failed";
       } finally {
         turnAbort = null;
+        // Notes that never reached the model are reported either way: kept for
+        // the next turn, or — when the operator cancelled — not retained.
+        if (steerEnd === "cancelled") steerChannel.cancelTurn();
+        else steerChannel.endTurn();
+        if (steerEnd === "retryable") {
+          steerChannel.restoreNextTurnNotes(carriedSteers, `turn ${steerTurn} failed; kept for the retry`);
+        }
       }
     };
 
@@ -1591,10 +1659,11 @@ export async function repl(ctx: AppContext, skillOpts: TurnSkillOptions = {}): P
       // ── mid-turn Enter: bypass commands + type-ahead queueing ──
       if (busy) {
         if (t.startsWith("/steer ")) {
-          steering = t.slice(7).trim() || steering;
           remember(buf.value);
           buf.commit(buf.value);
-          if (steering) process.stdout.write(`\n🎯 Steering set: "${steering}"\n`);
+          // Acknowledged through the channel: accepted/applied by the running
+          // turn, refused, or deferred to the next turn — never assumed.
+          steerChannel.steer(t.slice(7)).catch(() => { /* acks are best-effort output */ });
           return;
         }
         if (t.startsWith("/btw ")) {
@@ -1675,9 +1744,9 @@ export async function repl(ctx: AppContext, skillOpts: TurnSkillOptions = {}): P
       if (t.startsWith("/steer ") || t === "/steer") {
         const guidance = t.slice(6).trim();
         if (!guidance) { process.stdout.write("usage: /steer <guidance>\n"); repaint(); return; }
-        steering = guidance;
-        process.stdout.write(`🎯 Steering set: "${guidance}"\n`);
-        repaint(); return;
+        // No turn is running: kept, in order, for the next one (the ack repaints).
+        steerChannel.steer(guidance).catch(() => { /* acks are best-effort output */ });
+        return;
       }
       if (t.startsWith("/btw ") || t === "/btw") {
         const note = t.slice(4).trim();
@@ -1716,7 +1785,7 @@ export async function repl(ctx: AppContext, skillOpts: TurnSkillOptions = {}): P
               } else process.stdout.write("No safely rejected task is ready. Use /auth status for details.\n");
             } else if (sub === "new") {
               process.stdout.write(authRepair.startNewConversation());
-              queue.length = 0; steering = null; btwNotes.length = 0;
+              queue.length = 0; steerChannel.clearNextTurn(); btwNotes.length = 0;
             } else if (sub === "draft") {
               if (buf.value) process.stdout.write("Current draft is still in the input line; clear it before restoring the earlier draft.\n");
               else if (!heldDraft) process.stdout.write("No earlier type-ahead draft is saved.\n");
 
@@ -4331,8 +4331,8 @@ export const COMMAND_MANIFEST_SOURCE: readonly CommandManifestEntry[] = [
     "compatibilityAliases": [],
     "deprecatedAliases": [],
     "args": "<guidance>",
-    "summary": "mid-task steering for the next turn",
-    "detailedHelp": "/steer <guidance>\nmid-task steering for the next turn",
+    "summary": "steer the running turn if its brain acknowledges it, else the next turn",
+    "detailedHelp": "/steer <guidance>\nsteer the running turn if its brain acknowledges it, else the next turn\nDuring a local turn the note goes to the running brain and is reported as accepted, applied (naming the boundary and any tool calls withheld), or refused. A hosted chat turn has no live control acknowledgement, so the note is kept for the next turn and reported as deferred. Steering never changes tool permissions or approves anything. Use /btw for a side note.",
     "section": "Steering",
     "hidden": false,
     "permissionClass": "unknown",
 
@@ -40,6 +40,26 @@ export interface Brain {
    * treated as its own round.
    */
   modelRound?(): number;
+  /**
+   * Optional: report when accepted steering actually reaches the model. A
+   * brain that cannot say so omits it, and the host never infers "applied"
+   * from an acceptance alone (#283).
+   */
+  onSteerApplied?(listener: (applied: SteerApplied) => void): void;
+}
+
+/** Where accepted steering entered the run (#283). */
+export interface SteerApplied {
+  /** Notes delivered with this model request, oldest first. */
+  notes: number;
+  /**
+   * The safe boundary reached. "model-reply": a reply that arrived after the
+   * steer was held back and never published. "tool-results": every tool call
+   * already handed to the host settled first.
+   */
+  boundary: "model-reply" | "tool-results";
+  /** Tool calls the model selected before the steer that the brain never emitted. */
+  withheldToolCalls: readonly string[];
 }
 
 // A minimal single-consumer async queue: producers push events (from a