agent-relay-runner 0.35.1 → 0.35.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.35.1",
+  "version": "0.35.3",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {

package/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.35.1",
+  "version": "0.35.3",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/plugins/claude/hooks/stop.sh

@@ -12,9 +12,14 @@ trap '[ "${_relay_clear_idle_on_exit:-0}" = "1" ] && relay_post_status_clearing_
 
 payload="$(cat || true)"
 stop_hook_active="$(relay_json_bool_field stop_hook_active "$payload")"
+
+# Session-mirror capture is orthogonal to reply-obligation gating (#332): a recursive Stop
+# (stop_hook_active=true) must NOT suppress capturing this turn's response, or the live mirror
+# silently drops frames. Always post the turn; only the reply-obligation decision is gated below.
+last_assistant_msg="$(echo "$payload" | jq -c '.last_assistant_message // empty' 2>/dev/null || true)"
+relay_post_session_turn "$(relay_json_string_field transcript_path "$payload")" "$last_assistant_msg"
+
 if [ "$stop_hook_active" != "true" ]; then
-  last_assistant_msg="$(echo "$payload" | jq -c '.last_assistant_message // empty' 2>/dev/null || true)"
-  relay_post_session_turn "$(relay_json_string_field transcript_path "$payload")" "$last_assistant_msg"
   # `|| true`: under `set -e`, a non-zero from the obligation check must never abort
   # the hook before the idle-clear — clearing the turn is the critical path (#199).
   stop_decision="$(relay_pending_reply_stop_decision || true)"

package/src/adapter.ts

@@ -154,7 +154,9 @@ export interface ProviderAdapter {
   probeActivity?(process: ManagedProcess): Promise<"busy" | "idle" | "unknown">;
   terminalAttachSpec?(process: ManagedProcess): Promise<TerminalAttachSpec>;
   respondToPermissionDecision?(process: ManagedProcess, input: ProviderPermissionDecisionInput): Promise<Record<string, unknown> | void>;
-  deliverInitialPrompt?(process: ManagedProcess, prompt: string): Promise<void>;
+  // `options.readyTimeoutMs` lets the runner widen the provider-ready wait for the
+  // first (cold-start) delivery vs. a fast re-attempt after a ready signal (#329).
+  deliverInitialPrompt?(process: ManagedProcess, prompt: string, options?: { readyTimeoutMs?: number }): Promise<void>;
   deliver(process: ManagedProcess, messages: Message[]): Promise<void>;
   onStatusChange(cb: (status: ProviderStatusUpdate) => void): void;
   // Subscribe to session-mirror events from providers that emit them directly

package/src/adapters/claude.ts

@@ -191,11 +191,11 @@ export class ClaudeAdapter implements ProviderAdapter {
     }
   }
 
-  async deliverInitialPrompt(process: ManagedProcess, prompt: string): Promise<void> {
+  async deliverInitialPrompt(process: ManagedProcess, prompt: string, options?: { readyTimeoutMs?: number }): Promise<void> {
     const session = process.meta?.tmuxSession as string | undefined;
     const socket = process.meta?.tmuxSocket as string | undefined;
     if (!session || !tmuxHasSession(session, socket)) throw new Error("no active tmux session for initial prompt");
-    await waitForClaudeInputReady(session, CLAUDE_TMUX_READY_TIMEOUT_MS, socket);
+    await waitForClaudeInputReady(session, options?.readyTimeoutMs ?? CLAUDE_TMUX_READY_TIMEOUT_MS, socket);
     await submitTextToTmux(session, prompt, socket);
   }
 

package/src/adapters/codex.ts

@@ -286,8 +286,8 @@ export class CodexAdapter implements ProviderAdapter {
     };
   }
 
-  async deliverInitialPrompt(process: ManagedProcess, prompt: string): Promise<void> {
-    const text = prompt.trim();
+  async deliverInitialPrompt(process: ManagedProcess, prompt: string, _options?: { readyTimeoutMs?: number }): Promise<void> {
+    const text = prompt.trim(); // _options.readyTimeoutMs (#329) is a Claude-TUI concern; ignored here
     if (!text) return;
     const threadId = await ensureCodexThread(process);
     let input = [

package/src/runner.ts

@@ -148,6 +148,13 @@ const INTERRUPT_RECONCILE_DELAY_MS = 1_500;
 // match) — it is emitted only by the harness, never typed by a human, so any
 // echo starting with it is a system injection, not a user prompt (#289).
 const RELAY_INJECTION_MARKERS = ["[relay message #", "[agent-relay", "<task-notification>"];
+// #329: a cold isolated profile (first-run trust/onboarding/install gates) can take far longer
+// than the warm-restart window to render an input-ready TUI, so the first prompt delivery gets a
+// generous timeout. If it still misses, the prompt is re-attempted on the next provider ready
+// signal (short timeout, since it just went idle), up to a bounded number of attempts.
+const INITIAL_PROMPT_FIRST_READY_TIMEOUT_MS = 30_000;
+const INITIAL_PROMPT_RETRY_READY_TIMEOUT_MS = 10_000;
+const MAX_INITIAL_PROMPT_ATTEMPTS = 6;
 // Reasoning tailer poll cadence (item 5). Coarse on purpose — reasoning is a
 // discreet progress signal, not a token stream, so ~1.2s keeps it light.
 const REASONING_POLL_MS = 1_200;
@@ -175,6 +182,10 @@ export class AgentRunner {
   // insights, hook-fatal) go through this durable, disk-backed, timestamped queue instead of
   // direct fire-and-forget HTTP — so nothing is lost across a server/Runner restart.
   private readonly outbox: Outbox;
+  // #332: a fast-lane outbox for display-only session-mirror trace events. Routing them through
+  // their own FIFO queue stops one transient trace failure from head-of-line blocking real-message
+  // delivery (and vice versa); its backoff is capped low since a stale live-mirror frame is cheap.
+  private readonly sessionOutbox: Outbox;
   private currentToken?: string;
   private currentTokenJti?: string;
   private currentTokenProfileId?: string;
@@ -231,6 +242,11 @@ export class AgentRunner {
   private readonly activeTaskClaims = new Map<number, ActiveTaskClaim>();
   private pendingTimelineEvent?: RunnerTimelineEvent;
   private pendingPromptMessageId?: number;
+  // #329: a spawn-time initial prompt whose first delivery timed out before the TUI was
+  // ready. Held (not dropped) for a ready-signal-driven re-attempt; cleared on success.
+  private pendingInitialPrompt?: string;
+  private deliveringInitialPrompt = false;
+  private initialPromptAttempts = 0;
   // Session-mirror: a synthesized id grouping a turn's reasoning/tool steps and
   // its final response. Set when a provider-turn starts, cleared when it ends.
   private currentTurnId?: string;
@@ -281,6 +297,14 @@ export class AgentRunner {
     const outboxDir = process.env.AGENT_RELAY_RUNNER_OUTBOX_DIR
       ?? (process.env.AGENT_RELAY_RUNNER_INFO_FILE ? join(dirname(process.env.AGENT_RELAY_RUNNER_INFO_FILE), "outbox") : undefined);
     this.outbox = new Outbox({ agentId: this.agentId, dir: outboxDir, send: (record) => this.deliverOutboxEvent(record) });
+    this.sessionOutbox = new Outbox({
+      agentId: `${this.agentId}-session`,
+      dir: outboxDir,
+      send: (record) => this.deliverOutboxEvent(record),
+      // Ephemeral trace frames: cap the per-row stall low and poison sooner than the main queue.
+      maxBackoffMs: 5_000,
+      maxAttempts: 6,
+    });
     this.bus = new RelayBusClient({
       url: relayBusUrl(options.relayUrl),
       role: "provider",
@@ -383,6 +407,7 @@ export class AgentRunner {
     await this.bus.connect();
     this.obligationCache.start();
     this.outbox.start();
+    this.sessionOutbox.start();
     this.ensureScratch();
     void this.sweepStaleScratch();
     this.process = await this.spawnProvider();
@@ -424,6 +449,7 @@ export class AgentRunner {
     this.stopReasoningTail();
     this.obligationCache.stop();
     this.outbox.close();
+    this.sessionOutbox.close();
     this.proxy?.stop();
     this.control?.stop();
     await this.bus.close();
@@ -574,11 +600,27 @@ export class AgentRunner {
 
   private async deliverInitialPrompt(): Promise<void> {
     const prompt = this.options.prompt?.trim();
-    if (!prompt || !this.process || !this.options.adapter.deliverInitialPrompt) return;
+    if (prompt) await this.attemptInitialPromptDelivery(prompt, INITIAL_PROMPT_FIRST_READY_TIMEOUT_MS);
+  }
+
+  // Deliver the spawn-time first prompt, surviving a cold-start TUI that isn't input-ready yet
+  // (#329). A ready-timeout no longer swallow-drops the prompt (the old bug → a taskless worker
+  // that looked healthy): it's stashed for a ready-signal-driven retry (setProviderStatus) and
+  // surfaced on the runner timeline, so the spawner sees a stuck delivery, not just a log line.
+  private async attemptInitialPromptDelivery(prompt: string, readyTimeoutMs: number): Promise<void> {
+    if (this.deliveringInitialPrompt || this.stopped || !this.process || !this.options.adapter.deliverInitialPrompt) return;
+    this.deliveringInitialPrompt = true;
+    const attempt = (this.initialPromptAttempts += 1);
     try {
-      await this.options.adapter.deliverInitialPrompt(this.process, prompt);
+      await this.options.adapter.deliverInitialPrompt(this.process, prompt, { readyTimeoutMs });
+      this.pendingInitialPrompt = undefined;
     } catch (error) {
-      logger.error("runner", `initial prompt delivery failed: ${error}`);
+      const giveUp = attempt >= MAX_INITIAL_PROMPT_ATTEMPTS;
+      this.pendingInitialPrompt = giveUp ? undefined : prompt;
+      logger.error("runner", `initial prompt attempt ${attempt} failed${giveUp ? " (giving up)" : "; will retry on next ready signal"}: ${errMessage(error)}`);
+      this.publishRunnerTimelineEvent({ status: "prompt_failed", timestamp: Date.now(), title: "Initial prompt not delivered", body: errMessage(error), metadata: { attempts: attempt, terminal: giveUp } });
+    } finally {
+      this.deliveringInitialPrompt = false;
     }
   }
 
@@ -1078,6 +1120,11 @@ export class AgentRunner {
     if (typeof update !== "string") {
       for (const kind of update.clear ?? []) this.claims.clearWorkKind(kind);
     }
+    // #329: the provider just went idle (ready). If a first initial-prompt delivery timed out on
+    // a cold-start TUI, re-attempt now — the ready wait should resolve almost immediately.
+    if (status === "idle" && this.pendingInitialPrompt && !this.deliveringInitialPrompt) {
+      void this.attemptInitialPromptDelivery(this.pendingInitialPrompt, INITIAL_PROMPT_RETRY_READY_TIMEOUT_MS);
+    }
     this.publishStatus();
   }
 
@@ -1161,8 +1208,9 @@ export class AgentRunner {
   }): void {
     // Durable, ordered, timestamped (#196): the actual POST happens in deliverOutboxEvent,
     // retried until it lands. occurredAt is stamped now so a queued event reports when it
-    // truly happened, not when the server finally accepted it.
-    this.outbox.enqueue({
+    // truly happened, not when the server finally accepted it. Routed through the fast-lane
+    // sessionOutbox (#332) so a transient trace failure can't head-of-line block real messages.
+    this.sessionOutbox.enqueue({
       kind: "session-message",
       payload: {
         from: input.from,