@autohq/cli 0.1.449 → 0.1.451

package/dist/agent-bridge.js

@@ -30825,7 +30825,7 @@ Object.assign(lookup, {
 // package.json
 var package_default = {
   name: "@autohq/cli",
-  version: "0.1.449",
+  version: "0.1.451",
   license: "SEE LICENSE IN README.md",
   publishConfig: {
     access: "public"
@@ -70697,8 +70697,7 @@ var AgentBridgeOutputBuffer = class {
     await this.emitUiMessagePartSnapshots(context, projection.chunk, {
       coveredSeq: this.outputSeq
     });
-    const toolEntry = legacyToolEntry(projection.chunk);
-    if (toolEntry) {
+    for (const toolEntry of legacyToolEntries(projection.chunk)) {
       await this.enqueueProjectionAndDrain(context, {
         type: "entry",
         entry: toolEntry
@@ -71177,73 +71176,112 @@ var UiMessageAssembler = class {
 function isTerminalUiMessageChunk(chunk) {
   return chunk.type === "finish" || chunk.type === "error" || chunk.type === "abort";
 }
-function legacyToolEntry(chunk) {
+function legacyToolEntries(chunk) {
   switch (chunk.type) {
     case "tool-input-available":
       if (chunk.toolName === ASK_USER_QUESTION_TOOL_NAME) {
-        return null;
+        return [];
       }
-      return {
-        role: "assistant",
-        kind: "tool_call",
-        content: {
-          parts: [
-            {
-              type: "tool_call",
-              toolCallId: legacyToolCallId(chunk.toolCallId),
-              name: chunk.toolName,
-              input: toJsonValue(chunk.input)
-            }
-          ]
+      return [
+        {
+          role: "assistant",
+          kind: "tool_call",
+          content: {
+            parts: [
+              {
+                type: "tool_call",
+                toolCallId: legacyToolCallId(chunk.toolCallId),
+                name: chunk.toolName,
+                input: toJsonValue(chunk.input)
+              }
+            ]
+          }
         }
-      };
+      ];
+    case "tool-input-error":
+      return [
+        {
+          role: "assistant",
+          kind: "tool_call",
+          content: {
+            parts: [
+              {
+                type: "tool_call",
+                toolCallId: legacyToolCallId(chunk.toolCallId),
+                name: chunk.toolName,
+                input: toJsonValue(chunk.input)
+              }
+            ]
+          }
+        },
+        {
+          role: "tool",
+          kind: "tool_result",
+          content: {
+            parts: [
+              {
+                type: "tool_result",
+                toolUseId: legacyToolCallId(chunk.toolCallId),
+                output: chunk.errorText,
+                isError: true
+              }
+            ]
+          }
+        }
+      ];
     case "tool-output-available":
-      return {
-        role: "tool",
-        kind: "tool_result",
-        content: {
-          parts: [
-            {
-              type: "tool_result",
-              toolUseId: legacyToolCallId(chunk.toolCallId),
-              output: toJsonValue(chunk.output),
-              isError: false
-            }
-          ]
+      return [
+        {
+          role: "tool",
+          kind: "tool_result",
+          content: {
+            parts: [
+              {
+                type: "tool_result",
+                toolUseId: legacyToolCallId(chunk.toolCallId),
+                output: toJsonValue(chunk.output),
+                isError: false
+              }
+            ]
+          }
         }
-      };
+      ];
     case "tool-output-error":
-      return {
-        role: "tool",
-        kind: "tool_result",
-        content: {
-          parts: [
-            {
-              type: "tool_result",
-              toolUseId: legacyToolCallId(chunk.toolCallId),
-              output: errorOutput(chunk.errorText),
-              isError: true
-            }
-          ]
+      return [
+        {
+          role: "tool",
+          kind: "tool_result",
+          content: {
+            parts: [
+              {
+                type: "tool_result",
+                toolUseId: legacyToolCallId(chunk.toolCallId),
+                output: errorOutput(chunk.errorText),
+                isError: true
+              }
+            ]
+          }
         }
-      };
+      ];
     case "tool-output-denied":
-      return {
-        role: "tool",
-        kind: "tool_result",
-        content: {
-          parts: [
-            {
-              type: "tool_result",
-              toolUseId: legacyToolCallId(chunk.toolCallId),
-              output: { denied: true },
-              isError: true
-            }
-          ]
+      return [
+        {
+          role: "tool",
+          kind: "tool_result",
+          content: {
+            parts: [
+              {
+                type: "tool_result",
+                toolUseId: legacyToolCallId(chunk.toolCallId),
+                output: { denied: true },
+                isError: true
+              }
+            ]
+          }
         }
-      };
+      ];
     default:
-      return null;
+      return [];
   }
 }
 function legacyToolCallId(toolCallId) {
@@ -71451,6 +71489,10 @@ function jsonRecordString2(value2, key) {
 
 // src/commands/agent-bridge/harness/claude-code/projector.ts
 var ClaudeCodeProjector = class {
+  constructor(input = {}) {
+    this.input = input;
+  }
+  input;
   currentMessageId = null;
   // The turn's UI message id. Claude emits a `message_start` per assistant
   // message, but a tool-using turn spans several (message A with the tool call,
@@ -71469,13 +71511,17 @@ var ClaudeCodeProjector = class {
   // real turn failure (FRA-3548). Cleared on every result and on the next
   // message_start so a stale marker can never reclassify a later failure.
   interruptMarkerSeen = false;
-  project(message) {
+  project(message, context = {}) {
     if (isClaudeCodeInterruptMarker(message)) {
       this.interruptMarkerSeen = true;
     }
     if (message.type === "stream_event") {
       return this.projectStreamEvent(message);
     }
+    const interruptContext = {
+      marker: this.interruptMarkerSeen,
+      bridge: context.bridgeInterruptSettling === true
+    };
     const parsed = parseClaudeCodeStreamRecord(message);
     const snapshotMessageId = assistantSnapshotMessageId(message);
     const suppressStreamed = snapshotMessageId !== null && this.streamedMessageIds.has(snapshotMessageId);
@@ -71487,18 +71533,28 @@ var ClaudeCodeProjector = class {
         return [];
       }
       return conversationProjectionToUiChunks(entry, {
-        interrupted: this.interruptMarkerSeen
+        interruptContext,
+        emitDiagnostic: this.input.writeOutput
       });
     });
     if (parsed.result) {
-      outputs.push(...this.endActiveParts(), ...this.finishActiveToolInputs());
-      this.currentMessageId = null;
-      this.activeResponseMessageId = null;
+      const interrupted = this.isInterruptCancellation(
+        parsed.result,
+        interruptContext
+      );
+      const failActiveInputs = parsed.result.isError && !interrupted;
       outputs.push(
-        projectClaudeCodeResult(parsed.result, {
-          interrupted: this.isInterruptCancellation(parsed.result)
-        })
+        ...this.endActiveParts(),
+        ...failActiveInputs ? this.failActiveToolInputs() : this.finishActiveToolInputs()
       );
+      this.currentMessageId = null;
+      this.activeResponseMessageId = null;
+      if (interrupted) {
+        this.input.writeOutput?.(
+          `agent_bridge_claude_result_interrupt_cancellation gate=${interruptGate(interruptContext)}`
+        );
+      }
+      outputs.push(projectClaudeCodeResult(parsed.result, { interrupted }));
       this.interruptMarkerSeen = false;
     }
     return outputs;
@@ -71508,13 +71564,16 @@ var ClaudeCodeProjector = class {
   // surfaces as a diagnostic-only `error_during_execution`. Treating that as a
   // turn failure fed the FRA-3548 redelivery loop (the bridge redelivered a
   // message the SDK was actively answering), so a failed result bracketed by
-  // the SDK's own interrupt marker is classified as a cancellation instead.
-  isInterruptCancellation(result) {
-    return result.isError && this.interruptMarkerSeen && isClaudeCodeEdeDiagnosticOnlyError(result.errorMessage);
+  // interrupt context — the SDK's own marker, or the session's knowledge that
+  // a bridge interrupt is settling (which covers a missing or late marker) —
+  // is classified as a cancellation instead.
+  isInterruptCancellation(result, context) {
+    return result.isError && (context.marker || context.bridge) && isClaudeCodeEdeDiagnosticOnlyError(result.errorMessage);
   }
   flushPendingAssistantMessages() {
     const outputs = [
       ...this.endActiveParts(),
+      ...this.failActiveToolInputs(),
       uiChunk({ type: "finish", finishReason: "stop" })
     ];
     this.currentMessageId = null;
@@ -71618,6 +71677,23 @@ var ClaudeCodeProjector = class {
       (index) => this.finishActiveToolInput(index)
     );
   }
+  // Settle every still-active tool input as an error part that preserves the
+  // partial input text. Used when the turn ends in an error before the tool
+  // block completed: the tool was never dispatched, and persisting whatever
+  // input streamed keeps the transcript diagnosable.
+  failActiveToolInputs() {
+    const outputs = [...this.activeToolInputs.values()].map(
+      (active) => uiChunk({
+        type: "tool-input-error",
+        toolCallId: active.toolCallId,
+        toolName: active.toolName,
+        input: partialToolInput(active),
+        errorText: truncatedToolInputErrorText(active)
+      })
+    );
+    this.activeToolInputs.clear();
+    return outputs;
+  }
   // A never-streamed assistant snapshot (an SDK-internal stream retry can
   // reissue the in-flight message under a fresh id, so suppression misses it;
   // pure snapshot delivery has no stream at all). Its content must respect the
@@ -71631,7 +71707,8 @@ var ClaudeCodeProjector = class {
     const messageChunks = this.assistantSnapshotMessageChunks(projections);
     const rest = projections.filter((projection) => !isAssistantMessageOrToolCall(projection)).flatMap(
       (projection) => conversationProjectionToUiChunks(projection, {
-        interrupted: this.interruptMarkerSeen
+        interruptContext: { marker: this.interruptMarkerSeen, bridge: false },
+        emitDiagnostic: this.input.writeOutput
       })
     );
     const last = messageChunks.at(-1);
@@ -71793,6 +71870,21 @@ function completeToolInput(input) {
   }
   return input.initialInput ?? {};
 }
+function partialToolInput(input) {
+  const inputText = input.inputText.trim();
+  if (inputText.length === 0) {
+    return input.initialInput ?? {};
+  }
+  try {
+    return JSON.parse(inputText);
+  } catch {
+    return input.inputText;
+  }
+}
+function truncatedToolInputErrorText(input) {
+  const bytes = Buffer.byteLength(input.inputText, "utf8");
+  return `Tool input streaming was interrupted before the call completed; the tool was never dispatched (${bytes.toString()} bytes of partial input preserved).`;
+}
 function sourceChunkFromDelta(delta, index) {
   if (delta.type !== "citations_delta") {
     return null;
@@ -71855,7 +71947,7 @@ function textContentFromDelta(delta) {
       return null;
   }
 }
-function conversationProjectionToUiChunks(projection, options = { interrupted: false }) {
+function conversationProjectionToUiChunks(projection, options) {
   if (projection.role === "assistant" && projection.kind === "message") {
     return messageContentChunks(projection);
   }
@@ -71876,15 +71968,12 @@ function conversationProjectionToUiChunks(projection, options = { interrupted: f
           })
         ];
       }
-      const remapped = typeof part.output === "string" ? remapClaudeCodeInterruptToolResultErrorText(part.output, {
-        interrupted: options.interrupted
-      }) : null;
       return [
-        uiChunk({
-          type: "tool-output-error",
-          toolCallId: part.toolUseId ?? UNKNOWN_MESSAGE_ID,
-          errorText: remapped ?? JSON.stringify(part.output)
-        })
+        toolResultErrorChunk(
+          part.toolUseId ?? UNKNOWN_MESSAGE_ID,
+          part.output,
+          options
+        )
       ];
     });
   }
@@ -71928,6 +72017,32 @@ function conversationProjectionToUiChunks(projection, options = { interrupted: f
     }
   ];
 }
+function toolResultErrorChunk(toolCallId, output, options) {
+  const context = options.interruptContext;
+  const remapped = typeof output === "string" ? remapClaudeCodeInterruptToolResultErrorText(output, {
+    interrupted: context.marker || context.bridge
+  }) : null;
+  if (remapped !== null) {
+    options.emitDiagnostic?.(
+      `agent_bridge_claude_tool_cancellation_remapped tool_use_id=${toolCallId} gate=${interruptGate(context)}`
+    );
+  } else if (typeof output === "string" && isClaudeCodePermissionDenialText(output)) {
+    options.emitDiagnostic?.(
+      `agent_bridge_claude_permission_denial_passthrough tool_use_id=${toolCallId}`
+    );
+  }
+  return uiChunk({
+    type: "tool-output-error",
+    toolCallId,
+    errorText: remapped ?? JSON.stringify(output)
+  });
+}
+function interruptGate(context) {
+  if (context.marker && context.bridge) {
+    return "marker+bridge";
+  }
+  return context.marker ? "marker" : "bridge";
+}
 function isAssistantMessageOrToolCall(projection) {
   return projection.role === "assistant" && (projection.kind === "message" || projection.kind === "tool_call");
 }
@@ -91972,7 +92087,7 @@ function withClaudeStderrDiagnosticsPointer(error51, capturedStderr) {
 
 // src/commands/agent-bridge/harness/claude-code/session.ts
 var CLAUDE_AGENT_STARTUP_TIMEOUT_MS = 3e4;
-var CLAUDE_INTERRUPT_SETTLE_TIMEOUT_MS = 1e4;
+var CLAUDE_TOOL_BOUNDARY_WAIT_TIMEOUT_MS = 12e4;
 var CLAUDE_INTERRUPT_ACK_TIMEOUT_MS = 1e4;
 var CLAUDE_MCP_REGISTRATION_TIMEOUT_MS = 3e4;
 var CLAUDE_MCP_REGISTRATION_POLL_INTERVAL_MS = 100;
@@ -92048,16 +92163,33 @@ var ClaudeAgentBridgeSessionImpl = class {
   // flushed command id.
   openTurnCommandIds = [];
   // tool_use ids the assistant has emitted whose tool_result has not yet been
-  // observed. A non-empty set means a tool call is in flight, so an immediate
-  // interrupt would append the new user message after an unresolved
+  // observed, with the name/detail needed to describe them in a cancellation
+  // notice. A non-empty map means a tool call is in flight: interrupting now
+  // would destroy its work and record a denial-worded cancellation, and
+  // injecting now would append the new user message after an unresolved
   // stop_reason=tool_use — the invalid transcript that trips Claude Code's
   // ede_diagnostic and auto-restarts the session (FRA-3049).
-  pendingToolUseIds = /* @__PURE__ */ new Set();
-  // Incremented on every turn-terminal `result`. An interrupt that aborts an
-  // in-flight tool call waits for this to advance before injecting, so the
-  // message lands only once the interrupted turn has settled its tool_use.
+  pendingToolUses = /* @__PURE__ */ new Map();
+  // Incremented on every turn-terminal `result`; the interrupt-timeout latch
+  // compares against it to tell whether the same wedged turn is still running.
   turnResultCount = 0;
-  turnSettlementWaiters = /* @__PURE__ */ new Set();
+  // A steering message is waiting for the in-flight tool call to settle so the
+  // turn can be interrupted at the tool boundary instead of mid-tool. Armed by
+  // sendMessage, fired by the output pump when the pending tool_use set
+  // drains, bounded by the budget timer below.
+  toolBoundaryWait = null;
+  // True from the moment a bridge-initiated interrupt control request fires
+  // until the targeted turn emits its terminal result (or the stream ends).
+  // Reported to the projector on every message so the SDK's denial-worded
+  // cancellation records are classified as platform cancellations even though
+  // the SDK's own interrupt marker arrives after them (probe-verified wire
+  // order, 2026-07-13: tool_result → marker → error_during_execution result).
+  interruptSettling = false;
+  // Tool calls the SDK cancelled while a bridge-initiated interrupt was
+  // settling. Consumed by the deferred flush: the injected message gets a
+  // platform-cancellation notice naming this work so the model re-runs it
+  // instead of treating the denial-worded tool_result as a human rejection.
+  cancelledToolRuns = [];
   // Memoized MCP-registration gate, keyed by the attached query. A runtime
   // restart warms a brand-new session + query, so keying off the query object
   // (rather than a session-lifetime flag) re-arms the gate on every restart:
@@ -92116,18 +92248,34 @@ var ClaudeAgentBridgeSessionImpl = class {
       delivery_mode: mode,
       state: this.state.kind,
       active_turn_count: this.activeTurnCount,
-      pending_tool_use_count: this.pendingToolUseIds.size,
+      pending_tool_use_count: this.pendingToolUses.size,
       deferred_count: this.deferredMessages.length
     });
     if (mode === "deferred" && this.hasInterruptibleTurn()) {
       this.deferredMessages.push({ text: message, commandIds });
       this.input.runtimeLogger?.info("agent_bridge_claude_message_deferred", {
         active_turn_count: this.activeTurnCount,
-        pending_tool_use_count: this.pendingToolUseIds.size,
+        pending_tool_use_count: this.pendingToolUses.size,
         deferred_count: this.deferredMessages.length
       });
       return;
     }
+    if (this.hasInterruptibleTurn() && this.hasInFlightToolUse()) {
+      this.deferredMessages.push({ text: message, commandIds });
+      this.armToolBoundaryWait();
+      this.input.runtimeLogger?.info(
+        "agent_bridge_claude_message_deferred_tool_boundary",
+        {
+          active_turn_count: this.activeTurnCount,
+          pending_tool_use_count: this.pendingToolUses.size,
+          pending_tools: [...this.pendingToolUses.values()].map(
+            (tool) => tool.name
+          ),
+          deferred_count: this.deferredMessages.length
+        }
+      );
+      return;
+    }
     const interruption = await this.interruptActiveTurnBeforeMessage();
     if (interruption === "defer" && this.hasInterruptibleTurn()) {
       this.deferredMessages.push({ text: message, commandIds });
@@ -92135,7 +92283,7 @@ var ClaudeAgentBridgeSessionImpl = class {
         "agent_bridge_claude_message_deferred_after_interrupt_timeout",
         {
           active_turn_count: this.activeTurnCount,
-          pending_tool_use_count: this.pendingToolUseIds.size,
+          pending_tool_use_count: this.pendingToolUses.size,
           deferred_count: this.deferredMessages.length
         }
       );
@@ -92148,7 +92296,7 @@ var ClaudeAgentBridgeSessionImpl = class {
       duration_ms: Date.now() - startedAt,
       state: this.state.kind,
       active_turn_count: this.activeTurnCount,
-      pending_tool_use_count: this.pendingToolUseIds.size,
+      pending_tool_use_count: this.pendingToolUses.size,
       deferred_count: this.deferredMessages.length
     });
   }
@@ -92232,8 +92380,10 @@ var ClaudeAgentBridgeSessionImpl = class {
     }
     this.state = { kind: "closed" };
     this.activeTurnCount = 0;
-    this.pendingToolUseIds.clear();
-    this.resolveTurnSettlement(false);
+    this.pendingToolUses.clear();
+    this.cancelledToolRuns = [];
+    this.interruptSettling = false;
+    this.disarmToolBoundaryWait();
     if (this.deferredMessages.length > 0) {
       this.input.writeOutput?.(
         `agent_bridge_claude_deferred_dropped count=${this.deferredMessages.length} reason=session_closed`
@@ -92324,19 +92474,21 @@ var ClaudeAgentBridgeSessionImpl = class {
     void (async () => {
       try {
         for await (const message of query) {
+          const interruptSettling = this.interruptSettling;
           this.trackToolUseLifecycle(message);
-          let meta3;
+          let meta3 = { interruptSettling };
           if (isClaudeAgentTurnResult(message)) {
             this.activeTurnCount = Math.max(0, this.activeTurnCount - 1);
             meta3 = {
+              interruptSettling,
               consumedCommandIds: this.openTurnCommandIds.shift() ?? []
             };
-            this.pendingToolUseIds.clear();
+            this.pendingToolUses.clear();
+            this.interruptSettling = false;
             this.turnResultCount += 1;
-            this.resolveTurnSettlement(true);
             this.input.runtimeLogger?.info("agent_bridge_claude_turn_result", {
               active_turn_count: this.activeTurnCount,
-              pending_tool_use_count: this.pendingToolUseIds.size,
+              pending_tool_use_count: this.pendingToolUses.size,
               turn_result_count: this.turnResultCount,
               deferred_count: this.deferredMessages.length,
               consumed_command_ids: meta3.consumedCommandIds
@@ -92344,6 +92496,9 @@ var ClaudeAgentBridgeSessionImpl = class {
             if (this.activeTurnCount === 0) {
               this.flushDeferredMessages();
             }
+            if (this.deferredMessages.length === 0) {
+              this.cancelledToolRuns = [];
+            }
           }
           const failure = probeClaudeAgentMessage(
             message,
@@ -92368,8 +92523,9 @@ var ClaudeAgentBridgeSessionImpl = class {
       } finally {
         this.activeTurnCount = 0;
         this.openTurnCommandIds.length = 0;
-        this.pendingToolUseIds.clear();
-        this.resolveTurnSettlement(false);
+        this.pendingToolUses.clear();
+        this.interruptSettling = false;
+        this.disarmToolBoundaryWait();
         this.state = { kind: "closed" };
         this.reportExit();
       }
@@ -92386,7 +92542,7 @@ var ClaudeAgentBridgeSessionImpl = class {
     this.input.runtimeLogger?.info("agent_bridge_claude_message_enqueued", {
       state: this.state.kind,
       active_turn_count: this.activeTurnCount,
-      pending_tool_use_count: this.pendingToolUseIds.size,
+      pending_tool_use_count: this.pendingToolUses.size,
       deferred_count: this.deferredMessages.length
     });
     void this.ensureRunningQuery().catch((error51) => {
@@ -92399,75 +92555,105 @@ var ClaudeAgentBridgeSessionImpl = class {
     return this.activeTurnCount > 0 && this.state.kind === "running";
   }
   // True while the assistant has an emitted tool_use with no matching
-  // tool_result yet — the window where an immediate interrupt would strand an
+  // tool_result yet — the window where an immediate interrupt would cancel
+  // real tool work, and where an immediate injection would strand an
   // unresolved stop_reason=tool_use ahead of the injected user message.
   hasInFlightToolUse() {
-    return this.pendingToolUseIds.size > 0;
+    return this.pendingToolUses.size > 0;
   }
   // Track tool_use/tool_result pairs as they stream so hasInFlightToolUse()
   // reflects the live transcript. A tool_use may appear first as a streaming
   // content block before the full assistant message is available; the matching
   // tool_result closes it; the turn's terminal result clears any remainder.
+  // Two side jobs ride on the same observation point:
+  // - a denial-worded error tool_result arriving while a bridge interrupt is
+  //   settling is that interrupt's cancellation of the tool — record it so the
+  //   flushed message can tell the model to re-run the cancelled work;
+  // - a tool_result that drains the pending set is the tool boundary an armed
+  //   steering message has been waiting for — interrupt the turn now, while no
+  //   tool work is at risk.
   trackToolUseLifecycle(message) {
-    for (const id of toolUseIds(message)) {
-      this.pendingToolUseIds.add(id);
+    for (const entry of toolUseEntries(message)) {
+      this.pendingToolUses.set(entry.id, {
+        name: entry.name,
+        detail: entry.detail
+      });
+    }
+    const hadInFlightToolUse = this.hasInFlightToolUse();
+    for (const result of toolResultEntries(message)) {
+      const pending = this.pendingToolUses.get(result.id);
+      this.pendingToolUses.delete(result.id);
+      if (pending && this.interruptSettling && result.isError && result.text !== null && isClaudeCodePermissionDenialText(result.text)) {
+        this.cancelledToolRuns.push(pending);
+        this.input.writeOutput?.(
+          `agent_bridge_claude_tool_cancellation_observed tool=${pending.name}`
+        );
+      }
     }
-    for (const id of toolResultIds(message)) {
-      this.pendingToolUseIds.delete(id);
+    if (hadInFlightToolUse && !this.hasInFlightToolUse()) {
+      this.fireToolBoundaryInterrupt();
     }
   }
-  // Resolve once the interrupted turn emits its terminal `result` (turnResultCount
-  // advances past the pre-interrupt baseline), bounded so a tool that never
-  // returns after interrupt cannot wedge delivery. The caller reads the
-  // outcome: "timeout" means the turn is still running and the message must
-  // defer to the turn boundary rather than inject mid-turn.
-  awaitTurnSettlement(baseline, startedAt) {
-    if (this.turnResultCount > baseline) {
-      return Promise.resolve("ready");
+  // The pending tool_use set just drained mid-turn. If a steering message is
+  // waiting on that boundary, interrupt the turn now: nothing is executing, so
+  // the cancellation costs only the model's remaining reasoning, and the
+  // turn's terminal result flushes the message. Fire-and-forget — the flush at
+  // the turn result owns delivery whether or not this interrupt lands.
+  fireToolBoundaryInterrupt() {
+    if (!this.toolBoundaryWait || this.deferredMessages.length === 0 || !this.hasInterruptibleTurn()) {
+      return;
     }
-    return new Promise((resolve2) => {
-      let done = false;
-      const finish = (outcome) => {
-        if (done) {
-          return;
-        }
-        done = true;
-        clearTimeout(timer);
-        this.turnSettlementWaiters.delete(waiter);
-        this.input.writeOutput?.(
-          `agent_bridge_claude_interrupt_settle_${outcome} duration_ms=${Date.now() - startedAt}`
-        );
-        resolve2(outcome);
-      };
-      const waiter = (settled) => finish(settled ? "ready" : "aborted");
-      const timer = setTimeout(
-        () => finish("timeout"),
-        CLAUDE_INTERRUPT_SETTLE_TIMEOUT_MS
+    this.disarmToolBoundaryWait();
+    this.input.writeOutput?.(
+      `agent_bridge_claude_tool_boundary_interrupt deferred_count=${this.deferredMessages.length}`
+    );
+    void this.interruptActiveTurn();
+  }
+  // Bound the tool-boundary wait: past the budget the steering message is
+  // judged more urgent than the in-flight tool, which is cancelled mid-run.
+  // The cancellation is observed by trackToolUseLifecycle and reported to the
+  // model in the flushed message's platform notice.
+  armToolBoundaryWait() {
+    if (this.toolBoundaryWait) {
+      return;
+    }
+    const timer = setTimeout(() => {
+      this.toolBoundaryWait = null;
+      if (!this.hasInterruptibleTurn() || this.deferredMessages.length === 0) {
+        return;
+      }
+      this.input.writeOutput?.(
+        `agent_bridge_claude_tool_boundary_wait_timeout pending_tools=${[
+          ...this.pendingToolUses.values()
+        ].map((tool) => tool.name).join(",")} deferred_count=${this.deferredMessages.length}`
       );
-      timer.unref?.();
-      this.turnSettlementWaiters.add(waiter);
-    });
+      void this.interruptActiveTurn();
+    }, CLAUDE_TOOL_BOUNDARY_WAIT_TIMEOUT_MS);
+    timer.unref?.();
+    this.toolBoundaryWait = { timer };
   }
-  resolveTurnSettlement(settled) {
-    if (this.turnSettlementWaiters.size === 0) {
+  disarmToolBoundaryWait() {
+    if (!this.toolBoundaryWait) {
       return;
     }
-    const waiters = [...this.turnSettlementWaiters];
-    this.turnSettlementWaiters.clear();
-    for (const waiter of waiters) {
-      waiter(settled);
-    }
+    clearTimeout(this.toolBoundaryWait.timer);
+    this.toolBoundaryWait = null;
   }
   flushDeferredMessages() {
     if (this.deferredMessages.length === 0) {
       return;
     }
     const pending = this.deferredMessages.splice(0);
+    const cancelledToolRuns = this.cancelledToolRuns.splice(0);
+    this.disarmToolBoundaryWait();
     this.input.writeOutput?.(
-      `agent_bridge_claude_deferred_flush count=${pending.length}`
+      `agent_bridge_claude_deferred_flush count=${pending.length} cancelled_tool_count=${cancelledToolRuns.length}`
     );
+    const text2 = pending.map((entry) => entry.text).join("\n\n");
     this.enqueueUserMessage(
-      pending.map((entry) => entry.text).join("\n\n"),
+      cancelledToolRuns.length > 0 ? `${text2}
+
+${cancelledToolPlatformNotice(cancelledToolRuns)}` : text2,
       pending.flatMap((entry) => entry.commandIds)
     );
   }
@@ -92488,11 +92674,10 @@ var ClaudeAgentBridgeSessionImpl = class {
       return "proceed";
     }
     const query = this.state.query;
-    const hadInFlightToolUse = this.hasInFlightToolUse();
     const settlementBaseline = this.turnResultCount;
     const startedAt = Date.now();
     this.input.writeOutput?.(
-      `agent_bridge_claude_mid_turn_interrupt_started at=${new Date(startedAt).toISOString()} in_flight_tool_use=${hadInFlightToolUse}`
+      `agent_bridge_claude_mid_turn_interrupt_started at=${new Date(startedAt).toISOString()} in_flight_tool_use=${this.hasInFlightToolUse()}`
     );
     const interruptPromise = (async () => {
       const ack = await this.requestInterruptAck(query, startedAt);
@@ -92500,16 +92685,6 @@ var ClaudeAgentBridgeSessionImpl = class {
         this.interruptTimeoutTurn = settlementBaseline;
         return "defer";
       }
-      if (hadInFlightToolUse) {
-        const settle = await this.awaitTurnSettlement(
-          settlementBaseline,
-          startedAt
-        );
-        if (settle === "timeout") {
-          this.interruptTimeoutTurn = settlementBaseline;
-          return "defer";
-        }
-      }
       return "proceed";
     })();
     this.interruptInFlight = interruptPromise;
@@ -92546,6 +92721,7 @@ var ClaudeAgentBridgeSessionImpl = class {
         );
       }, CLAUDE_INTERRUPT_ACK_TIMEOUT_MS);
       timer.unref?.();
+      this.interruptSettling = true;
       query.interrupt().then(
         () => {
           if (done) {
@@ -92902,10 +93078,10 @@ function claudeAgentUserMessage(message) {
 function isClaudeAgentTurnResult(message) {
   return message.type === "result";
 }
-function toolUseIds(message) {
+function toolUseEntries(message) {
   if (message.type === "assistant") {
     return contentBlocks2(message.message.content).flatMap(
-      (block2) => block2.type === "tool_use" && typeof block2.id === "string" ? [block2.id] : []
+      (block2) => block2.type === "tool_use" && typeof block2.id === "string" ? [toolUseEntryFromBlock(block2)] : []
     );
   }
   if (message.type !== "stream_event") {
@@ -92916,16 +93092,54 @@ function toolUseIds(message) {
     return [];
   }
   const block = event.content_block;
-  return block.type === "tool_use" && typeof block.id === "string" ? [block.id] : [];
+  return block.type === "tool_use" && typeof block.id === "string" ? [toolUseEntryFromBlock(block)] : [];
+}
+function toolUseEntryFromBlock(block) {
+  return {
+    id: String(block.id),
+    name: typeof block.name === "string" ? block.name : "unknown_tool",
+    detail: toolUseDetail(block.input)
+  };
+}
+function toolUseDetail(input) {
+  if (input === void 0 || input === null) {
+    return "";
+  }
+  let text2;
+  try {
+    text2 = JSON.stringify(input);
+  } catch {
+    return "";
+  }
+  if (!text2 || text2 === "{}") {
+    return "";
+  }
+  return text2.length > 160 ? `${text2.slice(0, 160)}\u2026` : text2;
 }
-function toolResultIds(message) {
+function toolResultEntries(message) {
   if (message.type !== "user") {
     return [];
   }
   return contentBlocks2(message.message.content).flatMap(
-    (block) => block.type === "tool_result" && typeof block.tool_use_id === "string" ? [block.tool_use_id] : []
+    (block) => block.type === "tool_result" && typeof block.tool_use_id === "string" ? [
+      {
+        id: block.tool_use_id,
+        isError: block.is_error === true,
+        text: typeof block.content === "string" ? block.content : null
+      }
+    ] : []
   );
 }
+function cancelledToolPlatformNotice(cancelled) {
+  const lines = cancelled.map(
+    (tool) => `- ${tool.name}${tool.detail ? ` ${tool.detail}` : ""}`
+  );
+  return [
+    "[Auto platform notice] To deliver the message above, the platform cancelled the following in-flight tool call(s) mid-execution:",
+    ...lines,
+    "This was a platform-initiated cancellation for message delivery, NOT a rejection or permission denial by the user \u2014 ignore any tool result saying the user doesn't want to proceed. Re-run or resume that tool work if it is still needed once you have applied the message."
+  ].join("\n");
+}
 function contentBlocks2(content) {
   if (!Array.isArray(content)) {
     return [];
@@ -92944,6 +93158,9 @@ var ClaudeCodeCommandHandler = class {
     this.input = input;
     this.claudeConfig = input.claude;
     this.outputBuffer = new AgentBridgeOutputBuffer(input);
+    this.projector = new ClaudeCodeProjector({
+      writeOutput: input.writeOutput
+    });
     this.readState = input.readState ? new ClaudeReadStateTracker(input.readState) : null;
   }
   input;
@@ -92965,7 +93182,7 @@ var ClaudeCodeCommandHandler = class {
   inFlightMessageCommands = /* @__PURE__ */ new Map();
   pendingQuestions = /* @__PURE__ */ new Map();
   outputBuffer;
-  projector = new ClaudeCodeProjector();
+  projector;
   readState;
   livenessTicker = null;
   // -----------------------------------------------------------------------------
@@ -93346,7 +93563,9 @@ var ClaudeCodeCommandHandler = class {
     this.trackReadState(activeContext, message);
     let projections;
     try {
-      projections = this.projector.project(message);
+      projections = this.projector.project(message, {
+        bridgeInterruptSettling: meta3?.interruptSettling === true
+      });
     } catch (error51) {
       this.input.writeOutput?.(
         `agent_bridge_claude_parse_failed error=${error51 instanceof Error ? error51.message : String(error51)}`