agent-relay-runner 0.125.0 → 0.126.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.125.0",
+  "version": "0.126.0",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -23,7 +23,7 @@
   },
   "dependencies": {
     "agent-relay-providers": "0.104.4",
-    "agent-relay-sdk": "0.2.116",
+    "agent-relay-sdk": "0.2.117",
     "callmux": "0.23.0"
   },
   "devDependencies": {

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.125.0",
+  "version": "0.126.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/adapters/codex-agent-message-capture.ts

@@ -45,17 +45,16 @@ export class CodexAgentMessageCapture {
     this.currentSegment = [];
   }
 
-  // Deterministic turn-final response: the TRAILING agentMessage run only — all items after
-  // the LAST non-message item (tool call, file change, reasoning...) in the turn (design
-  // #1079 §3.2). Earlier agentMessage segments are mid-work narration, already mirrored live
-  // via `emit`, and must not be re-injected into the final (#1083 Finding 2). Codex's own
-  // phase:"commentary" tag (see completeItem above) still trims commentary items out of
-  // whichever segment they land in, but is not the sole guard against leading narration.
+  // Deterministic turn-final response: prefer the trailing structured report span, not a generic
+  // post-handoff coda. The original #1079/#1086 trailing-run rule correctly kept early narration
+  // out, but it over-trimmed Codex turns shaped "summary -> workspace ready -> Landed..." and made
+  // report-up deliver only the coda (#1136). We still drop leading narration; we just let structured
+  // report markers beat a terse final status line.
   finish(emit: EmitAgentMessage): string | undefined {
     this.closeSegment(emit);
-    const trailingSegment = this.segments.at(-1);
+    const trailingSegment = selectFinalResponseSegments(this.segments);
     this.segments = [];
-    const text = trailingSegment ? segmentBody(trailingSegment) : undefined;
+    const text = trailingSegment ? trailingSegment.map(segmentBody).join("\n\n").trim() : undefined;
     return truncateCapturedResponse(text);
   }
 
@@ -105,6 +104,37 @@ function segmentBody(segment: ResponseEntry[]): string {
   return segment.map((entry) => entry.body).join("\n\n").trim();
 }
 
+function selectFinalResponseSegments(segments: ResponseEntry[][]): ResponseEntry[][] | undefined {
+  const bodies = segments.map(segmentBody).filter(Boolean);
+  if (!bodies.length) return undefined;
+  let end = bodies.length - 1;
+  while (end > 0 && isGenericFinalCoda(bodies[end]!) && bodies.slice(0, end).some(isSubstantiveReportSegment)) end--;
+  const firstReport = bodies.slice(0, end + 1).findIndex(isReportBoundarySegment);
+  if (firstReport >= 0) return segments.slice(firstReport, end + 1);
+  for (let i = end; i >= 0; i--) {
+    if (isSubstantiveReportSegment(bodies[i]!)) return [segments[i]!];
+  }
+  return [segments[end]!];
+}
+
+const REPORT_BOUNDARY = /(^|\n)(#{1,6}\s|\*\*(summary|what changed|rca|fix|tests?|gates?|verification|risk)\b|(?:summary|what changed|rca|fix|tests?|gates?|verification|risk):)/i;
+const REPORT_STRUCTURE = /(^|\n)\s*[-*]\s+\S|`[^`]+`|\b(typecheck|bun test|tests? pass(?:ed)?|gates? green|rca|verified|implemented)\b/i;
+const GENERIC_FINAL_CODA = /^(?:done|landed(?: on main)?|committed|merged|ready|no further action|nothing further|all set)\b|(?:\bno further action needed\b|\bnothing further needed\b)$/i;
+
+function isReportBoundarySegment(body: string): boolean {
+  return REPORT_BOUNDARY.test(body.trim());
+}
+
+function isSubstantiveReportSegment(body: string): boolean {
+  const trimmed = body.trim();
+  return !isGenericFinalCoda(trimmed) && (trimmed.length >= 120 || isReportBoundarySegment(trimmed) || REPORT_STRUCTURE.test(trimmed));
+}
+
+function isGenericFinalCoda(body: string): boolean {
+  const trimmed = body.trim();
+  return trimmed.length <= 180 && GENERIC_FINAL_CODA.test(trimmed) && !isReportBoundarySegment(trimmed);
+}
+
 function truncateCapturedResponse(text: string | undefined): string | undefined {
   if (!text || text.length <= MAX_CAPTURED_RESPONSE_CHARS) return text;
   return `${text.slice(0, MAX_CAPTURED_RESPONSE_CHARS).trimEnd()}\n\n${TRUNCATION_MARKER_PREFIX} showing first ${MAX_CAPTURED_RESPONSE_CHARS} of ${text.length} chars]`;

package/src/runner-core.ts

@@ -51,7 +51,7 @@ import {
   runnerAgentStatus,
   runnerBusErrorAction,
   runnerMessageMatches,
-  runnerMessageShouldDirtyObligations,
+  runnerMessageShouldDirtyObligations, restartOptionsFromCommand,
   runnerShouldResolveProviderExit,
   runnerShouldRestartUnexpectedProviderExit,
   runtimeProviderCapabilities,
@@ -60,7 +60,7 @@ import {
   shouldLogDeliveryFailure,
   stripRunnerClaimedGuidance,
   taskIdFromMessage,
-  type ProbeModelInfo,
+  type ProbeModelInfo, type RestartProviderOptions,
 } from "./runner-helpers";
 
 // Pre-destroy work is best-effort and must never hang teardown. Capping it keeps a slow
@@ -69,6 +69,7 @@ import {
 // short so a wedged/down server can't stall an operator-requested shutdown for long; a
 // row that still can't land is logged, not silently dropped.
 const OUTBOX_FLUSH_TIMEOUT_MS = 3_000;
+const STALE_PROVIDER_TURN_BUSY_MS = 10 * 60_000;
 
 interface RunnerOptions {
   provider: string;
@@ -535,7 +536,7 @@ export class AgentRunner {
     return mode === "isolated";
   }
 
-  private async spawnProvider(opts: { resumeId?: string; suppressPrompt?: boolean } = {}): Promise<ManagedProcess> {
+  private async spawnProvider(opts: RestartProviderOptions = {}): Promise<ManagedProcess> {
     this.providerSessionId = crypto.randomUUID();
     this.lastTranscriptPath = undefined;
     const includeProviderGlobals = profileUsesProviderHostGlobals(this.options);
@@ -586,7 +587,7 @@ export class AgentRunner {
       ...(this.options.profile ? { profile: this.options.profile } : {}),
       ...(this.options.agentProfile ? { agentProfile: this.options.agentProfile } : {}),
       ...(this.options.prompt && !opts.resumeId && !opts.suppressPrompt ? { prompt: this.options.prompt } : {}),
-      ...(this.options.systemPromptAppend ? { systemPromptAppend: this.options.systemPromptAppend } : {}),
+      ...((opts.systemPromptAppend ?? this.options.systemPromptAppend) ? { systemPromptAppend: opts.systemPromptAppend ?? this.options.systemPromptAppend } : {}),
       ...(this.options.tmuxSession ? { tmuxSession: this.options.tmuxSession } : {}),
       providerArgs: opts.resumeId ? [...this.options.providerArgs, "--resume", opts.resumeId] : this.options.providerArgs,
       providerConfig: this.options.providerConfig,
@@ -604,7 +605,7 @@ export class AgentRunner {
     };
     const launchSeededPrompt = this.options.adapter.seedsInitialPromptAtLaunch && !opts.resumeId && !opts.suppressPrompt ? this.options.prompt?.trim() : ""; if (launchSeededPrompt) this.recordInjectedPrompt(launchSeededPrompt);
     const managedProcess = await this.options.adapter.spawn(config);
-    const injectionEvents = runnerLaunchInjectionSessionEvents({ carried: this.options.relayInjectionEvents, provider: this.options.provider, config, providerConfig: this.options.providerConfig, agentId: this.agentId, providerSessionId: this.providerSessionId });
+    const injectionEvents = runnerLaunchInjectionSessionEvents({ carried: opts.relayInjectionEvents ?? this.options.relayInjectionEvents, provider: this.options.provider, config, providerConfig: this.options.providerConfig, agentId: this.agentId, providerSessionId: this.providerSessionId });
     for (const event of injectionEvents) {
       this.publishSessionEvent(event);
     }
@@ -777,7 +778,7 @@ export class AgentRunner {
       else this.lifecycleAction = undefined;
       this.publishStatus();
       let providerResult: Record<string, unknown> | void = undefined;
-      if (type === "agent.restart") await this.restartProvider();
+      if (type === "agent.restart") await this.restartProvider(restartOptionsFromCommand(params));
       else if (type === "agent.reconnect") this.publishStatus();
       else if (type === "agent.compact") {
         if (!this.options.adapter.compact || !this.process) throw new Error("provider does not support compact");
@@ -927,7 +928,7 @@ export class AgentRunner {
     return attachmentText ? `${body}\n\n${attachmentText}` : body;
   }
 
-  private async restartProvider(opts: { resumeId?: string; suppressPrompt?: boolean } = {}): Promise<void> {
+  private async restartProvider(opts: RestartProviderOptions = {}): Promise<void> {
     this.restartInProgress = true;
     try {
       if (this.process) {
@@ -1204,7 +1205,7 @@ export class AgentRunner {
     const providerSessionId = typeof update === "string" ? undefined : update.providerSessionId;
     if (providerSessionId && providerSessionId !== this.providerSessionId) return;
     const reason = typeof update === "string" ? "provider-turn" : update.reason ?? "provider-turn";
-    const id = typeof update === "string" ? reason : update.id ?? reason;
+    let id = typeof update === "string" ? reason : update.id ?? reason;
     if (typeof update !== "string" && update.timeline) {
       this.pendingTimelineEvent = {
         status: update.timeline.status,
@@ -1300,8 +1301,10 @@ export class AgentRunner {
         this.compactionMidTurn = false;
         this.sessionLog(`turn started (turn ${this.currentTurnId})`);
       }
+      id = this.currentTurnId;
       this.busyReconciler.arm();
     } else if (status === "idle" && reason === "provider-turn") {
+      id = typeof update !== "string" && update.id ? update.id : this.currentTurnId ?? reason;
       if (this.currentTurnId) { this.completedProviderTurns += 1; this.sessionLog(`turn ended via provider idle (turn ${this.currentTurnId})`); }
       this.currentTurnId = undefined;
       this.currentTurnStartedAt = undefined;
@@ -1346,7 +1349,8 @@ export class AgentRunner {
       }
     } else if (status === "idle") {
       this.claims.clearTerminalStatus();
-      this.claims.finishWork(reason, id);
+      if (reason === "provider-turn") this.claims.clearWorkKind("provider-turn");
+      else this.claims.finishWork(reason, id);
       if (reason === "provider-turn") void this.completeObservedTaskClaims();
     }
     else if (status === "offline" || status === "error") this.claims.setTerminalStatus(status);
@@ -2007,15 +2011,25 @@ export class AgentRunner {
     });
   }
 
+  private isStaleProviderTurnOnlyBusy(
+    status: SemanticStatus,
+    activeWork: Array<{ kind: string }>,
+    busyReasons: string[],
+    liveness: { hasLiveWork: boolean; lastProgressAt: number },
+  ): boolean {
+    if (status !== "busy") return false;
+    if (activeWork.length === 0 || activeWork.some((work) => work.kind !== "provider-turn")) return false;
+    if (busyReasons.some((reason) => reason !== "provider-turn")) return false;
+    if (liveness.hasLiveWork || !liveness.lastProgressAt) return false;
+    return Date.now() - liveness.lastProgressAt >= STALE_PROVIDER_TURN_BUSY_MS;
+  }
+
   private publishStatus(): void {
     this.claims.expire();
     const status = this.claims.currentStatus();
-    const agentStatus = runnerAgentStatus(status);
     const activeWork = this.claims.activeWork();
     const activeSubagents = activeWork.filter((item) => item.kind === "subagent");
     const terminalFailure = this.terminalFailure;
-    const providerState = terminalFailure?.providerState ?? this.rateLimitHold ?? providerStateFromActiveWork(activeWork);
-    this.bus.setSemanticStatus(status === "offline" || status === "error" ? "idle" : status);
     const timelineEvent = this.pendingTimelineEvent;
     this.pendingTimelineEvent = undefined;
     // §4.1 Runner↔provider liveness contract (#725 / #746): fold the raw transport/timeline/
@@ -2031,6 +2045,12 @@ export class AgentRunner {
     const liveness = this.options.adapter.liveness
       ? this.options.adapter.liveness(livenessInputs)
       : computeLivenessSignal(livenessInputs);
+    const busyReasons = this.claims.reasons();
+    const staleProviderTurnBusy = this.isStaleProviderTurnOnlyBusy(status, activeWork, busyReasons, liveness);
+    const effectiveStatus = staleProviderTurnBusy ? "idle" : status;
+    const agentStatus = runnerAgentStatus(effectiveStatus);
+    const providerState = terminalFailure?.providerState ?? this.rateLimitHold ?? (staleProviderTurnBusy ? null : providerStateFromActiveWork(activeWork));
+    this.bus.setSemanticStatus(effectiveStatus === "offline" || effectiveStatus === "error" ? "idle" : effectiveStatus);
     this.bus.status({
       agentStatus,
       ready: agentStatus !== "offline" && !this.stopped,
@@ -2062,7 +2082,7 @@ export class AgentRunner {
             ? { lastError: `Claude provider exited; resume id ${this.terminalProviderExit.claudeResumeId} captured for manual recovery` }
             : { lastError: "Claude provider exited; manual intervention required" }),
         } : {}),
-        busyReasons: this.claims.reasons(),
+        busyReasons: staleProviderTurnBusy ? busyReasons.filter((reason) => reason !== "provider-turn") : busyReasons,
         completedProviderTurns: this.completedProviderTurns,
         activeWork,
         activeSubagents,

package/src/runner-helpers.ts

@@ -5,6 +5,7 @@ import { getManifest } from "agent-relay-providers";
 import type { BooleanCapabilityDefault, ProviderCapabilityCondition } from "agent-relay-providers";
 import { targetMatchesAgentIdentity } from "agent-relay-sdk/agent-target";
 import type { ProviderAdapter, ProviderConfig, RunnerSpawnConfig, SemanticStatus } from "./adapter";
+import type { RunnerRelayInjectionEvent } from "./relay-injection-events";
 import { agentProfileProjectionReport } from "./profile-projection";
 import { assembleLaunch } from "./launch-assembly";
 
@@ -27,6 +28,13 @@ export interface ProbeModelInfo {
   effort?: string;
 }
 
+export interface RestartProviderOptions {
+  resumeId?: string;
+  suppressPrompt?: boolean;
+  systemPromptAppend?: string;
+  relayInjectionEvents?: RunnerRelayInjectionEvent[];
+}
+
 export function runnerMessageMatches(message: Pick<Message, "to" | "resolvedToAgent">, target: {
   agentId: string;
   label?: string;
@@ -62,6 +70,29 @@ export function stripRunnerClaimedGuidance(body: string): string {
   return body.replace(RUNNER_CLAIMED_GUIDANCE_RE, "");
 }
 
+const RELAY_INJECTION_CATEGORIES = new Set(["memory", "instructions", "tools", "comms", "knowledge", "context"]);
+
+function relayInjectionEventsFromParam(value: unknown): RunnerRelayInjectionEvent[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const events = value.flatMap((item): RunnerRelayInjectionEvent[] => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return [];
+    const record = item as Record<string, unknown>;
+    const detail = record.detail;
+    if (typeof record.category !== "string" || !RELAY_INJECTION_CATEGORIES.has(record.category)) return [];
+    if (typeof record.summary !== "string" || !record.summary.trim()) return [];
+    if (!detail || typeof detail !== "object" || Array.isArray(detail)) return [];
+    return [{ category: record.category as RunnerRelayInjectionEvent["category"], summary: record.summary, detail: detail as Record<string, unknown> }];
+  });
+  return events.length ? events : undefined;
+}
+
+export function restartOptionsFromCommand(params: Record<string, unknown>): RestartProviderOptions {
+  return {
+    systemPromptAppend: typeof params.systemPromptAppend === "string" ? params.systemPromptAppend : undefined,
+    relayInjectionEvents: relayInjectionEventsFromParam(params.relayInjectionEvents),
+  };
+}
+
 // Bound a runner's INITIAL relay registration. `connect` resolves on the first `registered`
 // frame and otherwise loops forever, so a token the relay rejects (401 at the WS upgrade)
 // hangs here silently. Race it against `timeoutMs`; on timeout, surface a fatal reason, tear