@autohq/cli 0.1.187 → 0.1.196

package/dist/agent-bridge.js

@@ -20856,6 +20856,11 @@ var GithubSyncBindingCreateResponseSchema = external_exports.object({
 var GithubSyncBindingListResponseSchema = external_exports.object({
   bindings: external_exports.array(GithubSyncBindingSchema)
 });
+var GithubSyncTriggerArtifactSchema = external_exports.object({
+  type: external_exports.string().trim().min(1),
+  externalId: external_exports.string().trim().min(1),
+  payload: JsonValueSchema2.optional()
+}).strict();
 var GithubSyncWorkflowInputSchema = external_exports.discriminatedUnion("kind", [
   external_exports.object({
     kind: external_exports.literal("pull_request"),
@@ -20871,7 +20876,8 @@ var GithubSyncWorkflowInputSchema = external_exports.discriminatedUnion("kind",
     pullRequestNumber: external_exports.number().int().positive(),
     headSha: external_exports.string().trim().min(1),
     baseSha: external_exports.string().trim().min(1).optional(),
-    baseRef: GithubSyncProductionBranchSchema
+    baseRef: GithubSyncProductionBranchSchema,
+    triggerArtifact: GithubSyncTriggerArtifactSchema.optional()
   }),
   external_exports.object({
     kind: external_exports.literal("push"),
@@ -20887,7 +20893,8 @@ var GithubSyncWorkflowInputSchema = external_exports.discriminatedUnion("kind",
     ref: external_exports.string().trim().min(1),
     branch: GithubSyncProductionBranchSchema,
     before: external_exports.string().trim().min(1).optional(),
-    after: external_exports.string().trim().min(1)
+    after: external_exports.string().trim().min(1),
+    triggerArtifact: GithubSyncTriggerArtifactSchema.optional()
   })
 ]);
 var GithubSyncWorkflowResultSchema = external_exports.discriminatedUnion("status", [
@@ -21472,29 +21479,53 @@ var TriggerEventsSchema = external_exports.array(TriggerEventSchema).min(1).supe
     seen.add(event);
   }
 });
-var TriggerSharedFields = {
-  message: external_exports.string().trim().min(1).max(2e4).optional(),
-  checks: external_exports.array(
-    external_exports.object({
-      name: ResourceNameSchema,
-      displayName: external_exports.string().trim().min(1).max(256),
-      description: external_exports.string().trim().min(1).max(65535),
-      instructions: external_exports.string().trim().min(1).max(2e4).optional(),
-      timeout: TriggerCheckTimeoutSchema.optional(),
-      beginTimeout: TriggerCheckTimeoutSchema.optional(),
-      completeTimeout: TriggerCheckTimeoutSchema.optional()
-    }).strict().superRefine((check2, context) => {
-      if (check2.timeout && check2.beginTimeout) {
-        context.addIssue({
-          code: external_exports.ZodIssueCode.custom,
-          path: ["beginTimeout"],
-          message: "Use either timeout or beginTimeout for the creation-to-begin timeout, not both"
-        });
-      }
-    })
-  ).optional(),
-  routing: TriggerRoutingSchema
-};
+var PAYLOAD_PREFIXED_TEMPLATE_TOKEN = /\{\{\s*(payload(?:\.[A-Za-z0-9_.-]+)?)\s*\}\}/g;
+function refineNoPayloadPrefixedTemplateTokens(value2, context) {
+  if (value2 === void 0) {
+    return;
+  }
+  const offending = new Set(
+    [...value2.matchAll(PAYLOAD_PREFIXED_TEMPLATE_TOKEN)].map(
+      (match) => match[0]
+    )
+  );
+  if (offending.size > 0) {
+    context.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      message: `Template renders against the event payload; drop the "payload." prefix (use "{{github.\u2026}}", not "{{payload.github.\u2026}}"). Offending tokens: ${[...offending].join(", ")}`
+    });
+  }
+}
+function templateField(guard) {
+  const field = external_exports.string().trim().min(1).max(2e4).optional();
+  return guard === "authoring" ? field.superRefine(refineNoPayloadPrefixedTemplateTokens) : field;
+}
+var TriggerChecksField = external_exports.array(
+  external_exports.object({
+    name: ResourceNameSchema,
+    displayName: external_exports.string().trim().min(1).max(256),
+    description: external_exports.string().trim().min(1).max(65535),
+    instructions: external_exports.string().trim().min(1).max(2e4).optional(),
+    timeout: TriggerCheckTimeoutSchema.optional(),
+    beginTimeout: TriggerCheckTimeoutSchema.optional(),
+    completeTimeout: TriggerCheckTimeoutSchema.optional()
+  }).strict().superRefine((check2, context) => {
+    if (check2.timeout && check2.beginTimeout) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["beginTimeout"],
+        message: "Use either timeout or beginTimeout for the creation-to-begin timeout, not both"
+      });
+    }
+  })
+).optional();
+function triggerSharedFields(guard) {
+  return {
+    message: templateField(guard),
+    checks: TriggerChecksField,
+    routing: TriggerRoutingSchema
+  };
+}
 var TriggerEventSourceFields = {
   connection: ConnectionNameSchema.optional(),
   endpoint: external_exports.string().trim().min(1).optional(),
@@ -21512,67 +21543,79 @@ var TriggerEventSourceFields = {
     })
   ]).optional()
 };
-var TriggerBaseSchema = external_exports.object({
-  event: TriggerEventSchema,
-  ...TriggerSharedFields,
-  ...TriggerEventSourceFields
-}).strict().superRefine((trigger, context) => {
-  validateTriggerChecks(trigger, context, [trigger.event]);
-});
-var TriggerDefinitionBaseSchema = external_exports.object({
-  event: TriggerEventSchema.optional(),
-  events: TriggerEventsSchema.optional(),
-  ...TriggerSharedFields,
-  ...TriggerEventSourceFields
-}).strict().superRefine((trigger, context) => {
-  if (trigger.event && trigger.events) {
-    context.addIssue({
-      code: external_exports.ZodIssueCode.custom,
-      path: ["events"],
-      message: "Use either event or events, not both"
-    });
-  }
-  if (!trigger.event && !trigger.events) {
-    context.addIssue({
-      code: external_exports.ZodIssueCode.custom,
-      path: ["event"],
-      message: "Trigger requires event or events"
-    });
-  }
-  validateTriggerChecks(
-    trigger,
-    context,
-    trigger.event ? [trigger.event] : trigger.events ?? []
-  );
-});
-var TriggerSchema = TriggerBaseSchema.extend({
+function triggerBaseSchema(guard) {
+  return external_exports.object({
+    event: TriggerEventSchema,
+    ...triggerSharedFields(guard),
+    ...TriggerEventSourceFields
+  }).strict().superRefine((trigger, context) => {
+    validateTriggerChecks(trigger, context, [trigger.event]);
+  });
+}
+function triggerDefinitionBaseSchema(guard) {
+  return external_exports.object({
+    event: TriggerEventSchema.optional(),
+    events: TriggerEventsSchema.optional(),
+    ...triggerSharedFields(guard),
+    ...TriggerEventSourceFields
+  }).strict().superRefine((trigger, context) => {
+    if (trigger.event && trigger.events) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["events"],
+        message: "Use either event or events, not both"
+      });
+    }
+    if (!trigger.event && !trigger.events) {
+      context.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["event"],
+        message: "Trigger requires event or events"
+      });
+    }
+    validateTriggerChecks(
+      trigger,
+      context,
+      trigger.event ? [trigger.event] : trigger.events ?? []
+    );
+  });
+}
+function heartbeatTriggerBaseSchema(guard) {
+  return external_exports.object({
+    kind: external_exports.literal("heartbeat"),
+    event: external_exports.never().optional(),
+    connection: external_exports.never().optional(),
+    endpoint: external_exports.never().optional(),
+    auth: external_exports.never().optional(),
+    cron: external_exports.string().trim().min(1).max(512),
+    timezone: external_exports.string().trim().min(1).max(128).default("UTC"),
+    ...triggerSharedFields(guard)
+  }).strict().superRefine((trigger, context) => {
+    validateTriggerChecks(trigger, context, ["heartbeat"]);
+  });
+}
+var TriggerSchema = triggerBaseSchema("stored").extend({
   where: external_exports.record(external_exports.string(), JsonValueSchema2).default({})
 });
-var ApplyTriggerSchema = TriggerBaseSchema.extend({
+var ApplyTriggerSchema = triggerBaseSchema("authoring").extend({
   where: TriggerFilterSchema
 });
-var HeartbeatTriggerBaseSchema = external_exports.object({
-  kind: external_exports.literal("heartbeat"),
-  event: external_exports.never().optional(),
-  connection: external_exports.never().optional(),
-  endpoint: external_exports.never().optional(),
-  auth: external_exports.never().optional(),
-  cron: external_exports.string().trim().min(1).max(512),
-  timezone: external_exports.string().trim().min(1).max(128).default("UTC"),
-  ...TriggerSharedFields
-}).strict().superRefine((trigger, context) => {
-  validateTriggerChecks(trigger, context, ["heartbeat"]);
-});
-var HeartbeatTriggerSchema = HeartbeatTriggerBaseSchema.extend({
+var HeartbeatTriggerSchema = heartbeatTriggerBaseSchema(
+  "stored"
+).extend({
   where: external_exports.record(external_exports.string(), JsonValueSchema2).default({})
 });
-var ApplyHeartbeatTriggerSchema = HeartbeatTriggerBaseSchema.extend({
+var ApplyHeartbeatTriggerSchema = heartbeatTriggerBaseSchema(
+  "authoring"
+).extend({
   where: TriggerFilterSchema
 });
-var TriggerDefinitionSchema = TriggerDefinitionBaseSchema.extend({
+var TriggerDefinitionSchema = triggerDefinitionBaseSchema("stored").extend({
   where: external_exports.record(external_exports.string(), JsonValueSchema2).default({})
 });
-var ApplyTriggerDefinitionSchema = TriggerDefinitionBaseSchema.extend({
+var ApplyTriggerDefinitionSchema = triggerDefinitionBaseSchema(
+  "authoring"
+).extend({
   where: TriggerFilterSchema
 });
 var TriggersSchema = external_exports.array(external_exports.union([TriggerDefinitionSchema, HeartbeatTriggerSchema])).transform(expandTriggerDefinitions).superRefine(validateAttributedRunsTriggerPairing);
@@ -21631,7 +21674,7 @@ var AgentSpecFieldsSchema = external_exports.object({
   systemPrompt: external_exports.string().trim().min(1).max(1e5).optional(),
   environment: ResourceNameSchema.optional(),
   identity: external_exports.union([ResourceNameSchema, AgentIdentitySchema]).optional(),
-  initialPrompt: external_exports.string().trim().min(1).max(2e4).optional(),
+  initialPrompt: templateField("stored"),
   env: SecretEnvSchema.default({}),
   mounts: external_exports.array(AgentMountSchema).default([]),
   triggers: TriggersSchema.default([]),
@@ -21658,6 +21701,7 @@ var AgentSpecSchema = AgentSpecFieldsSchema.superRefine(
   validateRunnableConfig
 );
 var AgentApplySpecSchema = AgentSpecFieldsSchema.extend({
+  initialPrompt: templateField("authoring"),
   triggers: ApplyTriggersSchema.default([])
 }).superRefine(validateRunnableConfig);
 var AgentStatusSchema = external_exports.object({
@@ -22251,6 +22295,11 @@ var ProjectResourceApplyAuditActionSchema = external_exports.enum([
   "github_sync.apply"
 ]);
 var ProjectResourceApplyOperationIdSchema = external_exports.string().trim().min(1).max(512);
+var ProjectResourceApplyTriggerArtifactSchema = external_exports.object({
+  type: external_exports.string().trim().min(1),
+  externalId: external_exports.string().trim().min(1),
+  payload: JsonValueSchema2.optional()
+}).strict();
 var ProjectResourceApplyWorkflowErrorSchema = external_exports.object({
   name: external_exports.string().trim().min(1),
   message: external_exports.string().trim().min(1)
@@ -22262,7 +22311,8 @@ var ProjectResourceApplyWorkflowInputSchema = external_exports.object({
   organizationId: OrganizationIdSchema,
   projectId: ProjectIdSchema.nullable().optional(),
   actor: AuthActorSchema,
-  auditAction: ProjectResourceApplyAuditActionSchema
+  auditAction: ProjectResourceApplyAuditActionSchema,
+  triggerArtifact: ProjectResourceApplyTriggerArtifactSchema.optional()
 }).superRefine((input, context) => {
   if ((input.request ? 1 : 0) + (input.sourceRequest ? 1 : 0) !== 1) {
     context.addIssue({
@@ -22680,8 +22730,27 @@ var SessionCommandSenderSchema = external_exports.discriminatedUnion("type", [
     type: external_exports.literal("system")
   })
 ]);
+var MESSAGE_DELIVERY_MODES = ["interrupt", "deferred"];
+var MessageDeliveryModeSchema = external_exports.enum(MESSAGE_DELIVERY_MODES);
+var TRIGGER_INJECTION_MODALITIES = [
+  "chat",
+  "githubCheck",
+  "githubCheckAction",
+  "githubPullRequest",
+  "other"
+];
+var TriggerInjectionModalitySchema = external_exports.enum(
+  TRIGGER_INJECTION_MODALITIES
+);
 var RunMessageCommandPayloadSchema = external_exports.object({
   message: external_exports.string().trim().min(1),
+  // Optional so existing payloads and direct operator/agent messages stay
+  // valid without it; trigger routing sets "deferred" for GitHub check
+  // events. An absent mode is treated as "interrupt" at the delivery
+  // boundary (commandDeliveryPayload / the runtime handler), so the default
+  // lives where the value is consumed rather than as a required field every
+  // call site must construct.
+  deliveryMode: MessageDeliveryModeSchema.optional(),
   metadata: JsonValueSchema2.optional()
 }).strict();
 var RunAnswerCommandPayloadSchema = external_exports.object({
@@ -26571,7 +26640,7 @@ Object.assign(lookup, {
 // package.json
 var package_default = {
   name: "@autohq/cli",
-  version: "0.1.187",
+  version: "0.1.196",
   license: "SEE LICENSE IN README.md",
   publishConfig: {
     access: "public"
@@ -46886,6 +46955,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_STARTUP_PROFILE_HOOK_EVENTS = [
   "Setup",
   "SessionStart",
@@ -46918,6 +46988,21 @@ var ClaudeAgentBridgeSessionImpl = class {
   activeTurnCount = 0;
   interruptInFlight = null;
   exitReported = false;
+  // Messages delivered in "deferred" mode while a turn is in flight. They are
+  // held here instead of injected mid-turn (which would reject a pending
+  // tool_use) and flushed once the turn ends and the session is idle.
+  deferredMessages = [];
+  // 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
+  // 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.
+  turnResultCount = 0;
+  turnSettlementWaiters = /* @__PURE__ */ new Set();
   constructor(input) {
     const optionsStartedAt = Date.now();
     this.input = input;
@@ -46960,13 +47045,17 @@ var ClaudeAgentBridgeSessionImpl = class {
       throw error51;
     }
   }
-  async sendMessage(message) {
+  async sendMessage(message, options) {
+    const mode = options?.mode ?? "interrupt";
+    if (mode === "deferred" && this.hasInterruptibleTurn()) {
+      this.deferredMessages.push(message);
+      this.input.writeOutput?.(
+        `agent_bridge_claude_message_deferred active_turn_count=${this.activeTurnCount}`
+      );
+      return;
+    }
     await this.interruptActiveTurnBeforeMessage();
-    this.inputQueue.push(claudeAgentUserMessage(message));
-    this.activeTurnCount += 1;
-    void this.ensureRunningQuery().catch((error51) => {
-      void this.input.onError(error51);
-    });
+    this.enqueueUserMessage(message);
   }
   close() {
     const previousState = this.state;
@@ -46975,6 +47064,14 @@ var ClaudeAgentBridgeSessionImpl = class {
     }
     this.state = { kind: "closed" };
     this.activeTurnCount = 0;
+    this.pendingToolUseIds.clear();
+    this.resolveTurnSettlement(false);
+    if (this.deferredMessages.length > 0) {
+      this.input.writeOutput?.(
+        `agent_bridge_claude_deferred_dropped count=${this.deferredMessages.length} reason=session_closed`
+      );
+      this.deferredMessages.length = 0;
+    }
     this.stderr.flush();
     this.inputQueue.close();
     if (previousState.kind === "started") {
@@ -47057,8 +47154,15 @@ var ClaudeAgentBridgeSessionImpl = class {
     void (async () => {
       try {
         for await (const message of query) {
+          this.trackToolUseLifecycle(message);
           if (isClaudeAgentTurnResult(message)) {
             this.activeTurnCount = Math.max(0, this.activeTurnCount - 1);
+            this.pendingToolUseIds.clear();
+            this.turnResultCount += 1;
+            this.resolveTurnSettlement(true);
+            if (this.activeTurnCount === 0) {
+              this.flushDeferredMessages();
+            }
           }
           const failure = probeClaudeAgentMessage(
             message,
@@ -47082,23 +47186,116 @@ var ClaudeAgentBridgeSessionImpl = class {
         }
       } finally {
         this.activeTurnCount = 0;
+        this.pendingToolUseIds.clear();
+        this.resolveTurnSettlement(false);
         this.state = { kind: "closed" };
         this.reportExit();
       }
     })();
   }
+  // Queue a user message as a fresh turn. Pushing before ensureRunningQuery()
+  // lets injection work while the SDK session is still starting; the queue
+  // drains once the query attaches. Startup failures surface through onError
+  // instead of failing injection.
+  enqueueUserMessage(message) {
+    this.inputQueue.push(claudeAgentUserMessage(message));
+    this.activeTurnCount += 1;
+    void this.ensureRunningQuery().catch((error51) => {
+      void this.input.onError(error51);
+    });
+  }
+  // A turn the SDK is actively running, so a new user message would either
+  // interrupt it or land mid-turn. Startup/idle states have nothing to disturb.
+  hasInterruptibleTurn() {
+    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
+  // unresolved stop_reason=tool_use ahead of the injected user message.
+  hasInFlightToolUse() {
+    return this.pendingToolUseIds.size > 0;
+  }
+  // Track tool_use/tool_result pairs as they stream so hasInFlightToolUse()
+  // reflects the live transcript. tool_use opens a call; the matching
+  // tool_result closes it; the turn's terminal result clears any remainder.
+  trackToolUseLifecycle(message) {
+    for (const id of toolUseIds(message)) {
+      this.pendingToolUseIds.add(id);
+    }
+    for (const id of toolResultIds(message)) {
+      this.pendingToolUseIds.delete(id);
+    }
+  }
+  // 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. On timeout the caller falls
+  // back to immediate injection rather than hanging or dropping the message.
+  awaitTurnSettlement(baseline, startedAt) {
+    if (this.turnResultCount > baseline) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      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}`
+        );
+        resolve();
+      };
+      const waiter = (settled) => finish(settled ? "ready" : "aborted");
+      const timer = setTimeout(
+        () => finish("timeout"),
+        CLAUDE_INTERRUPT_SETTLE_TIMEOUT_MS
+      );
+      timer.unref?.();
+      this.turnSettlementWaiters.add(waiter);
+    });
+  }
+  resolveTurnSettlement(settled) {
+    if (this.turnSettlementWaiters.size === 0) {
+      return;
+    }
+    const waiters = [...this.turnSettlementWaiters];
+    this.turnSettlementWaiters.clear();
+    for (const waiter of waiters) {
+      waiter(settled);
+    }
+  }
+  flushDeferredMessages() {
+    if (this.deferredMessages.length === 0) {
+      return;
+    }
+    const pending = this.deferredMessages.splice(0);
+    this.input.writeOutput?.(
+      `agent_bridge_claude_deferred_flush count=${pending.length}`
+    );
+    for (const message of pending) {
+      this.enqueueUserMessage(message);
+    }
+  }
   async interruptActiveTurnBeforeMessage() {
-    if (this.activeTurnCount === 0 || this.state.kind !== "running") {
+    if (!this.hasInterruptibleTurn()) {
       return;
     }
     if (this.interruptInFlight) {
       await this.interruptInFlight;
       return;
     }
+    if (this.state.kind !== "running") {
+      return;
+    }
     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()}`
+      `agent_bridge_claude_mid_turn_interrupt_started at=${new Date(startedAt).toISOString()} in_flight_tool_use=${hadInFlightToolUse}`
     );
     const interruptPromise = (async () => {
       try {
@@ -47111,6 +47308,9 @@ var ClaudeAgentBridgeSessionImpl = class {
           `agent_bridge_claude_mid_turn_interrupt_failed duration_ms=${Date.now() - startedAt} error=${error51 instanceof Error ? error51.message : String(error51)}`
         );
       }
+      if (hadInFlightToolUse) {
+        await this.awaitTurnSettlement(settlementBaseline, startedAt);
+      }
     })();
     this.interruptInFlight = interruptPromise;
     try {
@@ -47268,6 +47468,30 @@ function claudeAgentUserMessage(message) {
 function isClaudeAgentTurnResult(message) {
   return message.type === "result";
 }
+function toolUseIds(message) {
+  if (message.type !== "assistant") {
+    return [];
+  }
+  return contentBlocks(message.message.content).flatMap(
+    (block) => block.type === "tool_use" && typeof block.id === "string" ? [block.id] : []
+  );
+}
+function toolResultIds(message) {
+  if (message.type !== "user") {
+    return [];
+  }
+  return contentBlocks(message.message.content).flatMap(
+    (block) => block.type === "tool_result" && typeof block.tool_use_id === "string" ? [block.tool_use_id] : []
+  );
+}
+function contentBlocks(content) {
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  return content.filter(
+    (block) => typeof block === "object" && block !== null
+  );
+}
 
 // src/commands/agent-bridge/harness/claude-code/index.ts
 async function runAgentBridgeClaudeCode(options) {
@@ -47371,7 +47595,9 @@ var ClaudeCodeCommandHandler = class {
           }
         }
       });
-      await this.ensureAgentSession().sendMessage(message);
+      await this.ensureAgentSession().sendMessage(message, {
+        mode: deliveryMode(delivery)
+      });
     } catch (error51) {
       this.injectedCommands.delete(delivery.commandId);
       return commandAck({
@@ -47617,6 +47843,16 @@ function deliveryMessage(delivery) {
   }
   return null;
 }
+function deliveryMode(delivery) {
+  const payload = delivery.payload;
+  if (payload && typeof payload === "object" && "deliveryMode" in payload) {
+    const parsed = MessageDeliveryModeSchema.safeParse(payload.deliveryMode);
+    if (parsed.success) {
+      return parsed.data;
+    }
+  }
+  return "interrupt";
+}
 
 // src/commands/agent-bridge/entrypoint.ts
 async function runAgentBridgeProcess(input) {