@autohq/cli 0.1.448 → 0.1.450

package/dist/index.js

@@ -20694,34 +20694,26 @@ var init_pricing = __esm({
 });
 
 // ../../packages/schemas/src/platform-usage-feed.ts
-var SafeTelemetryTextSchema, PlatformUsageUserSchema, PlatformUsageSessionActorSchema, PlatformUsageScopeSchema, ScopedUserEventSchema, PlatformUsageEventSchema;
+var SafeTelemetryTextSchema, PlatformUsageActorSchema, PlatformUsageAgentSchema, PlatformUsageScopeSchema, ScopedActorEventSchema, PlatformUsageEventSchema;
 var init_platform_usage_feed = __esm({
   "../../packages/schemas/src/platform-usage-feed.ts"() {
     "use strict";
     init_zod();
+    init_agents();
     SafeTelemetryTextSchema = external_exports.string().transform(
       (value) => [...value].map((character) => {
         const codePoint = character.codePointAt(0) ?? 0;
         return codePoint < 32 || codePoint === 127 ? " " : character;
       }).join("").replace(/\s+/g, " ").trim().slice(0, 300).trim()
     ).pipe(external_exports.string().min(1).max(300));
-    PlatformUsageUserSchema = external_exports.object({
-      id: external_exports.string().trim().min(1).max(200),
-      displayName: SafeTelemetryTextSchema.nullable(),
-      email: SafeTelemetryTextSchema.nullable()
-    });
-    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()
-      })
-    ]);
+    PlatformUsageActorSchema = external_exports.object({
+      displayName: SafeTelemetryTextSchema,
+      source: SafeTelemetryTextSchema.nullable()
+    }).strict();
+    PlatformUsageAgentSchema = external_exports.object({
+      displayName: SafeTelemetryTextSchema,
+      model: SafeTelemetryTextSchema.nullable()
+    }).strict();
     PlatformUsageScopeSchema = external_exports.object({
       environment: SafeTelemetryTextSchema,
       organizationId: external_exports.string().trim().min(1).max(200),
@@ -20729,13 +20721,13 @@ var init_platform_usage_feed = __esm({
       projectId: external_exports.string().trim().min(1).max(200).nullable(),
       projectName: SafeTelemetryTextSchema.nullable()
     });
-    ScopedUserEventSchema = external_exports.object({
-      user: PlatformUsageUserSchema,
+    ScopedActorEventSchema = external_exports.object({
+      actor: PlatformUsageActorSchema,
       scope: PlatformUsageScopeSchema
     });
     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,
@@ -20745,23 +20737,21 @@ var init_platform_usage_feed = __esm({
           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",
@@ -27217,6 +27207,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": [
@@ -49212,7 +49211,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@autohq/cli",
-      version: "0.1.448",
+      version: "0.1.450",
       license: "SEE LICENSE IN README.md",
       publishConfig: {
         access: "public"
@@ -62053,6 +62052,10 @@ function jsonRecordString2(value, key) {
 // src/commands/agent-bridge/harness/claude-code/projector.ts
 init_src();
 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,
@@ -62071,13 +62074,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);
@@ -62089,18 +62096,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;
@@ -62110,9 +62123,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 = [
@@ -62233,7 +62248,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);
@@ -62457,7 +62473,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);
   }
@@ -62478,15 +62494,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
+        )
       ];
     });
   }
@@ -62530,6 +62543,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");
 }
@@ -62808,6 +62847,7 @@ function parseReadStateRecord(raw) {
 }
 
 // src/commands/agent-bridge/harness/claude-code/session.ts
+init_src();
 import {
   startup as startupClaudeAgent
 } from "@anthropic-ai/claude-agent-sdk";
@@ -63002,7 +63042,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;
@@ -63078,16 +63118,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:
@@ -63146,18 +63203,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 });
@@ -63165,7 +63238,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
         }
       );
@@ -63178,7 +63251,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
     });
   }
@@ -63262,8 +63335,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`
@@ -63354,19 +63429,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
@@ -63374,6 +63451,9 @@ var ClaudeAgentBridgeSessionImpl = class {
             if (this.activeTurnCount === 0) {
               this.flushDeferredMessages();
             }
+            if (this.deferredMessages.length === 0) {
+              this.cancelledToolRuns = [];
+            }
           }
           const failure = probeClaudeAgentMessage(
             message,
@@ -63398,8 +63478,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();
       }
@@ -63416,7 +63497,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) => {
@@ -63429,75 +63510,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((resolve4) => {
-      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}`
-        );
-        resolve4(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 text = pending.map((entry) => entry.text).join("\n\n");
     this.enqueueUserMessage(
-      pending.map((entry) => entry.text).join("\n\n"),
+      cancelledToolRuns.length > 0 ? `${text}
+
+${cancelledToolPlatformNotice(cancelledToolRuns)}` : text,
       pending.flatMap((entry) => entry.commandIds)
     );
   }
@@ -63518,11 +63629,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);
@@ -63530,16 +63640,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;
@@ -63576,6 +63676,7 @@ var ClaudeAgentBridgeSessionImpl = class {
         );
       }, CLAUDE_INTERRUPT_ACK_TIMEOUT_MS);
       timer.unref?.();
+      this.interruptSettling = true;
       query.interrupt().then(
         () => {
           if (done) {
@@ -63932,10 +64033,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") {
@@ -63946,16 +64047,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 toolResultIds(message) {
+function toolUseDetail(input) {
+  if (input === void 0 || input === null) {
+    return "";
+  }
+  let text;
+  try {
+    text = JSON.stringify(input);
+  } catch {
+    return "";
+  }
+  if (!text || text === "{}") {
+    return "";
+  }
+  return text.length > 160 ? `${text.slice(0, 160)}\u2026` : text;
+}
+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 [];
@@ -63974,6 +64113,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;
@@ -63995,7 +64137,7 @@ var ClaudeCodeCommandHandler = class {
   inFlightMessageCommands = /* @__PURE__ */ new Map();
   pendingQuestions = /* @__PURE__ */ new Map();
   outputBuffer;
-  projector = new ClaudeCodeProjector();
+  projector;
   readState;
   livenessTicker = null;
   // -----------------------------------------------------------------------------
@@ -64376,7 +64518,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)}`