agent-relay-runner 0.10.26 → 0.11.0

package/package.json

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

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) {