agent-relay-runner 0.12.2 → 0.12.4

package/package.json

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

package/src/adapters/claude.ts

@@ -355,6 +355,13 @@ export function sessionStatusLineSettingsArgs(...argLists: string[][]): string[]
       command: "agent-relay context-probe --wrap",
       refreshInterval: 30,
     },
+    // Force readable thinking text for managed sessions so the session-mirror can
+    // surface reasoning in the dashboard. With showThinkingSummaries:false the API
+    // redacts thinking to a signature-only stub (empty text), leaving the transcript
+    // tail nothing to mirror. --settings merges per-key, so this overrides only this
+    // key for managed sessions — a host rig default of false still governs the
+    // operator's own interactive TUI sessions.
+    showThinkingSummaries: true,
   })];
 }
 
@@ -448,12 +455,19 @@ export function claudePaneLooksReady(text: string): boolean {
     || text.includes("Claude Code");
 }
 
+// The working-spinner footer carries a live elapsed-time counter while a turn is in
+// flight, e.g. "✶ Perambulating… (2m 17s · ↓ 8.7k tokens)" — gerund, "… (", then
+// "[Nh ][Nm ]Ns". Anchored on the gerund ellipsis so it can't match the "… +N lines
+// (ctrl+o to expand)" truncation marker, the idle input box, or the persistent
+// "/btw … without interrupting Claude's current work" queue hint.
+const CLAUDE_BUSY_SPINNER_RE = /…\s*\((?:\d+h\s+)?(?:\d+m\s+)?\d+s\b/;
+
 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");
+  // Claude Code <2.1.x rendered "(esc to interrupt)" in the spinner footer; 2.1.x
+  // dropped that hint but kept the "(<elapsed>" counter, which is the stable busy
+  // signal across versions. Match either so the busy probe (and the reconciler
+  // backstop that depends on it) keep working as the footer wording changes.
+  return CLAUDE_BUSY_SPINNER_RE.test(text) || text.includes("esc to interrupt");
 }
 
 async function waitForClaudeInputReady(sessionName: string, timeoutMs = CLAUDE_TMUX_READY_TIMEOUT_MS, socketName?: string): Promise<void> {

package/src/adapters/codex.ts

@@ -453,6 +453,18 @@ export function codexToolSummary(type: string | undefined, item: Record<string,
   if (type === "webSearch") {
     return { label: "Search", body: clip(oneLine(item.query) || "web search") };
   }
+  if (type === "plan") {
+    return { label: "Plan", body: clip(oneLine(item.text) || "updated plan") };
+  }
+  if (type === "collabAgentToolCall") {
+    const tool = stringValue(item.tool) ?? "collab";
+    const prompt = oneLine(item.prompt);
+    const targets = Array.isArray(item.receiverThreadIds)
+      ? item.receiverThreadIds.filter((t): t is string => typeof t === "string").length
+      : 0;
+    const detail = prompt || (targets ? `${targets} agent${targets === 1 ? "" : "s"}` : tool);
+    return { label: `Collab/${tool}`, body: clip(detail) };
+  }
   return null;
 }
 

package/src/runner.ts

@@ -63,6 +63,9 @@ const CLAIM_RENEW_INTERVAL_MS = 5 * 60 * 1000;
 const HTTP_LIVENESS_INTERVAL_MS = 20_000;
 const HTTP_LIVENESS_LOG_INTERVAL_MS = 5 * 60 * 1000;
 const TOKEN_RENEW_RETRY_MS = 60_000;
+// Debounce reactive token recovery so a burst of 401-ing calls in the same window
+// triggers a single re-mint attempt, not one per failing request.
+const REACTIVE_TOKEN_RECOVERY_DEBOUNCE_MS = 10_000;
 const UNEXPECTED_EXIT_WINDOW_MS = 2 * 60 * 1000;
 const RAPID_EXIT_MS = 30 * 1000;
 const MAX_RAPID_UNEXPECTED_EXITS = 3;
@@ -128,6 +131,7 @@ export class AgentRunner {
   private tokenRenewTimer?: Timer;
   private tokenRenewInFlight = false;
   private tokenRenewLastLog?: { key: string; at: number };
+  private reactiveTokenRecoveryAt?: number;
   private processStartedAt = 0;
   private providerSessionId = crypto.randomUUID();
   private lifecycleAction?: "shutting-down" | "killing" | "restarting";
@@ -972,6 +976,7 @@ export class AgentRunner {
       });
     } catch (error) {
       this.logRunnerDiagnostic(`session ${input.session.type} capture failed: ${error instanceof Error ? error.message : String(error)}`);
+      if (isHttpAuthError(error)) this.recoverRuntimeTokenAfterAuthFailure("session-capture");
     }
   }
 
@@ -1139,15 +1144,29 @@ export class AgentRunner {
     // and drop the rest of the turn. A seen-set is idempotent under any reshuffle.
     const seen = new Set<string>();
     const turnIdAtStart = this.currentTurnId;
+    // On the first poll the new prompt usually hasn't landed in the transcript yet,
+    // so extractLatestTurnSteps still returns the PRIOR (completed) turn. Seed those
+    // signatures as already-seen so we don't replay last turn's reasoning/tools as
+    // this turn's activity. Once our prompt lands the window resets at the new user
+    // boundary and genuinely-new steps emit normally. Only seed when the transcript
+    // is complete (last entry is an end_turn assistant) — otherwise we're already
+    // inside the new turn and those steps are legitimately ours.
+    let seeded = false;
     const poll = async (): Promise<void> => {
       let jsonl: string;
       try { jsonl = await readFile(transcriptPath, "utf8"); } catch { return; }
       let steps: ReturnType<typeof extractLatestTurnSteps>;
       try { steps = extractLatestTurnSteps(jsonl); } catch { return; }
+      if (!seeded) {
+        seeded = true;
+        if (transcriptLooksComplete(jsonl)) {
+          for (const s of steps) seen.add(JSON.stringify([s.type, s.label ?? "", s.text]));
+        }
+      }
       const turnId = this.currentTurnId ?? turnIdAtStart;
       let emitted = 0;
       for (const step of steps) {
-        const sig = `${step.type}${step.label ?? ""}${step.text}`;
+        const sig = JSON.stringify([step.type, step.label ?? "", step.text]);
         if (seen.has(sig)) continue;
         seen.add(sig);
         emitted += 1;
@@ -1245,6 +1264,25 @@ export class AgentRunner {
     this.httpLivenessAuthFailed = true;
     if (this.httpLivenessTimer) clearInterval(this.httpLivenessTimer);
     this.httpLivenessTimer = undefined;
+    // A 401/403 here is the only timely signal that the token died — stopping the
+    // liveness timer means there is no second chance, so recover from THIS failure.
+    this.recoverRuntimeTokenAfterAuthFailure("http-liveness");
+  }
+
+  // A definitive relay auth failure (401/403) means the runtime token is dead right
+  // now — expired, or (the common case) revoked when the relay marked this agent
+  // stale across its own restart/reconnect. The proactive renew timer is keyed to
+  // TTL and structurally cannot catch a revocation, so the auth failure itself must
+  // drive recovery. renewRuntimeToken() prefers an orchestrator re-mint, which heals
+  // even a revoked token. Debounced so a burst of failing calls re-mints once.
+  private recoverRuntimeTokenAfterAuthFailure(source: string): void {
+    if (this.stopped || this.tokenRenewInFlight) return;
+    if (!this.isRuntimeTokenRenewable() && !this.canRemintViaOrchestrator()) return;
+    const now = Date.now();
+    if (this.reactiveTokenRecoveryAt && now - this.reactiveTokenRecoveryAt < REACTIVE_TOKEN_RECOVERY_DEBOUNCE_MS) return;
+    this.reactiveTokenRecoveryAt = now;
+    this.logRunnerDiagnostic(`[runner] relay auth failure on ${source}; recovering runtime token`);
+    void this.renewRuntimeToken();
   }
 
   private logHttpLivenessFailure(error: unknown, authFailed: boolean): void {
@@ -1418,6 +1456,11 @@ export class AgentRunner {
     this.http.setToken(token);
     this.bus.setToken(token);
     this.httpLivenessAuthFailed = false;
+    this.reactiveTokenRecoveryAt = undefined;
+    // An earlier auth failure may have stopped the liveness loop; restart it so the
+    // agent reports live again on the fresh token. startHttpLiveness clears any
+    // existing timer first, so this is safe on the normal (proactive) renew path too.
+    this.startHttpLiveness();
     this.pendingTimelineEvent = { status, id: record.jti, timestamp: Date.now() };
     this.bus.reconnectTransport(status === "runtime-token-reminted" ? "runtime token re-minted" : "runtime token renewed");
     this.publishStatus();