agent-relay-runner 0.62.2 → 0.63.0

package/src/adapters/claude-transcript.ts

@@ -126,6 +126,50 @@ export function extractLastAssistantTurn(jsonl: string): string {
   return collected.join("\n\n").trim();
 }
 
+/**
+ * Like extractLastAssistantTurn but skips the first `afterEntry` valid JSON entries.
+ * Used when a partial transcript flush already emitted entries 1..afterEntry so the
+ * Stop-hook full-mode capture doesn't re-emit the already-published text.
+ */
+export function extractLastAssistantTurnAfterEntry(jsonl: string, afterEntry: number): string {
+  const lines = jsonl.split("\n");
+  const collected: string[] = [];
+  let entryIndex = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let entry: TranscriptEntry;
+    try {
+      entry = JSON.parse(trimmed) as TranscriptEntry;
+    } catch {
+      continue;
+    }
+    entryIndex++;
+    if (isSidechainEntry(entry)) continue;
+    if (isRealUserPrompt(entry)) {
+      collected.length = 0;
+      continue;
+    }
+    if (entryIndex <= afterEntry) continue;
+    const text = assistantText(entry);
+    if (text) collected.push(text);
+  }
+  return collected.join("\n\n").trim();
+}
+
+/**
+ * Count valid JSON entries in a JSONL string. Used to record the high-water-mark
+ * after a pre-flush so the Stop hook knows where to resume in full-capture mode.
+ */
+export function countTranscriptEntries(jsonl: string): number {
+  let count = 0;
+  for (const line of jsonl.split("\n")) {
+    if (!line.trim()) continue;
+    try { JSON.parse(line); count++; } catch {}
+  }
+  return count;
+}
+
 /**
  * Returns only the text from the LAST assistant entry in the current turn.
  * Unlike extractLastAssistantTurn which collects all intermediate text between

package/src/adapters/claude.ts

@@ -450,25 +450,21 @@ export function sessionStatusLineSettingsArgs(...argLists: string[][]): string[]
 }
 
 export function claudeLaunchArgs(defaultArgs: string[], providerArgs: string[], approvalMode?: string): string[] {
+  const stripToolArgs = approvalMode === "read-only";
   return [
-    ...stripClaudePermissionArgs(defaultArgs),
-    ...stripClaudePermissionArgs(providerArgs),
+    ...stripClaudePermissionArgs(defaultArgs, stripToolArgs),
+    ...stripClaudePermissionArgs(providerArgs, stripToolArgs),
     ...claudePermissionModeArgs(approvalMode),
   ];
 }
 
 export function claudePermissionModeArgs(approvalMode?: string): string[] {
   if (approvalMode === "open") return ["--dangerously-skip-permissions"];
-  if (approvalMode === "read-only") return [
-    "--permission-mode",
-    "dontAsk",
-    "--allowedTools",
-    "Read,Grep,Glob,LS,Bash(agent-relay *)",
-  ];
+  if (approvalMode === "read-only") return ["--permission-mode", "dontAsk", "--tools", "Read,Grep,Glob,LS,Bash"];
   return ["--permission-mode", "default"];
 }
 
-function stripClaudePermissionArgs(args: string[]): string[] {
+function stripClaudePermissionArgs(args: string[], stripToolArgs = false): string[] {
   const result: string[] = [];
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -484,6 +480,10 @@ function stripClaudePermissionArgs(args: string[]): string[] {
       i++;
       continue;
     }
+    if (stripToolArgs && /^--(?:tools|allowedTools|allowed-tools|disallowedTools|disallowed-tools)(?:=|$)/.test(arg)) {
+      if (!arg.includes("=")) i++;
+      continue;
+    }
     result.push(arg);
   }
   return result;

package/src/busy-reconciler.ts

@@ -0,0 +1,84 @@
+type ProviderActivity = "busy" | "idle" | "unknown";
+
+const BUSY_RECONCILE_POLL_MS = 4_000;
+const BUSY_RECONCILE_IDLE_CONFIRM = 8;
+const BUSY_RECONCILE_IDLE_CONFIRM_NO_BUSY = 15;
+const INTERRUPT_RECONCILE_DELAY_MS = 1_500;
+
+interface BusyReconcilerDeps {
+  isStopped(): boolean;
+  hasProcess(): boolean;
+  currentStatus(): "idle" | "busy" | "offline" | "error";
+  isProviderBlocked(): boolean;
+  hasProviderTurn(): boolean;
+  canProbeActivity(): boolean;
+  probeActivity(): Promise<ProviderActivity> | undefined;
+  clearProviderTurn(reason: string): void;
+  sessionDebug(message: string): void;
+}
+
+export class BusyReconciler {
+  private idleStreak = 0;
+  private timer?: ReturnType<typeof setInterval>;
+  private sawBusy = false;
+
+  constructor(private readonly deps: BusyReconcilerDeps) {}
+
+  arm(): void {
+    if (this.timer || !this.deps.canProbeActivity()) return;
+    this.idleStreak = 0;
+    this.sawBusy = false;
+    this.timer = setInterval(() => { void this.run(); }, BUSY_RECONCILE_POLL_MS);
+  }
+
+  disarm(): void {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = undefined;
+    this.idleStreak = 0;
+    this.sawBusy = false;
+  }
+
+  scheduleInterruptReconcile(): void {
+    setTimeout(() => {
+      if (this.deps.isStopped() || !this.deps.hasProcess()) return;
+      void (async () => {
+        if (this.deps.currentStatus() !== "busy" || this.deps.isProviderBlocked()) return;
+        const probe = this.deps.probeActivity();
+        let activity: ProviderActivity = "unknown";
+        try { if (probe) activity = await probe; } catch { return; }
+        this.deps.sessionDebug(`post-interrupt reconcile probe=${activity}`);
+        if (activity === "idle") this.deps.clearProviderTurn("post-interrupt");
+      })();
+    }, INTERRUPT_RECONCILE_DELAY_MS);
+  }
+
+  private async run(): Promise<void> {
+    const probe = this.deps.probeActivity();
+    if (this.deps.isStopped() || !this.deps.hasProcess() || !probe) {
+      this.disarm();
+      return;
+    }
+    if (this.deps.currentStatus() !== "busy" || this.deps.isProviderBlocked()) {
+      this.idleStreak = 0;
+      return;
+    }
+    if (!this.deps.hasProviderTurn()) {
+      this.disarm();
+      return;
+    }
+    let activity: ProviderActivity;
+    try { activity = await probe; } catch { return; }
+    if (activity === "busy") this.sawBusy = true;
+    if (activity !== "idle") {
+      this.idleStreak = 0;
+      this.deps.sessionDebug(`reconcile probe=${activity} sawBusy=${this.sawBusy} streak=${this.idleStreak}`);
+      return;
+    }
+    this.idleStreak += 1;
+    const confirm = this.sawBusy ? BUSY_RECONCILE_IDLE_CONFIRM : BUSY_RECONCILE_IDLE_CONFIRM_NO_BUSY;
+    this.deps.sessionDebug(`reconcile probe=idle sawBusy=${this.sawBusy} streak=${this.idleStreak}/${confirm}`);
+    if (this.idleStreak < confirm) return;
+    this.disarm();
+    this.deps.clearProviderTurn(this.sawBusy ? "backstop reconciler" : "backstop reconciler (no-busy-observed)");
+  }
+}

package/src/control-server.ts

@@ -36,7 +36,9 @@ interface ControlServerOptions {
   // Phase 1 live-session lane: a provider Stop hook hands over its transcript
   // path so the runner can capture the assistant turn and surface it in the
   // dashboard chat without the agent re-emitting it via /reply.
-  onSessionTurn?(input: { transcriptPath: string; lastAssistantMessage?: unknown }): Promise<void>;
+  // isPreFlush: true signals a mid-turn call from a PreToolUse hook — flush any
+  // un-mirrored narrative before the interactive form appears in chat (#435).
+  onSessionTurn?(input: { transcriptPath: string; lastAssistantMessage?: unknown; isPreFlush?: boolean }): Promise<void>;
   // A provider UserPromptSubmit hook hands over the prompt the human typed
   // directly into the session (web terminal / TUI) so the runner can mirror it
   // into the dashboard chat and start tailing the turn transcript for reasoning.
@@ -221,6 +223,14 @@ async function handlePermissionRequest(
 ): Promise<Response> {
   const body = await req.json().catch(() => null);
   if (!isRecord(body)) return Response.json({});
+  // #435: flush any un-mirrored narrative from the transcript before the form
+  // appears in chat — the transcript already has the assistant text block at
+  // PreToolUse time, but the Stop hook (which normally captures it) won't fire
+  // until after the user answers, so the form would otherwise arrive first.
+  const transcriptPath = typeof body.transcript_path === "string" ? body.transcript_path : "";
+  if (transcriptPath && options.onSessionTurn) {
+    await options.onSessionTurn({ transcriptPath, isPreFlush: true }).catch(() => {});
+  }
   const approvalId = crypto.randomUUID();
   const view = claudePermissionApprovalView(approvalId, body);
   options.onStatus({

package/src/mcp-outbox.ts

@@ -0,0 +1,86 @@
+import type { SendMessageInput } from "agent-relay-sdk";
+import type { RelayHttpClient } from "agent-relay-sdk";
+import { relayMcpEndpoint } from "./relay-mcp";
+import type { OutboxRecord } from "./outbox";
+import { deliverContinuationArchiveRecord } from "./continuation-archive";
+import { logger } from "./logger";
+import { isHttpAuthError, isHttpStatusError } from "./runner-helpers";
+
+interface RunnerOutboxDelivery {
+  record: OutboxRecord;
+  http: RelayHttpClient;
+  relayUrl: string;
+  token?: string;
+  updatePayload(seq: number, payload: unknown): void;
+  sessionLog(message: string): void;
+  recoverRuntimeTokenAfterAuthFailure(source: string): void;
+}
+
+export async function deliverRunnerOutboxEvent(input: RunnerOutboxDelivery): Promise<void> {
+  const { record, http } = input;
+  try {
+    if (record.kind === "session-message") {
+      await http.sendMessage({
+        ...(record.payload as SendMessageInput),
+        occurredAt: record.occurredAt,
+        idempotencyKey: record.idempotencyKey,
+      });
+      return;
+    }
+    if (record.kind === "insight") {
+      await http.recordInsightObservation({
+        ...(record.payload as Parameters<RelayHttpClient["recordInsightObservation"]>[0]),
+        occurredAt: record.occurredAt,
+      });
+      return;
+    }
+    if (record.kind === "continuation-archive") {
+      await deliverContinuationArchiveRecord({
+        record,
+        http,
+        updatePayload: input.updatePayload,
+        sessionLog: input.sessionLog,
+      });
+      return;
+    }
+    if (record.kind === "mcp-tool-call") {
+      await deliverBufferedMcpCall(input);
+      return;
+    }
+    logger.warn("outbox", `dropping event with unknown kind: ${record.kind}`);
+  } catch (error) {
+    if (isHttpStatusError(error, 409)) return;
+    if (isHttpAuthError(error)) input.recoverRuntimeTokenAfterAuthFailure("outbox");
+    throw error;
+  }
+}
+
+export async function deliverBufferedMcpCall(input: {
+  record: OutboxRecord;
+  relayUrl: string;
+  token?: string;
+  recoverRuntimeTokenAfterAuthFailure(source: string): void;
+}): Promise<void> {
+  const payload = input.record.payload as { tool: string; arguments: Record<string, unknown> };
+  const headers: Record<string, string> = { "content-type": "application/json" };
+  if (input.token) headers.authorization = `Bearer ${input.token}`;
+  const response = await fetch(relayMcpEndpoint(input.relayUrl), {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: payload.tool, arguments: payload.arguments } }),
+  });
+  if (response.status === 401 || response.status === 403) {
+    input.recoverRuntimeTokenAfterAuthFailure("mcp-outbox");
+    throw new Error(`relay rejected buffered ${payload.tool} with ${response.status}`);
+  }
+  if (response.status >= 500) throw new Error(`relay ${response.status} on buffered ${payload.tool}`);
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    logger.warn("mcp-outbox", `buffered ${payload.tool} permanently rejected (${response.status}); dropping: ${body.slice(0, 200)}`);
+    return;
+  }
+  const json = await response.json().catch(() => null) as { error?: { message?: string } } | null;
+  if (json?.error) {
+    logger.warn("mcp-outbox", `buffered ${payload.tool} returned a tool error; dropping: ${json.error.message ?? "(no detail)"}`);
+  }
+}

package/src/rate-limit.ts

@@ -14,7 +14,7 @@ export const RATE_LIMIT_BLOCK_REASON = "rate_limit";
 // fall back to the resume sweep's poll window.
 const MAX_RESET_AHEAD_MS = 7 * 24 * 60 * 60 * 1000;
 
-export interface RateLimitHoldInput {
+interface RateLimitHoldInput {
   errorType?: string;
   /** Unix ms the limit window resets, when known. */
   resetAt?: number;
@@ -58,7 +58,7 @@ const LIMIT_PHRASE_RE = /(?:hit (?:your|the)\s*(?:[\w-]+\s+)*limit|usage limit|\
 const RESET_AT_RE = /\bresets?\b(?:\s+at)?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*(?:\(([^)]+)\))?/i;
 const TRY_AGAIN_RE = /\btry again in\s+(\d+)\s*(second|minute|hour|day)s?/i;
 
-export interface PaneRateLimit {
+interface PaneRateLimit {
   /** The matched limit line, for the chat notice / observability. */
   message: string;
   /** Unix ms reset, when parseable from the pane (else undefined → resume falls back to poll). */