agent-relay-runner 0.56.2 → 0.57.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.56.2",
+  "version": "0.57.1",
   "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.56.2",
+  "version": "0.57.1",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/runner.ts

@@ -5,6 +5,7 @@ import { dirname, join } from "node:path";
 import type { AgentLifecycle, AgentProfile, ContextState, Message, MessageSessionMeta, ProviderCapabilities, SendMessageInput, TaskStatusInput, WorkspaceMetadata } from "agent-relay-sdk";
 import { errMessage, RelayBusClient, RelayHttpClient } from "agent-relay-sdk";
 import { contextStateFromProbeMetrics, readContextProbeState } from "agent-relay-sdk/context-probe";
+import { providerMessageText } from "./adapter";
 import type { ManagedProcess, ProviderAdapter, ProviderConfig, ProviderPermissionDecision, ProviderPermissionDecisionInput, ProviderSessionEvent, ProviderStatusUpdate, RunnerSpawnConfig, SemanticStatus, TerminalAttachSpec } from "./adapter";
 import { messagesWithCachedAttachments } from "./attachment-cache";
 import { resolveProjectName } from "./config";
@@ -288,6 +289,9 @@ export class AgentRunner {
   // from the Claude transcript into chat as discreet session events.
   private reasoningTail?: { timer: ReturnType<typeof setInterval>; seen: Set<string> };
   private scratch?: SessionScratchLayout;
+  // #417: for non-claude providers, tracks how many times each spawner obligation has
+  // been re-injected so a non-responsive agent can't spin in a re-injection loop.
+  private readonly pendingObligationInjections = new Map<number, number>();
 
   constructor(private readonly options: RunnerOptions) {
     this.agentId = options.agentId ?? options.runnerId;
@@ -570,6 +574,7 @@ export class AgentRunner {
         deliver: (messages) => this.control!.deliverToMonitor(messages),
       },
     };
+    const launchSeededPrompt = this.options.adapter.seedsInitialPromptAtLaunch ? this.options.prompt?.trim() : ""; if (launchSeededPrompt) this.recordInjectedPrompt(launchSeededPrompt);
     return this.options.adapter.spawn(config);
   }
 
@@ -617,25 +622,18 @@ export class AgentRunner {
 
   private async deliverInitialPrompt(): Promise<void> {
     const prompt = this.options.prompt?.trim();
-    if (!prompt) return;
-    // #352: adapters that seed the prompt as a launch arg (Claude's positional prompt) already
-    // delivered it at session start. Returning BEFORE attemptInitialPromptDelivery avoids a
-    // double-delivery AND leaves pendingInitialPrompt unset, so the #329 ready-signal retry never
-    // arms — one prompt, one turn. Mid-session injectPrompt + message delivery are unaffected.
-    if (this.options.adapter.seedsInitialPromptAtLaunch) return;
+    if (!prompt || this.options.adapter.seedsInitialPromptAtLaunch) return;
     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.
+  // (#329). Timeout stashes it for ready-signal retry and surfaces the stall on the timeline.
   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, { readyTimeoutMs });
+      this.recordInjectedPrompt(prompt); await this.options.adapter.deliverInitialPrompt(this.process, prompt, { readyTimeoutMs });
       this.pendingInitialPrompt = undefined;
     } catch (error) {
       const giveUp = attempt >= MAX_INITIAL_PROMPT_ATTEMPTS;
@@ -1176,6 +1174,9 @@ export class AgentRunner {
       this.compactionMidTurn = false;
       this.disarmBusyReconciler();
       this.stopReasoningTail();
+      // #417: claude enforces obligations via the stop.sh hook; for every other provider
+      // re-inject any pending spawner obligation so it surfaces the /reply command.
+      if (this.options.provider !== "claude") void this.reInjectPendingObligation();
     }
     if (status === "busy") {
       this.claims.clearTerminalStatus();
@@ -1208,6 +1209,49 @@ export class AgentRunner {
     this.publishStatus();
   }
 
+  // #417: when a non-claude provider finishes a turn with a pending spawner obligation
+  // still unresolved, re-inject the obligation as a synthetic message so providerMessageText
+  // surfaces the specific `agent-relay /reply <id>` command. Claude handles this via the
+  // stop.sh hook; every other provider needs this in-process nudge.
+  private async reInjectPendingObligation(): Promise<void> {
+    if (!this.process) return;
+    // Filter to spawner obligations only (from ≠ "user") — user obligations go through
+    // the existing codex prompt-capture path (publishProviderSessionEvent).
+    const obligations = this.obligationCache.get().filter((o) => o.from !== "user");
+    if (!obligations.length) return;
+    const MAX_REINJECTIONS = 3;
+    for (const obligation of obligations) {
+      const count = this.pendingObligationInjections.get(obligation.messageId) ?? 0;
+      if (count >= MAX_REINJECTIONS) continue;
+      this.pendingObligationInjections.set(obligation.messageId, count + 1);
+      this.sessionLog(`re-injecting pending reply obligation #${obligation.messageId} from ${obligation.from} (attempt ${count + 1}/${MAX_REINJECTIONS})`);
+      const replayMessage = {
+        id: obligation.messageId,
+        from: obligation.from,
+        to: this.agentId,
+        kind: obligation.kind,
+        ...(obligation.subject ? { subject: obligation.subject } : {}),
+        body: obligation.bodyPreview,
+        payload: {},
+        readBy: [] as string[],
+        createdAt: obligation.createdAt,
+      };
+      // Suppress the userMessage echo that providers (e.g. Codex) reflect back when
+      // a turn is started with relay-formatted content — the echo body is exactly what
+      // providerMessageText produces, which starts with "[relay message #" and is caught
+      // by the RELAY_INJECTION_MARKERS prefix check, but record it explicitly as
+      // defense-in-depth for adapters that might echo only the unformatted body text.
+      this.recordInjectedPrompt(providerMessageText([replayMessage]));
+      await this.options.adapter.deliver(this.process, [replayMessage]);
+      // Kick off a cache refresh so a cleared obligation (agent replied) is detected
+      // before the next idle fires — without this, the stale snapshot re-injects up to
+      // MAX_REINJECTIONS times even after the agent has already /reply-ed.
+      this.obligationCache.markDirty();
+      // One obligation at a time — let the provider reply before nudging again.
+      break;
+    }
+  }
+
   // Session-mirror lane: capture the assistant turn from the Claude transcript and
   // post it as a "session" message so it shows in the dashboard chat with zero
   // agent tokens. Capture is UNCONDITIONAL — it no longer depends on a triggering