agent-relay-runner 0.57.0 → 0.57.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.57.0",
+  "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.57.0",
+  "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;
@@ -1170,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();
@@ -1202,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