agent-relay-runner 0.57.0 → 0.57.2

package/package.json

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

package/src/control-server.ts

@@ -2,6 +2,7 @@ import type { Server, ServerWebSocket } from "bun";
 import type { Message, ReplyObligation } from "agent-relay-sdk";
 import { errMessage, isRecord } from "agent-relay-sdk";
 import type { ProviderPermissionDecisionInput, ProviderStatusEvent, SemanticStatus, TerminalAttachSpec } from "./adapter";
+import { obligationRequiresExplicitReply } from "./reply-obligation-cache";
 import { logger, parseLogLevel, LOG_LEVELS } from "./logger";
 import { buildRateLimitProviderState } from "./rate-limit";
 
@@ -199,7 +200,13 @@ function replyObligationSummary(obligations: ReplyObligation[]): Record<string,
 }
 
 function replyObligationStopDecision(obligations: ReplyObligation[]): Record<string, unknown> {
-  const summary = replyObligationSummary(obligations);
+  // #418 — never block the turn to nag for a `user` obligation: the operator already receives
+  // this turn via the session mirror, so an explicit /reply double-delivers. Only agent↔agent /
+  // spawner obligations (#413) gate the turn here; the mirror's replyTo-linking clears the user
+  // one. (The /reply-obligations summary endpoint is left unfiltered — the obligation IS pending
+  // until the mirror lands, so observability stays accurate.)
+  const enforceable = obligations.filter(obligationRequiresExplicitReply);
+  const summary = replyObligationSummary(enforceable);
   if (summary.pending !== true) return {};
   return {
     decision: "block",

package/src/reply-obligation-cache.ts

@@ -16,6 +16,17 @@ import { logger } from "./logger";
 // - A background interval keeps the snapshot warm; `markDirty()` requests an extra,
 //   debounced refresh when state likely just changed (a message arrived, a turn ended).
 
+// #418 — the human `user` sink is NOT delivered via an explicit relay reply: the agent's
+// turn is mirrored to the dashboard chat by the session-mirror lane (always, for managed
+// agents). So an explicit `/reply` to `user` double-delivers — the operator sees the mirrored
+// turn AND the explicit copy. Only agent↔agent / spawner obligations (#413) need an explicit
+// reply to clear and reach their recipient. This is the single home for that distinction —
+// both the Claude Stop-hook nag (control-server) and the non-claude re-injection (runner)
+// gate on it, so the rule must not drift between them.
+export function obligationRequiresExplicitReply(obligation: ReplyObligation): boolean {
+  return obligation.from !== "user";
+}
+
 type ReplyObligationFetch = () => Promise<ReplyObligation[]>;
 
 interface ReplyObligationCacheOptions {

package/src/runner.ts

@@ -5,12 +5,13 @@ 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";
 import { ClaimTracker } from "./claim-tracker";
 import { startControlServer, type ControlServer } from "./control-server";
-import { ReplyObligationCache } from "./reply-obligation-cache";
+import { ReplyObligationCache, obligationRequiresExplicitReply } from "./reply-obligation-cache";
 import { Outbox, type OutboxRecord } from "./outbox";
 import { extractLastAssistantTurn, extractFinalAssistantMessage, extractHookAssistantMessage, extractLatestTurnSteps, stepDedupKeys, transcriptLooksComplete } from "./adapters/claude-transcript";
 import { computeContextRatio } from "./session-insights";
@@ -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,51 @@ 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 — user obligations go through the existing codex
+    // prompt-capture path (publishProviderSessionEvent) and the session mirror (#418), never
+    // an explicit /reply. Shared predicate so this rule stays in lockstep with the Claude
+    // Stop-hook nag exemption (control-server.replyObligationStopDecision).
+    const obligations = this.obligationCache.get().filter(obligationRequiresExplicitReply);
+    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