@jskit-ai/assistant-core 0.1.237 → 0.1.238

package/examples/conversation/package.json

@@ -8,7 +8,7 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.237",
+    "@jskit-ai/assistant-core": "0.1.238",
     "@jskit-ai/http-runtime": "0.1.242",
     "@jskit-ai/kernel": "0.1.244",
     "@mdi/js": "^7.4.47",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.1.237",
+  "version": "0.1.238",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"

package/src/server/conversation/claudeTurn.js

@@ -593,21 +593,18 @@ export function createClaudeConversationOwner({
     deliveryTiming?.("process-ready");
     if (command && !command.steering) command.signal.throwIfAborted();
     const steering = command ? command.steering === true : Boolean(entry.turn?.active);
-    const sendNow = steering && native.client.supportsSendNow?.() === true;
     if (input.signal?.aborted) throw Object.assign(createError("The goal command was stopped before delivery."), { delivery: "not-sent" });
     if (steering) {
       if (command) {
         await command.beforeDispatch({ threadId: entry.id });
         command.signal.throwIfAborted();
       }
-      try {
-        await entry.nativeTurn.interruptGeneration(command ? entry.process.client : native.client,
-          { ...(command ? { timeoutMs: command.timeoutMs } : {}), sendNow });
-        if (command) command.interrupted = !sendNow;
-      } catch (error) {
+      // A mid-turn message is never an interrupt: Claude Code queues it and
+      // reads it after the running tool call. Only explicit Stop interrupts.
+      try { await entry.nativeTurn.prepareSteering(); }
+      catch (error) {
         if (!command) await entry.nativeTurn.stopProcess(error.message);
-        // Interruption precedes this input's pipe write. Preserve that definite
-        // non-delivery so a failed interrupt cannot strand an attempted receipt.
+        // This precedes the input's pipe write: a refused steer is definitely not sent.
         throw Object.assign(error, { delivery: "not-sent" });
       }
     }
@@ -688,7 +685,7 @@ export function createClaudeConversationOwner({
       else await input.onPromptSending?.({ threadId: entry.id, displayAttachments: input.displayAttachments, turnMetadata: actorMetadata });
       if (input.signal?.aborted) throw Object.assign(createError("The goal command was stopped before delivery."), { delivery: "not-sent" });
       await entry.nativeTurn.send(command ? entry.process.client : native.client, command ? preparation.message(entry, input) : prompt,
-        { messageId: uuid, accept, sendNow, ...(command ? { timeoutMs: command.timeoutMs } : {}) });
+        { messageId: uuid, accept, ...(command ? { timeoutMs: command.timeoutMs } : {}) });
     } catch (error) {
       if (!command) await entry.nativeTurn.stopProcess(error.message);
       throw error;
@@ -1026,11 +1023,11 @@ export function createClaudeConversationOwner({
     active.steer = async ({ input, beforeDispatch, accept, onNativeReceipt, onReceiptPersisted, deliveryTiming }) => {
       await ready.promise;
       const nativeDispatch = { active, signal, beforeDispatch, accept, onNativeReceipt, onReceiptPersisted, deliveryTiming,
-        timeoutMs, steering: true, interrupted: false, attempted: false, admitted: false };
+        timeoutMs, steering: true, attempted: false, admitted: false };
       try { await dispatch(control, { input, context, signal }, { acquire, entry, dispatch: nativeDispatch }); }
       catch (error) {
         if (nativeDispatch.attempted && !nativeDispatch.admitted && error.delivery !== "not-sent") error.delivery = "uncertain";
-        if (nativeDispatch.interrupted || nativeDispatch.attempted) completion.reject(error);
+        if (nativeDispatch.attempted) completion.reject(error);
         throw error;
       }
     };
@@ -1142,6 +1139,9 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
   const assistantRoles = new Map();
   const admissions = new Map();
   const inFlight = new Set();
+  // Inputs Claude has begun reading. A queued steer joins the running loop, so
+  // one result can finish several of them; queued-only input stays in flight.
+  const startedInputs = new Set();
   const tasks = new Set();
   let turnId = "";
   let messageId = "";
@@ -1153,7 +1153,6 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
   let generation = 0;
   let stopped = false;
   let cancelling = false;
-  let steering;
   let maximumOutput = 4 * 1024 * 1024;
   let inputOwner = null;
   let acceptedInput = null;
@@ -1418,11 +1417,13 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       if (frame.type === "user" && !inFlight.has(uuid) && !admissions.has(uuid)) return;
       // Native notifications have their own lifecycle UUIDs, including work
       // folded into this input. They must not steal its receipt/result owner.
-      if ((frame.state === "started" || frame.type === "user") && inFlight.has(uuid)) currentCommandId = uuid;
-      if (frame.state === "completed") inFlight.delete(uuid);
-      if (frame.state === "cancelled" && steering) {
+      if ((frame.state === "started" || frame.type === "user") && inFlight.has(uuid)) {
+        currentCommandId = uuid;
+        startedInputs.add(uuid);
+      }
+      if (frame.state === "completed") {
         inFlight.delete(uuid);
-        steering.resolve();
+        startedInputs.delete(uuid);
       }
       if (frame.state === "queued" || frame.type === "user") {
         const pending = admissions.get(uuid);
@@ -1559,10 +1560,8 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
           } : {}) });
       }
       inFlight.delete(currentCommandId);
-      if (steering) {
-        steering.resolve();
-        return;
-      }
+      for (const uuid of startedInputs) inFlight.delete(uuid);
+      startedInputs.clear();
       if (cancelling) return;
       outcome = { status: interrupted ? "interrupted" : failed ? "failed" : "completed", error: message };
       // The reply is final, but native background tasks still own the turn
@@ -1601,6 +1600,7 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
     }
     admissions.clear();
     inFlight.clear();
+    startedInputs.clear();
     tasks.clear();
     // Verified process cleanup can precede Claude's terminal generation frame.
     // Retain already displayed text for the existing transcript reader, with
@@ -1616,7 +1616,6 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
     }
     pendingAssistantMessages.clear();
     assistantRoles.clear();
-    steering?.reject(failure(reason));
     if (active) outcome = { status: "interrupted", error: reason };
     active = false;
     phase = "";
@@ -1670,7 +1669,7 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       acceptedInput = null;
       clearFinalAssistantResult();
     },
-    async send(client, message, { messageId: uuid, accept, timeoutMs = 30_000, sendNow = false } = {}) {
+    async send(client, message, { messageId: uuid, accept, timeoutMs = 30_000 } = {}) {
       if (!active || stopped || cancelling) throw Object.assign(
         failure("Claude has no active turn for this message.", !active && !stopped && !cancelling
           ? "conversation_steer_turn_finished" : "assistant_claude_turn_failed"),
@@ -1691,7 +1690,7 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
       )), timeoutMs);
       admissions.set(uuid, { ...admitted, accept, timer, receiptOwner });
       try {
-        await Promise.all([client.send(message, { messageId: uuid, sessionId: conversationId, ...(sendNow ? { sendNow: true } : {}) }), admitted.promise]);
+        await Promise.all([client.send(message, { messageId: uuid, sessionId: conversationId }), admitted.promise]);
       } catch (error) {
         if (inputOwner === receiptOwner) invalidateFinalAssistantResult();
         throw error;
@@ -1699,49 +1698,22 @@ export function createClaudeConversationTurn({ conversationId, onEvent = async (
         clearTimeout(timer);
       }
     },
-    async interruptGeneration(client, { timeoutMs = 30_000, sendNow = false } = {}) {
-      if (!active || steering || cancelling) {
-        const completed = !active && !steering && !stopped && !cancelling && outcome?.status === "completed";
+    async prepareSteering() {
+      if (!active || cancelling) {
+        const completed = !active && !stopped && !cancelling && outcome?.status === "completed";
         throw Object.assign(failure("This Claude turn cannot accept steering now.", completed
           ? "conversation_steer_turn_finished" : "assistant_claude_turn_failed"),
         { delivery: "not-sent", ...(completed ? { statusCode: 409 } : {}) });
       }
-      // Targeted Send now admits the new input before asking the native loop to
-      // make way; unlike plain Stop it preserves background agents. A completed
-      // main loop also has no further interruption result to wait for.
-      if (sendNow || outcome && inFlight.size === 0) {
-        // The next input owns completion now. A task finishing during host
-        // preparation must not settle this turn using the previous result.
-        outcome = null;
-        acceptedInput = null;
-        clearFinalAssistantResult();
-        await publish({ type: "diagnostic", stage: sendNow ? "steering_send_now" : "steering_background_only", backgroundTasks: tasks.size });
-        return;
-      }
-      // Streaming user input otherwise queues behind the entire running turn.
-      // Claude's supported steering path interrupts generation, then continues
-      // the same native history with the new instruction.
+      // Claude Code acknowledges streamed input as queued and folds it into the
+      // running turn after the current tool call, or starts it once the main
+      // loop is idle. Interrupting instead would kill a running foreground tool.
+      // The next input owns completion now: a result or task finishing before
+      // it starts must not settle this turn with the previous answer.
+      outcome = null;
       acceptedInput = null;
       clearFinalAssistantResult();
-      steering = Promise.withResolvers();
-      let timer;
-      try {
-        await publish({ type: "diagnostic", stage: "steering_requested", pendingCommands: inFlight.size, backgroundTasks: tasks.size });
-        await Promise.all([client.interrupt(), Promise.race([
-          steering.promise,
-          new Promise((_, reject) => {
-            timer = setTimeout(() => reject(Object.assign(failure(
-              "Claude did not confirm the interrupted generation. This instruction was not sent; retry after reconnecting.",
-              "assistant_claude_interrupt_timeout"
-            ), { statusCode: 503 })), timeoutMs);
-          })
-        ])]);
-        await publish({ type: "diagnostic", stage: "steering_confirmed", pendingCommands: inFlight.size, backgroundTasks: tasks.size });
-      } catch (error) {
-        await publish({ type: "diagnostic", stage: "steering_failed", pendingCommands: inFlight.size, backgroundTasks: tasks.size });
-        throw error;
-      }
-      finally { clearTimeout(timer); steering = null; }
+      await publish({ type: "diagnostic", stage: "steering_queued", pendingCommands: inFlight.size, backgroundTasks: tasks.size });
     },
     async cancel(client, stopProcess) {
       try {

package/test/claudeConversationSession.test.js

@@ -472,7 +472,7 @@ test("Claude reports common work and compaction phases and clears phase after se
   assert.deepEqual(phases, ["preparing", "working", "compacting", "working", ""]);
 });
 
-test("Claude steering interrupts generation and admits a distinct message without replacing its process", { timeout: 30_000 }, async t => {
+test("Claude steering queues a distinct message on the running process without interrupting it", { timeout: 30_000 }, async t => {
   const f = await fixture(t);
   const started = Promise.withResolvers();
   const events = [];
@@ -493,7 +493,7 @@ test("Claude steering interrupts generation and admits a distinct message withou
   const trace = await f.trace();
   assert.equal(trace.filter(row => row.args?.includes("--print")).length, 1);
   assert.equal(trace.filter(row => row.frame?.type === "user").length, 2);
-  assert.equal(trace.filter(row => row.frame?.request?.subtype === "interrupt").length, 1);
+  assert.equal(trace.filter(row => row.frame?.request?.subtype === "interrupt").length, 0, "Steering queues behind running work and never interrupts it");
   assert.equal((await f.conversation.send(steering)).duplicate, true);
   for (const turn of state.conversationLog) assert.equal(turn.assistant.messageId,
     events.find(event => event.role === "assistant" && event.status === "complete" && event.turnId === turn.turnId).messageId);
@@ -1193,7 +1193,7 @@ test("Claude accepts a goal during an active turn through the existing steering
   assert.equal(trace.filter(row => row.args?.includes("--print")).length, 1);
   assert.deepEqual(trace.filter(row => row.frame?.type === "user").map(row => row.frame.message.content),
     ["wait", "/goal Finish the current work"]);
-  assert.equal(trace.filter(row => row.frame?.request?.subtype === "interrupt").length, 1);
+  assert.equal(trace.filter(row => row.frame?.request?.subtype === "interrupt").length, 0, "Steering queues behind running work and never interrupts it");
 });
 
 test("Claude rejects reserved goals and waits for ordinary Send to deliver a replacement briefing", async t => {
@@ -2290,7 +2290,7 @@ test("completed Claude native-tool tracking preserves ordinary native steering i
     const trace = await f.trace();
     assert.equal(trace.filter(row => row.args?.includes("--print")).length, 1);
     assert.equal(trace.filter(row => row.frame?.type === "user").length, 2);
-    assert.equal(trace.filter(row => row.frame?.request?.subtype === "interrupt").length, 1);
+    assert.equal(trace.filter(row => row.frame?.request?.subtype === "interrupt").length, 0, "Steering queues behind running work and never interrupts it");
     assert.equal(f.effects(), 0);
   } finally { await f.close(); }
 });

package/test/claudeTurn.test.js

@@ -163,30 +163,64 @@ test("a pipe write is not admission; queued and replayed acknowledgements persis
   turn.stop();
 });
 
-test("steering waits for the generation's terminal event after the control acknowledgement", async () => {
+for (const lifecycle of [true, false]) test(`steering queues behind the running tool without an interrupt and one joined result completes both inputs, lifecycle=${lifecycle}`, async () => {
   const { turn, send, client, events } = fixture();
-  await send();
-  let interrupted = false;
-  const steering = turn.interruptGeneration(client).then(() => { interrupted = true; });
-  await Promise.resolve();
-  assert.equal(interrupted, false);
-  await turn.receive({ type: "result", subtype: "success", terminal_reason: "aborted_streaming", result: "" });
+  const first = claudeNativeMessageId("first");
+  const followUp = claudeNativeMessageId("follow-up");
+  const writes = [];
+  let interrupts = 0;
+  client.interrupt = async () => { interrupts++; };
+  // Claude Code 2.1.307 acknowledges streamed input as queued at once and
+  // replays it only when its loop reads it; older CLIs only replay it.
+  client.send = async (_message, input) => {
+    writes.push(input);
+    if (lifecycle) await turn.receive({ type: "command_lifecycle", command_uuid: input.messageId, state: "queued" });
+  };
+  const sending = send();
+  if (lifecycle) await turn.receive({ type: "command_lifecycle", command_uuid: first, state: "started" });
+  await turn.receive({ type: "user", uuid: first });
+  await sending;
+  await turn.receive({ type: "assistant", uuid: "tool-call", message: { id: "tool-api", stop_reason: "tool_use",
+    content: [{ type: "tool_use", id: "deploy", name: "Bash", input: { command: "eb deploy" } }] } });
+  await turn.prepareSteering();
+  // Without lifecycle frames the replay is the only receipt, so it waits for the tool.
+  const steering = send("follow-up");
+  if (lifecycle) await steering;
+  assert.equal(interrupts, 0, "A mid-turn message never interrupts the running tool");
+  assert.deepEqual(writes.map(input => Object.keys(input).sort()), [["messageId", "sessionId"], ["messageId", "sessionId"]],
+    "The follow-up is a plain user message, never Send now");
+  assert.equal(turn.read().active, true);
+  // Captured order: the tool finishes, Claude reads the queued input inside
+  // the same loop, answers both, then completes the queued and original input.
+  await turn.receive({ type: "user", uuid: "tool-result", message: { content: [{ type: "tool_result", tool_use_id: "deploy", content: "Deployed" }] } });
+  await turn.receive({ type: "user", uuid: followUp });
   await steering;
-  assert.equal(events.some(event => event.type === "settled"), false);
-  await send("follow-up");
-  await turn.receive({ type: "result", subtype: "success", result: "Revised answer" });
-  assert.equal(turn.read().text, "Revised answer");
-  assert.equal(turn.read().status, "completed");
+  if (lifecycle) await turn.receive({ type: "command_lifecycle", command_uuid: followUp, state: "started" });
+  await turn.receive({ type: "assistant", uuid: "answer", message: { id: "answer-api", stop_reason: "end_turn",
+    content: [{ type: "text", text: "Deployed; still on track." }] } });
+  if (lifecycle) {
+    await turn.receive({ type: "command_lifecycle", command_uuid: followUp, state: "completed" });
+    assert.equal(turn.read().active, true, "The queued input's completion cannot settle the running loop");
+  }
+  await turn.receive({ type: "result", subtype: "success", terminal_reason: "completed", result: "Deployed; still on track." });
+  if (lifecycle) await turn.receive({ type: "command_lifecycle", command_uuid: first, state: "completed" });
+  assert.deepEqual([turn.read().active, turn.read().status, turn.read().text, turn.read().pendingCommands],
+    [false, "completed", "Deployed; still on track.", 0]);
+  assert.equal(events.filter(event => event.type === "settled").length, 1);
+  const answer = events.findLast(event => event.type === "message" && event.message.complete && event.message.role === "assistant");
+  assert.equal(answer.message.userId, followUp, "The joined answer belongs to the newest accepted input");
+  assert.equal(interrupts, 0);
 });
 
-test("interrupted Claude output keeps its input identity after a follow-up is accepted", async t => {
+test("Claude output before a queued follow-up keeps its input identity after the follow-up is accepted", async t => {
   const f = await publishedClaudeFixture(t);
   await f.owner.send(f.entry, { messageId: "first", message: "First request" });
   const native = f.processes.at(-1);
   await native.options.onEvent({ type: "stream_event", event: { type: "message_start", message: { id: "first-api" } } });
   await native.options.onEvent({ type: "stream_event", event: { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } } });
   await native.options.onEvent({ type: "stream_event", event: { type: "content_block_delta", index: 0, delta: { text: "FIRST-PARTIAL" } } });
-  await native.options.onEvent({ type: "assistant", uuid: "first-output", message: { id: "first-api", content: [{ type: "text", text: "FIRST-PARTIAL" }] } });
+  await native.options.onEvent({ type: "assistant", uuid: "first-output", message: { id: "first-api", stop_reason: "tool_use", content: [{ type: "text", text: "FIRST-PARTIAL" }] } });
+  native.client.interrupt = async () => assert.fail("A follow-up is queued, never an interrupt");
   await f.owner.send(f.entry, { messageId: "second", message: "Second request" });
   await native.options.onEvent({ type: "assistant", uuid: "second-output", message: { id: "second-api", content: [{ type: "text", text: "SECOND-OK" }], stop_reason: "end_turn" } });
   await native.options.onEvent({ type: "result", subtype: "success", result: "SECOND-OK" });
@@ -337,22 +371,34 @@ for (const background of [false, true]) test(`folded native command cannot stran
   assert.equal(events.filter(event => event.type === "settled").length, 1);
 });
 
-test("folded lifecycle completion cannot acknowledge interruption before the generation result", async () => {
-  const { turn, send, client } = fixture();
+test("a steer queued during the final reply runs next; neither that result nor folded work settles it", async () => {
+  const { turn, send, client, events } = fixture();
+  client.interrupt = async () => assert.fail("A mid-turn message never interrupts");
+  client.send = async (_message, input) => {
+    await turn.receive({ type: "command_lifecycle", command_uuid: input.messageId, state: "queued" });
+  };
+  const first = claudeNativeMessageId("first");
+  const goal = claudeNativeMessageId("goal");
   await send();
+  await turn.receive({ type: "command_lifecycle", command_uuid: first, state: "started" });
+  await turn.receive({ type: "user", uuid: first });
   await turn.receive({ type: "command_lifecycle", command_uuid: "internal-notification", state: "started" });
-  let confirmed = false;
-  const steering = turn.interruptGeneration(client).then(() => { confirmed = true; });
   await turn.receive({ type: "command_lifecycle", command_uuid: "internal-notification", state: "completed" });
-  await Promise.resolve();
-  assert.equal(confirmed, false);
-  await turn.receive({ type: "result", subtype: "success", terminal_reason: "aborted_streaming", result: "" });
-  await steering;
+  await turn.receive({ type: "assistant", uuid: "story", message: { id: "story-api", stop_reason: "end_turn", content: [{ type: "text", text: "Story" }] } });
+  await turn.prepareSteering();
   await send("goal");
-  await turn.receive({ type: "result", subtype: "success", result: "Goal accepted" });
-  await turn.receive({ type: "command_lifecycle", command_uuid: claudeNativeMessageId("goal"), state: "completed" });
+  // Captured 2.1.307 order when input arrives after the last model request.
+  await turn.receive({ type: "result", subtype: "success", terminal_reason: "completed", result: "Story" });
+  await turn.receive({ type: "command_lifecycle", command_uuid: first, state: "completed" });
+  assert.equal(turn.read().active, true, "The queued input still needs its own run");
+  await turn.receive({ type: "command_lifecycle", command_uuid: goal, state: "started" });
+  await turn.receive({ type: "user", uuid: goal });
+  await turn.receive({ type: "assistant", uuid: "goal-answer", message: { id: "goal-api", stop_reason: "end_turn", content: [{ type: "text", text: "Goal accepted" }] } });
+  await turn.receive({ type: "result", subtype: "success", terminal_reason: "completed", result: "Goal accepted" });
+  await turn.receive({ type: "command_lifecycle", command_uuid: goal, state: "completed" });
   assert.equal(turn.read().pendingCommands, 0);
-  assert.equal(turn.read().status, "completed");
+  assert.deepEqual([turn.read().status, turn.read().text], ["completed", "Goal accepted"]);
+  assert.equal(events.filter(event => event.type === "settled").length, 1);
 });
 
 test("late input completion cannot settle a newer native continuation", async () => {
@@ -451,7 +497,7 @@ test("Claude can steer background-only work without waiting for an already compl
   await turn.receive({ type: "system", subtype: "task_started", task_id: "build", task_type: "local_bash" });
   await turn.receive({ type: "result", subtype: "success", result: "Build started" });
   client.interrupt = () => assert.fail("There is no active generation to interrupt");
-  await turn.interruptGeneration(client, { timeoutMs: 5 });
+  await turn.prepareSteering();
   await send("follow-up");
   await turn.receive({ type: "system", subtype: "task_notification", task_id: "build", status: "completed" });
   assert.equal(turn.read().active, true, "The new human input still needs its own result");
@@ -483,7 +529,7 @@ test("Claude steering survives background completion while the follow-up is bein
   await turn.receive({ type: "system", subtype: "task_started", task_id: "build", task_type: "local_bash" });
   await turn.receive({ type: "result", subtype: "success", result: "Build started" });
   client.interrupt = () => assert.fail("The generation has already completed");
-  await turn.interruptGeneration(client);
+  await turn.prepareSteering();
   await turn.receive({ type: "system", subtype: "task_notification", task_id: "build", status: "completed" });
   assert.equal(events.some(event => event.type === "settled"), false, "The reserved steering input still needs admission");
   await send("follow-up");
@@ -1504,24 +1550,20 @@ for (const tools of [true, false]) test(`Claude supplied common runtime checkpoi
   if (tools) f.admissions.at(-1).assertCompletionCurrent();
 });
 
-for (const sendNow of [false, true]) test(`Claude supplied common completion joins accepted steering and checkpoints only its own final, sendNow=${sendNow}`, { timeout: 10_000 }, async t => {
+for (const worker of [false, true]) test(`Claude supplied common completion joins accepted steering and checkpoints only its own final, worker=${worker}`, { timeout: 10_000 }, async t => {
   const f = await suppliedCommonFixture(t);
   await sendCommon(f, "common-first");
-  if (sendNow) {
-    const native = f.entry.process;
-    const send = native.client.send;
-    native.client.supportsSendNow = () => true;
-    native.client.interrupt = async () => { throw Error("Steering must preserve the background worker"); };
-    await f.frame({ type: "system", subtype: "task_started", task_id: "common-worker" });
-    native.client.send = async (message, input) => {
-      assert.equal(input.sendNow, true);
-      await f.frame({ type: "command_lifecycle", command_uuid: input.messageId, state: "queued" });
-      await f.frame({ type: "result", subtype: "error_during_execution", is_error: true,
-        terminal_reason: "aborted_tools", user_message_uuid: claudeNativeMessageId("common-first") });
-      await f.frame({ type: "command_lifecycle", command_uuid: input.messageId, state: "started" });
-      await send(message, input);
-    };
-  }
+  const native = f.entry.process;
+  const send = native.client.send;
+  native.client.supportsSendNow = () => true;
+  native.client.interrupt = async () => { throw Error("Steering must not interrupt running tools or workers"); };
+  if (worker) await f.frame({ type: "system", subtype: "task_started", task_id: "common-worker" });
+  native.client.send = async (message, input) => {
+    assert.equal(input.sendNow, undefined, "Steering is a plain queued user message");
+    await f.frame({ type: "command_lifecycle", command_uuid: input.messageId, state: "queued" });
+    await f.frame({ type: "command_lifecycle", command_uuid: input.messageId, state: "started" });
+    await send(message, input);
+  };
   await f.loadContract("first-contract");
   const first = f.admissions.at(-1);
   const legacyCompletion = f.entry.completion.promise;
@@ -1535,7 +1577,7 @@ for (const sendNow of [false, true]) test(`Claude supplied common completion joi
   await f.loadContract("successor-contract");
   assert.throws(() => first.assertCompletionCurrent(), { code: "conversation_tool_request_retired" });
   await f.frame({ type: "result", subtype: "success", result: "The successor question", uuid: "successor-final" });
-  if (sendNow) {
+  if (worker) {
     assert.equal(f.checkpoints.length, 0, "Foreground completion cannot checkpoint live background work");
     await f.frame({ type: "system", subtype: "task_notification", task_id: "common-worker", status: "completed" });
     assert.equal(f.checkpoints.length, 0);
@@ -1758,25 +1800,18 @@ test("only natural completion marks a rejected steer eligible for ordinary Send;
   }
 });
 
-test("interruption before a late steer distinguishes completed work from Stop, cancellation and idle state", async () => {
-  for (const ending of ["complete", "stop", "cancel", "idle", "steering"]) {
+test("a late steer distinguishes completed work from Stop, cancellation and idle state", async () => {
+  for (const ending of ["complete", "stop", "cancel", "idle"]) {
     const f = fixture();
     await f.send();
-    let firstInterrupt;
     if (ending === "complete" || ending === "idle") {
       await f.turn.receive({ type: "result", subtype: "success", result: "Done" });
       if (ending === "idle") f.turn.reset();
     } else if (ending === "stop") f.turn.stop();
-    else if (ending === "cancel") await f.turn.interrupt(f.client);
-    else {
-      const began = Promise.withResolvers();
-      f.client.interrupt = async () => { began.resolve(); };
-      firstInterrupt = f.turn.interruptGeneration(f.client).catch(() => {});
-      await began.promise;
-    }
+    else await f.turn.interrupt(f.client);
     let interrupts = 0;
     f.client.interrupt = async () => { interrupts += 1; };
-    await assert.rejects(f.turn.interruptGeneration(f.client), error => {
+    await assert.rejects(f.turn.prepareSteering(), error => {
       assert.equal(error.delivery, "not-sent");
       assert.equal(error.code, ending === "complete" ? "conversation_steer_turn_finished" : "assistant_claude_turn_failed");
       assert.equal(error.statusCode, ending === "complete" ? 409 : undefined);
@@ -1784,10 +1819,23 @@ test("interruption before a late steer distinguishes completed work from Stop, c
     });
     assert.equal(interrupts, 0);
     f.turn.stop();
-    await firstInterrupt;
   }
 });
 
+test("consecutive steers queue together without waiting for or sending an interrupt", async () => {
+  const { turn, send, client, events } = fixture();
+  client.interrupt = async () => assert.fail("Steering never interrupts");
+  await send();
+  for (const id of ["second", "third"]) {
+    await turn.prepareSteering();
+    await send(id);
+  }
+  assert.equal(turn.read().pendingCommands, 3);
+  await turn.receive({ type: "result", subtype: "success", result: "All three handled" });
+  assert.deepEqual([turn.read().status, turn.read().pendingCommands], ["completed", 0]);
+  assert.deepEqual(events.filter(event => event.type === "diagnostic" && event.stage === "steering_queued").length, 2);
+});
+
 test("folded internal command preserves the original published answer owner", async t => {
   const f = await publishedClaudeFixture(t);
   await f.send();
@@ -1800,28 +1848,21 @@ test("folded internal command preserves the original published answer owner", as
 });
 
 
-test("failed interruption reports definite non-delivery after the original process cleanup", async t => {
+test("a steer never depends on the interrupt control: an unresponsive interrupt cannot fail or stop it", async t => {
   const f = await publishedClaudeFixture(t);
   await f.send("original-input");
-  let writes = 0;
-  f.entry.process.client.send = async () => { writes++; };
-  f.entry.process.client.interrupt = async () => { throw new Error("Interrupt was not acknowledged"); };
-  await assert.rejects(f.send("goal-input"), error => error.delivery === "not-sent" &&
-    error.message === "Interrupt was not acknowledged");
-  assert.equal(writes, 0);
-  assert.equal(f.entry.process, null, "The original stop owner still proves cleanup before returning");
-});
-
-test("interrupt confirmation timeout is a recoverable typed failure, not a generic server error", async () => {
-  const { turn, send, client } = fixture();
-  await send();
-  await assert.rejects(turn.interruptGeneration(client, { timeoutMs: 5 }), error =>
-    error.code === "assistant_claude_interrupt_timeout" && error.statusCode === 503 && /not sent/.test(error.message));
-  turn.stop();
+  const native = f.entry.process;
+  let interrupts = 0;
+  native.client.interrupt = async () => { interrupts++; throw new Error("Interrupt was not acknowledged"); };
+  const receipt = await f.send("steer-input");
+  assert.deepEqual([receipt.delivered, receipt.deliveryMode], [true, "steer"]);
+  assert.equal(interrupts, 0);
+  assert.equal(f.entry.process, native, "Steering keeps the running process and its tools");
+  assert.equal(f.entry.nativeTurn.read().active, true);
 });
 
 
-test("failed cleanup after interrupt failure retains the cleanup error and execution custody", async t => {
+test("failed Stop cleanup after interrupt failure retains the cleanup error and execution custody", async t => {
   const f = await publishedClaudeFixture(t);
   await f.send("original-input");
   const native = f.entry.process;
@@ -1829,8 +1870,7 @@ test("failed cleanup after interrupt failure retains the cleanup error and execu
   native.client.interrupt = async () => { throw new Error("Interrupt was not acknowledged"); };
   native.stop = async () => ({ scopeEmpty: false, exited: false });
   try {
-    await assert.rejects(f.send("goal-input"), error => error.code === "claude_stop_unconfirmed" &&
-      error.delivery !== "not-sent");
+    await assert.rejects(f.owner.interrupt(f.entry), error => error.code === "claude_stop_unconfirmed");
     assert.equal(f.entry.process, native);
     assert.ok(f.entry.executionId);
   } finally { native.stop = originalStop; }
@@ -2194,7 +2234,7 @@ test("Claude goal command proof survives only evaluations of its own condition",
   assert.equal(changed.goalCommandId, null, "an old command cannot prove a different goal");
 });
 
-for (const action of ["steer", "set", "resume"]) test(`Claude ${action} uses targeted Send now without cancelling background workers`, async t => {
+for (const action of ["steer", "set", "resume"]) test(`Claude ${action} queues a plain message without Stop or Send now, preserving the running tool and background workers`, async t => {
   const f = await publishedClaudeFixture(t);
   if (action === "resume") await f.owner.updateGoal(f.entry, { action: "set", objective: "Finish checks", messageId: "first" });
   else await f.send("first");
@@ -2205,13 +2245,11 @@ for (const action of ["steer", "set", "resume"]) test(`Claude ${action} uses tar
   let stops = 0;
   native.client.interrupt = async () => { stops++; throw Error("A steer must not send Stop"); };
   native.client.send = async (message, input) => {
-    assert.equal(input.sendNow, true);
-    // Native 2.1.289 may end the foreground generation before consuming the
-    // queued goal. Its background task remains alive throughout this sequence.
+    assert.equal(input.sendNow, undefined, "An advertised Send now capability is still not used for steering");
+    // Claude 2.1.307 acknowledges the input as queued and reads it after the
+    // running tool call. Its background task remains alive throughout.
     await f.frame({ type: "command_lifecycle", command_uuid: input.messageId, state: "queued" });
-    await f.frame({ type: "result", subtype: "error_during_execution", is_error: true,
-      terminal_reason: "aborted_tools", user_message_uuid: claudeNativeMessageId("first") });
-    assert.equal(f.entry.nativeTurn.read().active, true, "Old result cannot finish a queued input or its worker");
+    assert.equal(f.entry.nativeTurn.read().active, true, "Queued input keeps the running turn and its worker");
     await f.frame({ type: "command_lifecycle", command_uuid: input.messageId, state: "started" });
     await send(message, input);
   };