agent-relay-runner 0.10.25 → 0.10.27

package/package.json

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

package/src/adapter.ts

@@ -31,6 +31,7 @@ export interface ProviderConfig {
   defaultCapabilities: string[];
   defaultApprovalMode: string;
   defaultTags: string[];
+  chatCaptureMode: "final" | "full";
   headless: {
     tmuxPrefix: string;
     shutdownTimeoutMs: number;

package/src/adapters/claude-transcript.ts

@@ -97,6 +97,37 @@ export function extractLastAssistantTurn(jsonl: string): string {
   return collected.join("\n\n").trim();
 }
 
+/**
+ * Returns only the text from the LAST assistant entry in the current turn.
+ * Unlike extractLastAssistantTurn which collects all intermediate text between
+ * tool calls, this returns just the final response — what the user sees as the
+ * concluding message.
+ */
+export function extractFinalAssistantMessage(jsonl: string): string {
+  const lines = jsonl.split("\n");
+  let lastText = "";
+  let pastLastUserPrompt = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let entry: TranscriptEntry;
+    try {
+      entry = JSON.parse(trimmed) as TranscriptEntry;
+    } catch {
+      continue;
+    }
+    if (isRealUserPrompt(entry)) {
+      pastLastUserPrompt = true;
+      lastText = "";
+      continue;
+    }
+    if (!pastLastUserPrompt) continue;
+    const text = assistantText(entry);
+    if (text) lastText = text;
+  }
+  return lastText.trim();
+}
+
 /**
  * Extract text from the `last_assistant_message` field in the Stop hook
  * payload. This is the content of the final assistant message — either a plain

package/src/adapters/claude.ts

@@ -10,6 +10,7 @@ export class ClaudeAdapter implements ProviderAdapter {
   readonly provider = "claude";
   private statusCb: (status: ProviderStatusUpdate) => void = () => {};
   private tmuxWatcher?: Timer;
+  private turnWatcher?: Timer;
 
   onStatusChange(cb: (status: ProviderStatusUpdate) => void): void {
     this.statusCb = cb;
@@ -88,6 +89,59 @@ export class ClaudeAdapter implements ProviderAdapter {
     // interaction scaffolding (reply reminder, claim-task instruction) — the agent has
     // no way to /reply or /claim, so it's just confusing noise in a clean-room run.
     await submitTextToTmux(session, claudeProviderMessageText(messages, { deliveryCount: 1, relaySurface: !monitorless }), socket);
+    // Monitorless = no Stop/UserPromptSubmit hooks, so the runner gets no turn
+    // lifecycle and never marks the claimed task done (the way Codex's app-server
+    // status does) — the task lingers until the runtime budget cancels it. Scrape
+    // the tmux pane for the busy→idle transition to synthesize a provider-turn
+    // signal so isolated automation agents reach task "done" like Codex.
+    if (monitorless) this.beginMonitorlessTurnWatch(session, socket);
+  }
+
+  private beginMonitorlessTurnWatch(sessionName: string, socketName?: string): void {
+    this.stopTurnWatch();
+    // We just submitted a prompt, so a turn is starting. Emit a synthetic
+    // provider-turn busy now so the runner arms task-claim completion; the claim
+    // for this delivery is already registered before deliver() runs.
+    this.statusCb({ status: "busy", reason: "provider-turn", id: CLAUDE_TURN_WATCH_ID });
+    let ticks = 0;
+    let idleStreak = 0;
+    let sawBusy = false;
+    this.turnWatcher = setInterval(() => {
+      ticks += 1;
+      if (!tmuxHasSession(sessionName, socketName) || ticks > CLAUDE_TURN_MAX_TICKS) {
+        // Session ended (the tmux watcher emits offline) or we hit the safety cap;
+        // stop without emitting idle and let budget/server reconcile resolve it.
+        this.stopTurnWatch();
+        return;
+      }
+      let pane: string;
+      try {
+        pane = captureTmuxPane(sessionName, socketName);
+      } catch {
+        return; // transient capture failure — retry next tick
+      }
+      if (claudePaneIsBusy(pane)) {
+        sawBusy = true;
+        idleStreak = 0;
+        return;
+      }
+      idleStreak = claudePaneLooksReady(pane) ? idleStreak + 1 : 0;
+      const confirmedIdle = idleStreak >= CLAUDE_TURN_IDLE_CONFIRM_TICKS;
+      // Require either an observed busy spinner or a grace window, so we never
+      // declare idle in the brief gap before Claude starts rendering the turn.
+      const turnObserved = sawBusy || ticks >= CLAUDE_TURN_QUICK_GRACE_TICKS;
+      if (confirmedIdle && turnObserved) {
+        this.stopTurnWatch();
+        this.statusCb({ status: "idle", reason: "provider-turn", id: CLAUDE_TURN_WATCH_ID });
+      }
+    }, CLAUDE_TURN_POLL_MS);
+  }
+
+  private stopTurnWatch(): void {
+    if (this.turnWatcher) {
+      clearInterval(this.turnWatcher);
+      this.turnWatcher = undefined;
+    }
   }
 
   async deliverInitialPrompt(process: ManagedProcess, prompt: string): Promise<void> {
@@ -228,6 +282,7 @@ export class ClaudeAdapter implements ProviderAdapter {
   }
 
   private async shutdownTmux(sessionName: string, opts: { graceful: boolean; timeoutMs: number }, socketName?: string): Promise<void> {
+    this.stopTurnWatch();
     if (this.tmuxWatcher) {
       clearInterval(this.tmuxWatcher);
       this.tmuxWatcher = undefined;
@@ -253,6 +308,12 @@ export const CLAUDE_EXIT_COMMAND = "/exit";
 export const CLAUDE_TMUX_SUBMIT_DELAY_MS = 250;
 export const CLAUDE_TMUX_SUBMIT_KEY = "C-m";
 export const CLAUDE_TMUX_READY_TIMEOUT_MS = 10_000;
+// Monitorless turn detection (Fix: isolated agents reach task "done" like Codex).
+const CLAUDE_TURN_WATCH_ID = "tmux-turn";
+const CLAUDE_TURN_POLL_MS = 1500;
+const CLAUDE_TURN_IDLE_CONFIRM_TICKS = 3;  // ~4.5s of stable idle before declaring done
+const CLAUDE_TURN_QUICK_GRACE_TICKS = 8;   // ~12s fallback when the spinner was never caught
+const CLAUDE_TURN_MAX_TICKS = 3600;        // ~90min safety cap so the timer never leaks
 
 export function claudeShutdownGraceMs(timeoutMs: number): number {
   if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return 10_000;
@@ -360,6 +421,14 @@ export function claudePaneLooksReady(text: string): boolean {
     || text.includes("Claude Code");
 }
 
+export function claudePaneIsBusy(text: string): boolean {
+  // Claude renders "(esc to interrupt)" in its working spinner footer while a turn
+  // is in flight and removes it once the turn completes and the input box is idle.
+  // The persistent "…without interrupting Claude" queue hint does NOT contain this
+  // exact phrase, so it won't false-positive.
+  return text.includes("esc to interrupt");
+}
+
 async function waitForClaudeInputReady(sessionName: string, timeoutMs = CLAUDE_TMUX_READY_TIMEOUT_MS, socketName?: string): Promise<void> {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {

package/src/config.ts

@@ -33,6 +33,7 @@ export function defaultProviderConfig(provider: string): ProviderConfig {
     defaultCapabilities: ["chat", "code", "review"],
     defaultApprovalMode: "guarded",
     defaultTags: [],
+    chatCaptureMode: "final",
     headless: {
       tmuxPrefix: `${provider}-relay`,
       shutdownTimeoutMs: 10_000,
@@ -63,6 +64,7 @@ export function loadProviderConfig(provider: string, home = agentRelayHome()): L
     defaultCapabilities: stringArray(raw.defaultCapabilities) ?? defaults.defaultCapabilities,
     defaultApprovalMode: stringValue(raw.defaultApprovalMode) ?? defaults.defaultApprovalMode,
     defaultTags: stringArray(raw.defaultTags) ?? defaults.defaultTags,
+    chatCaptureMode: enumValue(raw.chatCaptureMode, ["final", "full"]) ?? defaults.chatCaptureMode,
     headless: {
       tmuxPrefix: stringValue(recordValue(raw.headless).tmuxPrefix) ?? defaults.headless.tmuxPrefix,
       shutdownTimeoutMs: positiveInteger(recordValue(raw.headless).shutdownTimeoutMs) ?? defaults.headless.shutdownTimeoutMs,
@@ -88,6 +90,7 @@ export function providerConfigPublic(config: LoadedProviderConfig): Record<strin
     defaultCapabilities: config.defaultCapabilities,
     defaultApprovalMode: config.defaultApprovalMode,
     defaultTags: config.defaultTags,
+    chatCaptureMode: config.chatCaptureMode,
     headless: config.headless,
   };
 }
@@ -120,6 +123,10 @@ function positiveInteger(value: unknown): number | undefined {
   return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
 }
 
+function enumValue<T extends string>(value: unknown, allowed: T[]): T | undefined {
+  return typeof value === "string" && allowed.includes(value as T) ? (value as T) : undefined;
+}
+
 function stringArray(value: unknown): string[] | undefined {
   return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : undefined;
 }

package/src/runner.ts

@@ -9,7 +9,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 { extractLastAssistantTurn, extractHookAssistantMessage, transcriptLooksComplete } from "./adapters/claude-transcript";
+import { extractLastAssistantTurn, extractFinalAssistantMessage, extractHookAssistantMessage, transcriptLooksComplete } from "./adapters/claude-transcript";
 import { agentProfileProjectionReport } from "./profile-projection";
 import { profileUsesHostProviderGlobals } from "./profile-home";
 import { runtimeMetadata } from "./version";
@@ -702,7 +702,8 @@ export class AgentRunner {
         try { jsonl = await readFile(input.transcriptPath, "utf8"); } catch { return; }
       }
       if (!transcriptLooksComplete(jsonl)) continue;
-      body = extractLastAssistantTurn(jsonl);
+      const extract = this.options.providerConfig.chatCaptureMode === "full" ? extractLastAssistantTurn : extractFinalAssistantMessage;
+      body = extract(jsonl);
       if (body) break;
     }
     // Fallback: use last_assistant_message from the Stop hook payload directly.