@autohq/cli 0.1.287 → 0.1.289

package/dist/agent-bridge.js

@@ -23384,7 +23384,7 @@ Object.assign(lookup, {
 // package.json
 var package_default = {
   name: "@autohq/cli",
-  version: "0.1.287",
+  version: "0.1.289",
   license: "SEE LICENSE IN README.md",
   publishConfig: {
     access: "public"
@@ -28362,6 +28362,9 @@ var ProjectTemplateSubscriptionSchema = external_exports.object({
 });
 
 // ../../packages/schemas/src/temporal.ts
+var SessionCheckTimeoutWorkflowInputSchema = external_exports.object({
+  checkId: external_exports.string().trim().min(1)
+});
 var ResourceReconciliationScopeSchema = external_exports.object({
   organizationId: external_exports.string().trim().min(1),
   projectId: external_exports.string().trim().min(1).nullable()
@@ -36725,25 +36728,11 @@ var AgentBridgeOutputBuffer = class {
     );
     if (!completedMessage || !completedMessage.id.trim()) {
       if (isTerminalUiMessageChunk(projection.chunk)) {
-        const statusText = terminalStatusText(projection);
-        if (statusText) {
-          await this.enqueueProjectionAndDrain(context, {
-            type: "entry",
-            entry: {
-              role: "system",
-              kind: "status",
-              status: terminalEntryStatus(projection),
-              ...projection.turnStatus ? { turnStatus: projection.turnStatus } : {},
-              ...projection.usage ? { usage: projection.usage } : {},
-              content: {
-                parts: [{ type: "text", text: statusText }]
-              }
-            }
-          });
-        }
+        await this.emitTerminalStatusEntry(context, projection);
       }
       return;
     }
+    const turnFailed = projection.turnStatus === "failed";
     this.outputSeq += 1;
     const completedAt = now2();
     const completedOutput = buildUiMessageCompletedOutputEnvelope({
@@ -36751,13 +36740,35 @@ var AgentBridgeOutputBuffer = class {
       outputSeq: this.outputSeq,
       message: completedMessage,
       status: terminalEntryStatus(projection),
-      turnStatus: projection.turnStatus,
-      usage: projection.usage,
+      turnStatus: turnFailed ? void 0 : projection.turnStatus,
+      usage: turnFailed ? void 0 : projection.usage,
       createdAt: completedAt,
       completedAt
     });
     this.enqueueOutput(completedOutput);
     await this.drainPendingOutputs();
+    if (turnFailed) {
+      await this.emitTerminalStatusEntry(context, projection);
+    }
+  }
+  async emitTerminalStatusEntry(context, projection) {
+    const statusText = terminalStatusText(projection);
+    if (!statusText) {
+      return;
+    }
+    await this.enqueueProjectionAndDrain(context, {
+      type: "entry",
+      entry: {
+        role: "system",
+        kind: "status",
+        status: terminalEntryStatus(projection),
+        ...projection.turnStatus ? { turnStatus: projection.turnStatus } : {},
+        ...projection.usage ? { usage: projection.usage } : {},
+        content: {
+          parts: [{ type: "text", text: statusText }]
+        }
+      }
+    });
   }
   async emitLiveUiMessageChunk(context, chunk) {
     this.outputSeq += 1;
@@ -57340,6 +57351,12 @@ var claudeAgentBridgeRuntime = {
 var claudeAgentSdkRuntime = {
   startup: (input) => aj$(input)
 };
+var ClaudeMcpRegistryEmptyError = class extends Error {
+  constructor(detail) {
+    super(`MCP tool registry came up empty at session start: ${detail}`);
+    this.name = "ClaudeMcpRegistryEmptyError";
+  }
+};
 var ClaudeAgentBridgeSessionImpl = class {
   input;
   inputQueue;
@@ -57729,17 +57746,20 @@ var ClaudeAgentBridgeSessionImpl = class {
   }
   // Why this gate is correct without a provider-backed test (it relies on real
   // SDK mcpServerStatus() timing that fakes cannot prove):
-  // - Safe-degrade: pollMcpRegistration never rejects — on timeout, a
-  //   status-read failure, or a closed session it resolves, so the worst case
-  //   is today's immediate injection. The gate can never regress below the
-  //   status-quo race; it can only close it.
+  // - Safe-degrade on uncertainty: pollMcpRegistration never rejects — on
+  //   timeout, a status-read failure, or a closed session it resolves, so an
+  //   *unconfirmed* registry still degrades to today's immediate injection.
+  //   The one fail-closed exit is the confirmed-empty registry: every
+  //   configured server settled and none is serving tools, which is exactly
+  //   the state that produced silent toolless runs in production (FRA-3458).
   // - Provider-path validation is deferred deliberately: the failure is the
   //   intermittent live-prod race on the chief-of-staff singleton (a real
   //   runtime restart dispatching turn-1 while real mcp__* servers reconnect),
   //   which cannot be reproduced deterministically without live credentials
   //   and a forced restart racing reconnect.
   // - Live confirmation comes from the agent_bridge_claude_mcp_gate_started/
-  //   _ready/_timeout diagnostics on the next real restart, not a CI fake.
+  //   _ready/_timeout/_empty diagnostics on the next real restart, not a CI
+  //   fake.
   //
   // Block until the freshly-warmed query's MCP servers have left `pending`, so
   // the first turn's prompt is built with the mcp__* tools registered. Memoized
@@ -57763,15 +57783,22 @@ var ClaudeAgentBridgeSessionImpl = class {
         promise: this.pollMcpRegistration(query)
       };
     }
-    await this.mcpRegistrationGate.promise;
+    const result = await this.mcpRegistrationGate.promise;
+    if (result.outcome !== "empty") {
+      return;
+    }
+    this.close();
+    throw new ClaudeMcpRegistryEmptyError(result.detail);
   }
   // Poll the live query's MCP server status until no configured server is still
   // `pending`, bounded by CLAUDE_MCP_REGISTRATION_TIMEOUT_MS. Terminal states
   // (connected/failed/needs-auth/disabled) all count as settled, so a server
   // that cannot connect in this runtime (e.g. an interactively-authed server in
-  // a headless sandbox) never holds the gate to the timeout. Never rejects:
+  // a headless sandbox) never holds the gate to the timeout. A settled state
+  // where no configured server is serving tools resolves "empty" — the caller
+  // fails the send rather than injecting a toolless turn. Never rejects:
   // status-read failure, timeout, or a closed session all resolve so the caller
-  // degrades to immediate injection.
+  // degrades to immediate injection when the registry state is uncertain.
   async pollMcpRegistration(query) {
     const configuredNames = Object.keys(this.options.mcpServers ?? {});
     const startedAt = Date.now();
@@ -57781,7 +57808,7 @@ var ClaudeAgentBridgeSessionImpl = class {
     );
     while (true) {
       if (this.state.kind === "closed") {
-        return;
+        return { outcome: "closed" };
       }
       let statuses;
       try {
@@ -57790,19 +57817,26 @@ var ClaudeAgentBridgeSessionImpl = class {
         this.input.writeOutput?.(
           `agent_bridge_claude_mcp_gate_status_failed duration_ms=${Date.now() - startedAt} error=${error51 instanceof Error ? error51.message : String(error51)}`
         );
-        return;
+        return { outcome: "status_failed" };
       }
       if (mcpServersSettled(statuses, configuredNames)) {
+        if (!mcpRegistryHasTools(statuses, configuredNames)) {
+          const detail = mcpStatusDetailList(statuses);
+          this.input.writeOutput?.(
+            `agent_bridge_claude_mcp_gate_empty duration_ms=${Date.now() - startedAt} servers=${detail}`
+          );
+          return { outcome: "empty", detail };
+        }
         this.input.writeOutput?.(
           `agent_bridge_claude_mcp_gate_ready duration_ms=${Date.now() - startedAt} servers=${mcpStatusList(statuses)}`
         );
-        return;
+        return { outcome: "ready" };
       }
       if (Date.now() >= deadline) {
         this.input.writeOutput?.(
           `agent_bridge_claude_mcp_gate_timeout duration_ms=${Date.now() - startedAt} servers=${mcpStatusList(statuses)}`
         );
-        return;
+        return { outcome: "timeout" };
       }
       await delay(CLAUDE_MCP_REGISTRATION_POLL_INTERVAL_MS);
     }
@@ -57945,9 +57979,20 @@ function mcpServersSettled(statuses, configuredNames) {
     return status !== void 0 && status !== "pending";
   });
 }
+function mcpRegistryHasTools(statuses, configuredNames) {
+  const configured = new Set(configuredNames);
+  return statuses.some(
+    (server) => configured.has(server.name) && server.status === "connected" && (server.tools === void 0 || server.tools.length > 0)
+  );
+}
 function mcpStatusList(statuses) {
   return statuses.map((server) => `${server.name}:${server.status}`).join(",");
 }
+function mcpStatusDetailList(statuses) {
+  return statuses.map(
+    (server) => server.error ? `${server.name}:${server.status}(${server.error})` : `${server.name}:${server.status}`
+  ).join(",");
+}
 function delay(ms) {
   return new Promise((resolve2) => {
     const timer = setTimeout(resolve2, ms);
@@ -58055,6 +58100,13 @@ var ClaudeCodeCommandHandler = class {
   agentSession = null;
   persistedAgentId = null;
   injectedCommands = /* @__PURE__ */ new Set();
+  // Message commands whose injection has started but not settled. A fresh SDK
+  // warm inside sendMessage can outlast the bridge's command-ack window, so a
+  // redelivery may arrive while the first attempt is still in flight; acking it
+  // "duplicate" then would let the worker accept a command whose injection
+  // later fails, silently stalling the turn (FRA-3458). The duplicate branch
+  // awaits the in-flight outcome here and relays it instead.
+  inFlightMessageCommands = /* @__PURE__ */ new Map();
   pendingQuestions = /* @__PURE__ */ new Map();
   outputBuffer;
   projector = new ClaudeCodeProjector();
@@ -58102,13 +58154,25 @@ var ClaudeCodeCommandHandler = class {
       });
     }
     if (this.injectedCommands.has(delivery.commandId)) {
+      const inFlight = this.inFlightMessageCommands.get(delivery.commandId);
+      const outcome2 = inFlight ? await inFlight : { status: "injected" };
       this.input.runtimeLogger?.info(
         "agent_bridge_claude_command_duplicate",
         commandLogContext(delivery, {
           socket_id: socketId,
-          duration_ms: Date.now() - startedAt
+          duration_ms: Date.now() - startedAt,
+          awaited_in_flight: Boolean(inFlight),
+          in_flight_status: outcome2.status
         })
       );
+      if (outcome2.status === "failed") {
+        return commandAck({
+          delivery,
+          socketId,
+          status: "failed",
+          error: outcome2.error
+        });
+      }
       return commandAck({
         delivery,
         socketId,
@@ -58159,6 +58223,53 @@ var ClaudeCodeCommandHandler = class {
       });
     }
     this.injectedCommands.add(delivery.commandId);
+    const injection = this.injectMessageCommand(
+      activeContext,
+      delivery,
+      message,
+      socketId
+    );
+    this.inFlightMessageCommands.set(delivery.commandId, injection);
+    let outcome;
+    try {
+      outcome = await injection;
+    } finally {
+      this.inFlightMessageCommands.delete(delivery.commandId);
+    }
+    if (outcome.status === "failed") {
+      this.injectedCommands.delete(delivery.commandId);
+      this.input.runtimeLogger?.warn(
+        "agent_bridge_claude_command_failed",
+        commandLogContext(delivery, {
+          socket_id: socketId,
+          duration_ms: Date.now() - startedAt,
+          error: outcome.error
+        })
+      );
+      return commandAck({
+        delivery,
+        socketId,
+        status: "failed",
+        error: outcome.error
+      });
+    }
+    this.input.runtimeLogger?.info(
+      "agent_bridge_claude_command_injected",
+      commandLogContext(delivery, {
+        socket_id: socketId,
+        duration_ms: Date.now() - startedAt
+      })
+    );
+    return commandAck({
+      delivery,
+      socketId,
+      status: "injected"
+    });
+  }
+  // Runs one message command's injection to a terminal outcome. Never rejects:
+  // the returned promise is stored in the in-flight map and awaited by both the
+  // original delivery and any redeliveries, so failures travel as values.
+  async injectMessageCommand(activeContext, delivery, message, socketId) {
     try {
       const emitStartedAt = Date.now();
       this.input.runtimeLogger?.info(
@@ -58204,35 +58315,13 @@ var ClaudeCodeCommandHandler = class {
           duration_ms: Date.now() - sendStartedAt
         })
       );
+      return { status: "injected" };
     } catch (error51) {
-      this.injectedCommands.delete(delivery.commandId);
-      this.input.runtimeLogger?.warn(
-        "agent_bridge_claude_command_failed",
-        commandLogContext(delivery, {
-          socket_id: socketId,
-          duration_ms: Date.now() - startedAt,
-          error: error51 instanceof Error ? error51.message : String(error51)
-        })
-      );
-      return commandAck({
-        delivery,
-        socketId,
+      return {
         status: "failed",
         error: error51 instanceof Error ? error51.message : String(error51)
-      });
+      };
     }
-    this.input.runtimeLogger?.info(
-      "agent_bridge_claude_command_injected",
-      commandLogContext(delivery, {
-        socket_id: socketId,
-        duration_ms: Date.now() - startedAt
-      })
-    );
-    return commandAck({
-      delivery,
-      socketId,
-      status: "injected"
-    });
   }
   // -----------------------------------------------------------------------------
   // Question answering

package/dist/index.js

@@ -20265,11 +20265,14 @@ var init_templates = __esm({
 });
 
 // ../../packages/schemas/src/temporal.ts
-var ResourceReconciliationScopeSchema;
+var SessionCheckTimeoutWorkflowInputSchema, ResourceReconciliationScopeSchema;
 var init_temporal = __esm({
   "../../packages/schemas/src/temporal.ts"() {
     "use strict";
     init_zod();
+    SessionCheckTimeoutWorkflowInputSchema = external_exports.object({
+      checkId: external_exports.string().trim().min(1)
+    });
     ResourceReconciliationScopeSchema = external_exports.object({
       organizationId: external_exports.string().trim().min(1),
       projectId: external_exports.string().trim().min(1).nullable()
@@ -23170,7 +23173,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@autohq/cli",
-      version: "0.1.287",
+      version: "0.1.289",
       license: "SEE LICENSE IN README.md",
       publishConfig: {
         access: "public"
@@ -33742,25 +33745,11 @@ var AgentBridgeOutputBuffer = class {
     );
     if (!completedMessage || !completedMessage.id.trim()) {
       if (isTerminalUiMessageChunk(projection.chunk)) {
-        const statusText = terminalStatusText(projection);
-        if (statusText) {
-          await this.enqueueProjectionAndDrain(context, {
-            type: "entry",
-            entry: {
-              role: "system",
-              kind: "status",
-              status: terminalEntryStatus(projection),
-              ...projection.turnStatus ? { turnStatus: projection.turnStatus } : {},
-              ...projection.usage ? { usage: projection.usage } : {},
-              content: {
-                parts: [{ type: "text", text: statusText }]
-              }
-            }
-          });
-        }
+        await this.emitTerminalStatusEntry(context, projection);
       }
       return;
     }
+    const turnFailed = projection.turnStatus === "failed";
     this.outputSeq += 1;
     const completedAt = now2();
     const completedOutput = buildUiMessageCompletedOutputEnvelope({
@@ -33768,13 +33757,35 @@ var AgentBridgeOutputBuffer = class {
       outputSeq: this.outputSeq,
       message: completedMessage,
       status: terminalEntryStatus(projection),
-      turnStatus: projection.turnStatus,
-      usage: projection.usage,
+      turnStatus: turnFailed ? void 0 : projection.turnStatus,
+      usage: turnFailed ? void 0 : projection.usage,
       createdAt: completedAt,
       completedAt
     });
     this.enqueueOutput(completedOutput);
     await this.drainPendingOutputs();
+    if (turnFailed) {
+      await this.emitTerminalStatusEntry(context, projection);
+    }
+  }
+  async emitTerminalStatusEntry(context, projection) {
+    const statusText = terminalStatusText(projection);
+    if (!statusText) {
+      return;
+    }
+    await this.enqueueProjectionAndDrain(context, {
+      type: "entry",
+      entry: {
+        role: "system",
+        kind: "status",
+        status: terminalEntryStatus(projection),
+        ...projection.turnStatus ? { turnStatus: projection.turnStatus } : {},
+        ...projection.usage ? { usage: projection.usage } : {},
+        content: {
+          parts: [{ type: "text", text: statusText }]
+        }
+      }
+    });
   }
   async emitLiveUiMessageChunk(context, chunk) {
     this.outputSeq += 1;
@@ -34786,6 +34797,12 @@ var claudeAgentBridgeRuntime = {
 var claudeAgentSdkRuntime = {
   startup: (input) => startupClaudeAgent(input)
 };
+var ClaudeMcpRegistryEmptyError = class extends Error {
+  constructor(detail) {
+    super(`MCP tool registry came up empty at session start: ${detail}`);
+    this.name = "ClaudeMcpRegistryEmptyError";
+  }
+};
 var ClaudeAgentBridgeSessionImpl = class {
   input;
   inputQueue;
@@ -35175,17 +35192,20 @@ var ClaudeAgentBridgeSessionImpl = class {
   }
   // Why this gate is correct without a provider-backed test (it relies on real
   // SDK mcpServerStatus() timing that fakes cannot prove):
-  // - Safe-degrade: pollMcpRegistration never rejects — on timeout, a
-  //   status-read failure, or a closed session it resolves, so the worst case
-  //   is today's immediate injection. The gate can never regress below the
-  //   status-quo race; it can only close it.
+  // - Safe-degrade on uncertainty: pollMcpRegistration never rejects — on
+  //   timeout, a status-read failure, or a closed session it resolves, so an
+  //   *unconfirmed* registry still degrades to today's immediate injection.
+  //   The one fail-closed exit is the confirmed-empty registry: every
+  //   configured server settled and none is serving tools, which is exactly
+  //   the state that produced silent toolless runs in production (FRA-3458).
   // - Provider-path validation is deferred deliberately: the failure is the
   //   intermittent live-prod race on the chief-of-staff singleton (a real
   //   runtime restart dispatching turn-1 while real mcp__* servers reconnect),
   //   which cannot be reproduced deterministically without live credentials
   //   and a forced restart racing reconnect.
   // - Live confirmation comes from the agent_bridge_claude_mcp_gate_started/
-  //   _ready/_timeout diagnostics on the next real restart, not a CI fake.
+  //   _ready/_timeout/_empty diagnostics on the next real restart, not a CI
+  //   fake.
   //
   // Block until the freshly-warmed query's MCP servers have left `pending`, so
   // the first turn's prompt is built with the mcp__* tools registered. Memoized
@@ -35209,15 +35229,22 @@ var ClaudeAgentBridgeSessionImpl = class {
         promise: this.pollMcpRegistration(query)
       };
     }
-    await this.mcpRegistrationGate.promise;
+    const result = await this.mcpRegistrationGate.promise;
+    if (result.outcome !== "empty") {
+      return;
+    }
+    this.close();
+    throw new ClaudeMcpRegistryEmptyError(result.detail);
   }
   // Poll the live query's MCP server status until no configured server is still
   // `pending`, bounded by CLAUDE_MCP_REGISTRATION_TIMEOUT_MS. Terminal states
   // (connected/failed/needs-auth/disabled) all count as settled, so a server
   // that cannot connect in this runtime (e.g. an interactively-authed server in
-  // a headless sandbox) never holds the gate to the timeout. Never rejects:
+  // a headless sandbox) never holds the gate to the timeout. A settled state
+  // where no configured server is serving tools resolves "empty" — the caller
+  // fails the send rather than injecting a toolless turn. Never rejects:
   // status-read failure, timeout, or a closed session all resolve so the caller
-  // degrades to immediate injection.
+  // degrades to immediate injection when the registry state is uncertain.
   async pollMcpRegistration(query) {
     const configuredNames = Object.keys(this.options.mcpServers ?? {});
     const startedAt = Date.now();
@@ -35227,7 +35254,7 @@ var ClaudeAgentBridgeSessionImpl = class {
     );
     while (true) {
       if (this.state.kind === "closed") {
-        return;
+        return { outcome: "closed" };
       }
       let statuses;
       try {
@@ -35236,19 +35263,26 @@ var ClaudeAgentBridgeSessionImpl = class {
         this.input.writeOutput?.(
           `agent_bridge_claude_mcp_gate_status_failed duration_ms=${Date.now() - startedAt} error=${error51 instanceof Error ? error51.message : String(error51)}`
         );
-        return;
+        return { outcome: "status_failed" };
       }
       if (mcpServersSettled(statuses, configuredNames)) {
+        if (!mcpRegistryHasTools(statuses, configuredNames)) {
+          const detail = mcpStatusDetailList(statuses);
+          this.input.writeOutput?.(
+            `agent_bridge_claude_mcp_gate_empty duration_ms=${Date.now() - startedAt} servers=${detail}`
+          );
+          return { outcome: "empty", detail };
+        }
         this.input.writeOutput?.(
           `agent_bridge_claude_mcp_gate_ready duration_ms=${Date.now() - startedAt} servers=${mcpStatusList(statuses)}`
         );
-        return;
+        return { outcome: "ready" };
       }
       if (Date.now() >= deadline) {
         this.input.writeOutput?.(
           `agent_bridge_claude_mcp_gate_timeout duration_ms=${Date.now() - startedAt} servers=${mcpStatusList(statuses)}`
         );
-        return;
+        return { outcome: "timeout" };
       }
       await delay(CLAUDE_MCP_REGISTRATION_POLL_INTERVAL_MS);
     }
@@ -35391,9 +35425,20 @@ function mcpServersSettled(statuses, configuredNames) {
     return status !== void 0 && status !== "pending";
   });
 }
+function mcpRegistryHasTools(statuses, configuredNames) {
+  const configured = new Set(configuredNames);
+  return statuses.some(
+    (server) => configured.has(server.name) && server.status === "connected" && (server.tools === void 0 || server.tools.length > 0)
+  );
+}
 function mcpStatusList(statuses) {
   return statuses.map((server) => `${server.name}:${server.status}`).join(",");
 }
+function mcpStatusDetailList(statuses) {
+  return statuses.map(
+    (server) => server.error ? `${server.name}:${server.status}(${server.error})` : `${server.name}:${server.status}`
+  ).join(",");
+}
 function delay(ms) {
   return new Promise((resolve4) => {
     const timer = setTimeout(resolve4, ms);
@@ -35501,6 +35546,13 @@ var ClaudeCodeCommandHandler = class {
   agentSession = null;
   persistedAgentId = null;
   injectedCommands = /* @__PURE__ */ new Set();
+  // Message commands whose injection has started but not settled. A fresh SDK
+  // warm inside sendMessage can outlast the bridge's command-ack window, so a
+  // redelivery may arrive while the first attempt is still in flight; acking it
+  // "duplicate" then would let the worker accept a command whose injection
+  // later fails, silently stalling the turn (FRA-3458). The duplicate branch
+  // awaits the in-flight outcome here and relays it instead.
+  inFlightMessageCommands = /* @__PURE__ */ new Map();
   pendingQuestions = /* @__PURE__ */ new Map();
   outputBuffer;
   projector = new ClaudeCodeProjector();
@@ -35548,13 +35600,25 @@ var ClaudeCodeCommandHandler = class {
       });
     }
     if (this.injectedCommands.has(delivery.commandId)) {
+      const inFlight = this.inFlightMessageCommands.get(delivery.commandId);
+      const outcome2 = inFlight ? await inFlight : { status: "injected" };
       this.input.runtimeLogger?.info(
         "agent_bridge_claude_command_duplicate",
         commandLogContext(delivery, {
           socket_id: socketId,
-          duration_ms: Date.now() - startedAt
+          duration_ms: Date.now() - startedAt,
+          awaited_in_flight: Boolean(inFlight),
+          in_flight_status: outcome2.status
         })
       );
+      if (outcome2.status === "failed") {
+        return commandAck({
+          delivery,
+          socketId,
+          status: "failed",
+          error: outcome2.error
+        });
+      }
       return commandAck({
         delivery,
         socketId,
@@ -35605,6 +35669,53 @@ var ClaudeCodeCommandHandler = class {
       });
     }
     this.injectedCommands.add(delivery.commandId);
+    const injection = this.injectMessageCommand(
+      activeContext,
+      delivery,
+      message,
+      socketId
+    );
+    this.inFlightMessageCommands.set(delivery.commandId, injection);
+    let outcome;
+    try {
+      outcome = await injection;
+    } finally {
+      this.inFlightMessageCommands.delete(delivery.commandId);
+    }
+    if (outcome.status === "failed") {
+      this.injectedCommands.delete(delivery.commandId);
+      this.input.runtimeLogger?.warn(
+        "agent_bridge_claude_command_failed",
+        commandLogContext(delivery, {
+          socket_id: socketId,
+          duration_ms: Date.now() - startedAt,
+          error: outcome.error
+        })
+      );
+      return commandAck({
+        delivery,
+        socketId,
+        status: "failed",
+        error: outcome.error
+      });
+    }
+    this.input.runtimeLogger?.info(
+      "agent_bridge_claude_command_injected",
+      commandLogContext(delivery, {
+        socket_id: socketId,
+        duration_ms: Date.now() - startedAt
+      })
+    );
+    return commandAck({
+      delivery,
+      socketId,
+      status: "injected"
+    });
+  }
+  // Runs one message command's injection to a terminal outcome. Never rejects:
+  // the returned promise is stored in the in-flight map and awaited by both the
+  // original delivery and any redeliveries, so failures travel as values.
+  async injectMessageCommand(activeContext, delivery, message, socketId) {
     try {
       const emitStartedAt = Date.now();
       this.input.runtimeLogger?.info(
@@ -35650,35 +35761,13 @@ var ClaudeCodeCommandHandler = class {
           duration_ms: Date.now() - sendStartedAt
         })
       );
+      return { status: "injected" };
     } catch (error51) {
-      this.injectedCommands.delete(delivery.commandId);
-      this.input.runtimeLogger?.warn(
-        "agent_bridge_claude_command_failed",
-        commandLogContext(delivery, {
-          socket_id: socketId,
-          duration_ms: Date.now() - startedAt,
-          error: error51 instanceof Error ? error51.message : String(error51)
-        })
-      );
-      return commandAck({
-        delivery,
-        socketId,
+      return {
         status: "failed",
         error: error51 instanceof Error ? error51.message : String(error51)
-      });
+      };
     }
-    this.input.runtimeLogger?.info(
-      "agent_bridge_claude_command_injected",
-      commandLogContext(delivery, {
-        socket_id: socketId,
-        duration_ms: Date.now() - startedAt
-      })
-    );
-    return commandAck({
-      delivery,
-      socketId,
-      status: "injected"
-    });
   }
   // -----------------------------------------------------------------------------
   // Question answering

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autohq/cli",
-  "version": "0.1.287",
+  "version": "0.1.289",
   "license": "SEE LICENSE IN README.md",
   "publishConfig": {
     "access": "public"