agent-relay-runner 0.68.1 → 0.69.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.68.1",
+  "version": "0.69.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.68.1",
+  "version": "0.69.1",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/reply-obligation-cache.ts

@@ -27,6 +27,20 @@ export function obligationRequiresExplicitReply(obligation: ReplyObligation): bo
   return obligation.from !== "user";
 }
 
+export function responseCaptureReplyRoute(
+  obligations: ReplyObligation[],
+  currentTurnStartedAt?: number,
+  opts: { suppressUser?: boolean } = {},
+): { replyToMessageId?: number; to: string } | null {
+  const eligible = [...obligations].reverse()
+    .filter((o) => currentTurnStartedAt === undefined || o.createdAt <= currentTurnStartedAt);
+  const explicit = eligible.find(obligationRequiresExplicitReply);
+  if (explicit) return { replyToMessageId: explicit.messageId, to: explicit.from };
+  const user = eligible.find((o) => o.from === "user");
+  if (!user) return { to: "user" };
+  return opts.suppressUser ? null : { replyToMessageId: user.messageId, to: "user" };
+}
+
 type ReplyObligationFetch = () => Promise<ReplyObligation[]>;
 
 interface ReplyObligationCacheOptions {

package/src/response-capture-report.ts

@@ -0,0 +1,59 @@
+import type { MessageSessionMeta, SendMessageInput } from "agent-relay-sdk";
+
+interface ReportOutbox {
+  enqueue(record: { kind: string; idempotencyKey?: string; payload: SendMessageInput }): void;
+}
+
+type SessionPublisher = (input: {
+  from: string;
+  to: string;
+  body: string;
+  session: MessageSessionMeta;
+  replyTo?: number;
+}) => void | Promise<void>;
+
+export async function publishCapturedResponse(input: {
+  publishSessionEvent: SessionPublisher;
+  outbox: ReportOutbox;
+  provider: string;
+  from: string;
+  to: string;
+  body: string;
+  session: MessageSessionMeta;
+  replyTo?: number;
+}): Promise<void> {
+  await input.publishSessionEvent({
+    from: input.from,
+    to: input.to,
+    body: input.body,
+    ...(input.replyTo ? { replyTo: input.replyTo } : {}),
+    session: input.session,
+  });
+  enqueueCapturedResponseReport(input);
+}
+
+export function enqueueCapturedResponseReport(input: {
+  outbox: ReportOutbox;
+  provider: string;
+  from: string;
+  to: string;
+  body: string;
+  session: MessageSessionMeta;
+  replyTo?: number;
+}): void {
+  if (!input.replyTo || input.to === "user") return;
+  const turnId = input.session.turnId ?? "";
+  input.outbox.enqueue({
+    kind: "session-message",
+    idempotencyKey: `response-report:${input.from}:${input.replyTo}:${turnId}`,
+    payload: {
+      from: input.from,
+      to: input.to,
+      replyTo: input.replyTo,
+      kind: "chat",
+      body: input.body,
+      replyExpected: false,
+      payload: { responseCapture: { provider: input.provider, ...input.session } },
+    },
+  });
+}

package/src/runner-core.ts

@@ -10,7 +10,7 @@ import type { ManagedProcess, ProviderAdapter, ProviderConfig, ProviderPermissio
 import { messagesWithCachedAttachments } from "./attachment-cache";
 import { ClaimTracker } from "./claim-tracker";
 import { startControlServer, type ControlServer } from "./control-server";
-import { ReplyObligationCache, obligationRequiresExplicitReply } from "./reply-obligation-cache";
+import { ReplyObligationCache, obligationRequiresExplicitReply, responseCaptureReplyRoute } from "./reply-obligation-cache";
 import { Outbox, type OutboxRecord } from "./outbox";
 import { extractLastAssistantTurn, extractLastAssistantTurnAfterEntry, countTranscriptEntries, extractFinalAssistantMessage, extractFinalAssistantMessageAfterEntry, extractHookAssistantMessage, extractLatestTurnSteps, stepDedupKeys, transcriptLooksComplete } from "./adapters/claude-transcript";
 import { profileUsesHostProviderGlobals } from "./profile-home";
@@ -22,6 +22,7 @@ import { ensureSessionScratch, reapSessionScratch, sweepStaleSessions, type Sess
 import { deliverBufferedMcpCall as deliverBufferedMcpOutboxCall, deliverRunnerOutboxEvent } from "./mcp-outbox";
 import { RunnerInsights } from "./runner-insights";
 import { BusyReconciler } from "./busy-reconciler";
+import { publishCapturedResponse } from "./response-capture-report";
 import { capsFromEnv, contextStateDirFromEnv, logLevelFromEnv, mcpProxyEnabledFromEnv, orchestratorBaseDirFromEnv, orchestratorUrlFromEnv, registrationTimeoutMsFromEnv, runnerInfoFileFromEnv, runnerLogFileFromEnv, runnerOutboxDirWithInfoFallback, sessionDebugEnabled, tagsFromEnv, workspaceModeFromEnv } from "./config";
 import {
   appliedAgentProfileMetadata,
@@ -725,6 +726,7 @@ export class AgentRunner {
       });
       await this.options.adapter.deliver(this.process, prepared);
       for (const message of deliverable) {
+        await this.http.recordMessageDeliveryAttempt(message.id, { agentId: this.agentId, status: "delivered" }).catch(() => {});
         await this.http.markRead(message.id, this.agentId).catch(() => {});
         if (!taskIdFromMessage(message)) this.claims.finishClaim("message", String(message.id));
       }
@@ -1336,7 +1338,7 @@ export class AgentRunner {
     const turnId = this.currentTurnId;
     this.stopReasoningTail();
     // Optional correlation for threading + obligation clearing — never a capture gate.
-    let replyToMessageId: number | undefined;
+    let replyToMessageId: number | undefined, replyTarget = "user";
     const pendingPrompt = this.pendingPromptMessageId;
     if (pendingPrompt) {
       replyToMessageId = pendingPrompt;
@@ -1344,8 +1346,8 @@ export class AgentRunner {
     } else {
       // Correlation-only (threading + obligation clearing) — the local snapshot is fresh
       // enough and never blocks the response-capture path (#196).
-      const obligation = [...this.obligationCache.get()].reverse().find((o) => o.from === "user");
-      replyToMessageId = obligation?.messageId;
+      const route = responseCaptureReplyRoute(this.obligationCache.get(), this.currentTurnStartedAt);
+      replyToMessageId = route?.replyToMessageId; replyTarget = route?.to ?? "user";
     }
 
     // Grab and reset the pre-flush cursor before extraction: the cursor may be
@@ -1389,13 +1391,7 @@ export class AgentRunner {
     }
 
     this.sessionLog(`response captured for turn ${turnId ?? "?"} (${body.length} chars${replyToMessageId ? `, replyTo #${replyToMessageId}` : ", no replyTo"})`);
-    await this.publishSessionEvent({
-      from: this.agentId,
-      to: "user",
-      body,
-      ...(replyToMessageId ? { replyTo: replyToMessageId } : {}),
-      session: { type: "response", origin: "provider", ...(turnId ? { turnId } : {}) },
-    });
+    await publishCapturedResponse({ publishSessionEvent: (event) => this.publishSessionEvent(event), outbox: this.sessionOutbox, provider: this.options.provider, from: this.agentId, to: replyTarget, body, replyTo: replyToMessageId, session: { type: "response", origin: "provider", ...(turnId ? { turnId } : {}) } });
     // The agent's reply may have cleared an obligation — refresh the snapshot so the next
     // turn-end doesn't re-prompt for a message already answered (#196).
     if (replyToMessageId) this.obligationCache.markDirty();
@@ -1600,24 +1596,19 @@ export class AgentRunner {
     }
     if (event.type === "response") {
       // Dashboard prompt injection is already answered by this captured App Server
-      // response. Other Relay inbox obligations still belong to the agent's explicit
-      // reply path, so those keep suppressing auto-capture to avoid duplicates.
-      let replyToMessageId: number | undefined;
+      // response. User obligations still belong to the session mirror; spawner
+      // obligations (#413) route to the spawn-parent with replyTo to clear the debt.
+      let replyToMessageId: number | undefined, replyTarget = "user";
       const pendingPrompt = this.pendingPromptMessageId;
       if (pendingPrompt) {
         replyToMessageId = pendingPrompt;
         this.pendingPromptMessageId = undefined;
-      } else if (this.obligationCache.get().some((o) => o.from === "user" && this.obligationPredatesCurrentTurn(o))) {
-        // The agent will answer the relay obligation itself — don't double-post (#196).
-        return;
+      } else {
+        const route = responseCaptureReplyRoute(this.obligationCache.get(), this.currentTurnStartedAt, { suppressUser: true });
+        if (!route) return; // The session mirror will satisfy the user obligation; don't double-post (#196).
+        replyToMessageId = route.replyToMessageId; replyTarget = route.to;
       }
-      await this.publishSessionEvent({
-        from: this.agentId,
-        to: "user",
-        body,
-        ...(replyToMessageId ? { replyTo: replyToMessageId } : {}),
-        session: { type: "response", origin: event.origin ?? "provider", ...(turnId ? { turnId } : {}) },
-      });
+      await publishCapturedResponse({ publishSessionEvent: (sessionEvent) => this.publishSessionEvent(sessionEvent), outbox: this.sessionOutbox, provider: this.options.provider, from: this.agentId, to: replyTarget, body, replyTo: replyToMessageId, session: { type: "response", origin: event.origin ?? "provider", ...(turnId ? { turnId } : {}) } });
       if (replyToMessageId) this.obligationCache.markDirty();
       return;
     }
@@ -1660,10 +1651,6 @@ export class AgentRunner {
     return false;
   }
 
-  private obligationPredatesCurrentTurn(obligation: { createdAt: number }): boolean {
-    return this.currentTurnStartedAt === undefined || obligation.createdAt <= this.currentTurnStartedAt;
-  }
-
   // Force-clear a stuck provider-turn claim directly. Unlike the idle status path
   // it does NOT depend on a matching claim id (the Stop hook keys busy as
   // provider-turn:provider-turn, but reconciliation has no specific id), and it