@autohq/cli 0.1.448 → 0.1.450

package/dist/agent-bridge.js

@@ -30825,7 +30825,7 @@ Object.assign(lookup, {
 // package.json
 var package_default = {
   name: "@autohq/cli",
-  version: "0.1.448",
+  version: "0.1.450",
   license: "SEE LICENSE IN README.md",
   publishConfig: {
     access: "public"
@@ -36480,23 +36480,14 @@ var SafeTelemetryTextSchema = external_exports.string().transform(
     return codePoint < 32 || codePoint === 127 ? " " : character;
   }).join("").replace(/\s+/g, " ").trim().slice(0, 300).trim()
 ).pipe(external_exports.string().min(1).max(300));
-var PlatformUsageUserSchema = external_exports.object({
-  id: external_exports.string().trim().min(1).max(200),
-  displayName: SafeTelemetryTextSchema.nullable(),
-  email: SafeTelemetryTextSchema.nullable()
-});
-var PlatformUsageSessionActorSchema = external_exports.discriminatedUnion("kind", [
-  external_exports.object({
-    kind: external_exports.literal("user"),
-    user: PlatformUsageUserSchema
-  }),
-  external_exports.object({
-    kind: external_exports.literal("provider"),
-    provider: SafeTelemetryTextSchema,
-    externalId: external_exports.string().trim().min(1).max(200),
-    displayName: SafeTelemetryTextSchema.nullable()
-  })
-]);
+var PlatformUsageActorSchema = external_exports.object({
+  displayName: SafeTelemetryTextSchema,
+  source: SafeTelemetryTextSchema.nullable()
+}).strict();
+var PlatformUsageAgentSchema = external_exports.object({
+  displayName: SafeTelemetryTextSchema,
+  model: SafeTelemetryTextSchema.nullable()
+}).strict();
 var PlatformUsageScopeSchema = external_exports.object({
   environment: SafeTelemetryTextSchema,
   organizationId: external_exports.string().trim().min(1).max(200),
@@ -36504,13 +36495,13 @@ var PlatformUsageScopeSchema = external_exports.object({
   projectId: external_exports.string().trim().min(1).max(200).nullable(),
   projectName: SafeTelemetryTextSchema.nullable()
 });
-var ScopedUserEventSchema = external_exports.object({
-  user: PlatformUsageUserSchema,
+var ScopedActorEventSchema = external_exports.object({
+  actor: PlatformUsageActorSchema,
   scope: PlatformUsageScopeSchema
 });
 var PlatformUsageEventSchema = external_exports.discriminatedUnion("kind", [
-  ScopedUserEventSchema.extend({ kind: external_exports.literal("user.signup") }),
-  ScopedUserEventSchema.extend({
+  ScopedActorEventSchema.extend({ kind: external_exports.literal("user.signup") }),
+  ScopedActorEventSchema.extend({
     kind: external_exports.literal("onboarding.lifecycle"),
     stage: external_exports.enum(["team_selected", "github_connected", "team_applied"]),
     team: SafeTelemetryTextSchema,
@@ -36520,23 +36511,21 @@ var PlatformUsageEventSchema = external_exports.discriminatedUnion("kind", [
       failureSummary: SafeTelemetryTextSchema.nullable()
     }).nullable()
   }),
-  ScopedUserEventSchema.extend({
+  ScopedActorEventSchema.extend({
     kind: external_exports.literal("agent.created"),
-    agentName: SafeTelemetryTextSchema
+    agent: PlatformUsageAgentSchema
   }),
-  external_exports.object({
+  ScopedActorEventSchema.extend({
     kind: external_exports.literal("session.started"),
-    actor: PlatformUsageSessionActorSchema,
-    scope: PlatformUsageScopeSchema,
-    agentName: SafeTelemetryTextSchema,
+    agent: PlatformUsageAgentSchema,
     sessionId: external_exports.string().trim().min(1).max(200)
   }),
-  ScopedUserEventSchema.extend({
+  ScopedActorEventSchema.extend({
     kind: external_exports.literal("credits.added"),
     amountUsd: external_exports.number().positive().finite(),
     source: external_exports.enum(["purchase", "auto_topup", "adjustment"])
   }),
-  ScopedUserEventSchema.extend({
+  ScopedActorEventSchema.extend({
     kind: external_exports.literal("credits.exhausted"),
     autoReloadOutcome: external_exports.enum([
       "not_enabled",
@@ -42808,6 +42797,15 @@ triggers:
           content: "harness: claude-code\nenvironment:\n  name: auto-default-runtime\n  image:\n    kind: preset\n    name: node24\nidentity:\n  displayName: Default\n  username: default\n  description: Auto's built-in general-purpose agent.\ntools:\n  auto:\n    kind: local\n    implementation: auto\n"
         }
       ]
+    },
+    {
+      version: "1.1.0",
+      files: [
+        {
+          path: "fragments/default.yaml",
+          content: "# 1.1.0 bakes the built-in catalog avatar (default.png) into Default's identity so\n# every provisioned agent/default shows the house face instead of an initials\n# fallback. Otherwise byte-identical to 1.0.0.\nharness: claude-code\nenvironment:\n  name: auto-default-runtime\n  image:\n    kind: preset\n    name: node24\nidentity:\n  displayName: Default\n  username: default\n  avatar:\n    asset: .auto/assets/default.png\n    sha256: a5dd97676173a83dfc6fb9bdf30e7f50c7392f9e382fca40a23d6ab9285e9bf2\n  description: Auto's built-in general-purpose agent.\ntools:\n  auto:\n    kind: local\n    implementation: auto\n"
+        }
+      ]
     }
   ],
   "@auto/engineering-tier": [
@@ -71453,6 +71451,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,
@@ -71471,13 +71473,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);
@@ -71489,18 +71495,24 @@ 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;
-      outputs.push(
-        projectClaudeCodeResult(parsed.result, {
-          interrupted: this.isInterruptCancellation(parsed.result)
-        })
+      const interrupted = this.isInterruptCancellation(
+        parsed.result,
+        interruptContext
       );
+      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;
@@ -71510,9 +71522,11 @@ 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 = [
@@ -71633,7 +71647,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);
@@ -71857,7 +71872,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);
   }
@@ -71878,15 +71893,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
+        )
       ];
     });
   }
@@ -71930,6 +71942,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");
 }
@@ -91974,7 +92012,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;
@@ -92050,16 +92088,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:
@@ -92118,18 +92173,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 });
@@ -92137,7 +92208,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
         }
       );
@@ -92150,7 +92221,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
     });
   }
@@ -92234,8 +92305,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`
@@ -92326,19 +92399,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
@@ -92346,6 +92421,9 @@ var ClaudeAgentBridgeSessionImpl = class {
             if (this.activeTurnCount === 0) {
               this.flushDeferredMessages();
             }
+            if (this.deferredMessages.length === 0) {
+              this.cancelledToolRuns = [];
+            }
           }
           const failure = probeClaudeAgentMessage(
             message,
@@ -92370,8 +92448,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();
       }
@@ -92388,7 +92467,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) => {
@@ -92401,75 +92480,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
+      });
     }
-    for (const id of toolResultIds(message)) {
-      this.pendingToolUseIds.delete(id);
+    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}`
+        );
+      }
+    }
+    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)
     );
   }
@@ -92490,11 +92599,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);
@@ -92502,16 +92610,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;
@@ -92548,6 +92646,7 @@ var ClaudeAgentBridgeSessionImpl = class {
         );
       }, CLAUDE_INTERRUPT_ACK_TIMEOUT_MS);
       timer.unref?.();
+      this.interruptSettling = true;
       query.interrupt().then(
         () => {
           if (done) {
@@ -92904,10 +93003,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") {
@@ -92918,16 +93017,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 [];
@@ -92946,6 +93083,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;
@@ -92967,7 +93107,7 @@ var ClaudeCodeCommandHandler = class {
   inFlightMessageCommands = /* @__PURE__ */ new Map();
   pendingQuestions = /* @__PURE__ */ new Map();
   outputBuffer;
-  projector = new ClaudeCodeProjector();
+  projector;
   readState;
   livenessTicker = null;
   // -----------------------------------------------------------------------------
@@ -93348,7 +93488,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)}`