agent-relay-runner 0.12.0 → 0.12.2

package/package.json

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

package/src/runner.ts

@@ -71,10 +71,17 @@ const LOG_TAIL_BYTES = 128 * 1024;
 // A UserPromptSubmit echo matching a runner-injected prompt within this window is
 // the same prompt arriving back from the provider — drop it to avoid a duplicate.
 const PROMPT_ECHO_DEDUP_MS = 30_000;
-// Busy reconciler: how often to probe real provider activity, and how many
-// consecutive idle probes confirm a stuck-busy state should be cleared.
+// Busy reconciler: a conservative LAST-RESORT backstop for a turn that ended
+// without the provider's Stop hook clearing busy (e.g. ESC straight into the web
+// terminal). It must never fire during a live turn, so it (a) only counts idle
+// after it has actually observed the provider busy, and (b) requires a long,
+// unbroken idle streak — an active turn shows its working spinner well within
+// this window, which resets the streak. ~32s of uninterrupted idle = really done.
 const BUSY_RECONCILE_POLL_MS = 4_000;
-const BUSY_RECONCILE_IDLE_CONFIRM = 3;
+const BUSY_RECONCILE_IDLE_CONFIRM = 8;
+// After a dashboard interrupt, give the provider a moment to drop out of its turn,
+// then reconcile immediately so the user sees "stopped" without waiting for the backstop.
+const INTERRUPT_RECONCILE_DELAY_MS = 1_500;
 // Relay-injected content (delivered messages, memory context) is wrapped with
 // these markers; a UserPromptSubmit echo starting with one is a runner injection,
 // not a human typing into the terminal, so it must not be mirrored as a prompt.
@@ -139,12 +146,18 @@ export class AgentRunner {
   // Busy reconciler: consecutive idle probes observed while claims still say busy.
   private busyReconcileIdleStreak = 0;
   private busyReconcileTimer?: ReturnType<typeof setInterval>;
+  // The reconciler only trusts an "idle" reading once it has seen the provider
+  // actually busy this turn — so a flaky/always-idle probe can never false-clear.
+  private busyReconcileSawBusy = false;
+  // Verbose session-mirror diagnostics (turn lifecycle, reconciler probes, tail
+  // emits) → a dedicated clean log. Always on for key transitions; AGENT_RELAY_SESSION_DEBUG=1 adds the high-frequency probe/emit lines.
+  private readonly sessionDebugVerbose = process.env.AGENT_RELAY_SESSION_DEBUG === "1";
   // Tracks whether the provider is in a legitimate blocked/approval state, so the
   // busy reconciler doesn't mistake a permission prompt for a stuck-busy turn.
   private providerBlocked = false;
   // Reasoning tailer (item 5): streams the in-flight turn's reasoning/tool steps
   // from the Claude transcript into chat as discreet session events.
-  private reasoningTail?: { timer: ReturnType<typeof setInterval>; emitted: number };
+  private reasoningTail?: { timer: ReturnType<typeof setInterval>; seen: Set<string> };
   private scratch?: SessionScratchLayout;
 
   constructor(private readonly options: RunnerOptions) {
@@ -487,7 +500,9 @@ export class AgentRunner {
         providerResult = await this.options.adapter.clearContext(this.process);
       } else if (type === "agent.interrupt") {
         if (!this.options.adapter.interrupt || !this.process) throw new Error("provider does not support interrupt");
+        this.sessionLog("interrupt requested from dashboard");
         providerResult = await this.options.adapter.interrupt(this.process);
+        this.scheduleInterruptReconcile();
       } else if (type === "agent.injectContext") {
         if (!this.process) throw new Error("provider process is unavailable");
         providerResult = await this.injectContext(params);
@@ -832,9 +847,13 @@ export class AgentRunner {
       this.providerBlocked = false;
     }
     if (status === "busy" && reason === "provider-turn") {
-      if (!this.currentTurnId) this.currentTurnId = typeof update !== "string" && update.id ? update.id : crypto.randomUUID();
+      if (!this.currentTurnId) {
+        this.currentTurnId = typeof update !== "string" && update.id ? update.id : crypto.randomUUID();
+        this.sessionLog(`turn started (turn ${this.currentTurnId})`);
+      }
       this.armBusyReconciler();
     } else if (status === "idle" && reason === "provider-turn") {
+      if (this.currentTurnId) this.sessionLog(`turn ended via provider idle (turn ${this.currentTurnId})`);
       this.currentTurnId = undefined;
       this.disarmBusyReconciler();
       this.stopReasoningTail();
@@ -916,8 +935,12 @@ export class AgentRunner {
     }
     // A pure tool-use turn with no closing text is fine to skip — its reasoning and
     // tool steps already carried the visibility into chat.
-    if (!body) return;
+    if (!body) {
+      this.sessionLog(`response capture: no closing text for turn ${turnId ?? "?"} (skipped)`);
+      return;
+    }
 
+    this.sessionLog(`response captured for turn ${turnId ?? "?"} (${body.length} chars${replyToMessageId ? `, replyTo #${replyToMessageId}` : ", no replyTo"})`);
     await this.publishSessionEvent({
       from: this.agentId,
       to: "user",
@@ -960,12 +983,15 @@ export class AgentRunner {
     if (!this.currentTurnId) this.currentTurnId = crypto.randomUUID();
     const text = input.prompt.trim();
     if (text && !this.isRunnerInjectedPrompt(text)) {
+      this.sessionLog(`prompt echoed from terminal (${text.length} chars)`);
       await this.publishSessionEvent({
         from: "user",
         to: this.agentId,
         body: text,
         session: { type: "prompt", origin: "terminal", turnId: this.currentTurnId },
       });
+    } else if (text) {
+      this.sessionDebug("user-prompt hook: skipped echo (runner-injected)");
     }
     if (input.transcriptPath) this.startReasoningTail(input.transcriptPath);
   }
@@ -1038,6 +1064,7 @@ export class AgentRunner {
   private armBusyReconciler(): void {
     if (this.busyReconcileTimer || !this.options.adapter.probeActivity) return;
     this.busyReconcileIdleStreak = 0;
+    this.busyReconcileSawBusy = false;
     this.busyReconcileTimer = setInterval(() => { void this.runBusyReconcile(); }, BUSY_RECONCILE_POLL_MS);
   }
 
@@ -1045,6 +1072,7 @@ export class AgentRunner {
     if (this.busyReconcileTimer) clearInterval(this.busyReconcileTimer);
     this.busyReconcileTimer = undefined;
     this.busyReconcileIdleStreak = 0;
+    this.busyReconcileSawBusy = false;
   }
 
   private async runBusyReconcile(): Promise<void> {
@@ -1055,13 +1083,47 @@ export class AgentRunner {
     if (!this.claims.activeWork().some((w) => w.kind === "provider-turn")) { this.disarmBusyReconciler(); return; }
     let activity: "busy" | "idle" | "unknown";
     try { activity = await this.options.adapter.probeActivity(this.process); } catch { return; }
-    if (activity !== "idle") { this.busyReconcileIdleStreak = 0; return; }
+    if (activity === "busy") this.busyReconcileSawBusy = true;
+    // Reset the streak on anything that isn't a confident idle — and never start
+    // counting until we've actually observed the provider busy this turn.
+    if (activity !== "idle" || !this.busyReconcileSawBusy) {
+      if (activity !== "idle") this.busyReconcileIdleStreak = 0;
+      this.sessionDebug(`reconcile probe=${activity} sawBusy=${this.busyReconcileSawBusy} streak=${this.busyReconcileIdleStreak}`);
+      return;
+    }
     this.busyReconcileIdleStreak += 1;
+    this.sessionDebug(`reconcile probe=idle streak=${this.busyReconcileIdleStreak}/${BUSY_RECONCILE_IDLE_CONFIRM}`);
     if (this.busyReconcileIdleStreak < BUSY_RECONCILE_IDLE_CONFIRM) return;
-    this.logRunnerDiagnostic(`busy reconciler cleared a stuck provider-turn (idle confirmed ${this.busyReconcileIdleStreak}x)`);
-    const turnId = this.currentTurnId;
     this.disarmBusyReconciler();
-    this.setProviderStatus({ status: "idle", reason: "provider-turn", id: turnId ?? "provider-turn" });
+    this.forceClearProviderTurn("backstop reconciler");
+  }
+
+  // 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
+  // deliberately leaves the reasoning tail alone so a late clear can't truncate
+  // a turn's activity stream.
+  private forceClearProviderTurn(reason: string): void {
+    if (!this.claims.activeWork().some((w) => w.kind === "provider-turn")) return;
+    this.sessionLog(`force-clearing stuck provider-turn (${reason})`);
+    this.claims.clearWorkKind("provider-turn");
+    this.currentTurnId = undefined;
+    this.publishStatus();
+  }
+
+  // After a dashboard interrupt, the provider should drop out of its turn; reconcile
+  // promptly so the busy indicator clears even if the Stop hook doesn't fire.
+  private scheduleInterruptReconcile(): void {
+    setTimeout(() => {
+      if (this.stopped || !this.process) return;
+      void (async () => {
+        if (this.claims.currentStatus() !== "busy" || this.providerBlocked) return;
+        let activity: "busy" | "idle" | "unknown" = "unknown";
+        try { if (this.options.adapter.probeActivity) activity = await this.options.adapter.probeActivity(this.process!); } catch { return; }
+        this.sessionDebug(`post-interrupt reconcile probe=${activity}`);
+        if (activity === "idle") this.forceClearProviderTurn("post-interrupt");
+      })();
+    }, INTERRUPT_RECONCILE_DELAY_MS);
   }
 
   // --- Reasoning tailer (item 5) ------------------------------------------------------
@@ -1071,14 +1133,24 @@ export class AgentRunner {
   private startReasoningTail(transcriptPath: string): void {
     if (this.options.providerConfig.reasoningCapture === false) return;
     this.stopReasoningTail();
-    const state = { emitted: 0, timer: undefined as unknown as ReturnType<typeof setInterval> };
+    // Track emitted steps by content signature, not by index/count: the "latest
+    // turn" window in the transcript can shrink/reset (a tool_result entry, a
+    // mid-turn user line), and an index cursor would then either re-emit or stall
+    // and drop the rest of the turn. A seen-set is idempotent under any reshuffle.
+    const seen = new Set<string>();
+    const turnIdAtStart = this.currentTurnId;
     const poll = async (): Promise<void> => {
       let jsonl: string;
       try { jsonl = await readFile(transcriptPath, "utf8"); } catch { return; }
-      const steps = extractLatestTurnSteps(jsonl);
-      const turnId = this.currentTurnId;
-      for (let i = state.emitted; i < steps.length; i++) {
-        const step = steps[i]!;
+      let steps: ReturnType<typeof extractLatestTurnSteps>;
+      try { steps = extractLatestTurnSteps(jsonl); } catch { return; }
+      const turnId = this.currentTurnId ?? turnIdAtStart;
+      let emitted = 0;
+      for (const step of steps) {
+        const sig = `${step.type}${step.label ?? ""}${step.text}`;
+        if (seen.has(sig)) continue;
+        seen.add(sig);
+        emitted += 1;
         void this.publishSessionEvent({
           from: this.agentId,
           to: "user",
@@ -1086,10 +1158,10 @@ export class AgentRunner {
           session: { type: step.type, origin: "provider", ...(turnId ? { turnId } : {}), ...(step.label ? { label: step.label } : {}) },
         });
       }
-      if (steps.length > state.emitted) state.emitted = steps.length;
+      if (emitted) this.sessionDebug(`reasoning tail emitted ${emitted} step(s) (turn ${turnId ?? "?"}, ${seen.size} total)`);
     };
-    state.timer = setInterval(() => { void poll(); }, REASONING_POLL_MS);
-    this.reasoningTail = state;
+    this.reasoningTail = { seen, timer: setInterval(() => { void poll(); }, REASONING_POLL_MS) };
+    this.sessionLog(`reasoning tail started (turn ${turnIdAtStart ?? "?"})`);
     void poll();
   }
 
@@ -1201,6 +1273,24 @@ export class AgentRunner {
     }
   }
 
+  // Session-mirror diagnostics → a dedicated, ANSI-free, greppable log per agent
+  // (NOT the provider's TUI stdout, which is unreadable). This is the single place
+  // to look when chat/terminal sync misbehaves. Key transitions always log here.
+  private sessionLog(message: string): void {
+    try {
+      const logDir = join(process.env.HOME || ".", ".agent-relay", "logs");
+      mkdirSync(logDir, { recursive: true });
+      appendFileSync(join(logDir, `session-mirror-${safeLogName(this.agentId)}.log`), `[${new Date().toISOString()}] ${message}\n`);
+    } catch {
+      // best-effort
+    }
+  }
+
+  // Verbose, high-frequency lines (per-probe, per-emit) — only when AGENT_RELAY_SESSION_DEBUG=1.
+  private sessionDebug(message: string): void {
+    if (this.sessionDebugVerbose) this.sessionLog(message);
+  }
+
   private ensureScratch(): void {
     try {
       this.scratch = ensureSessionScratch({