agent-relay-runner 0.127.7 → 0.127.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.127.7",
+  "version": "0.127.9",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -23,7 +23,7 @@
   },
   "dependencies": {
     "agent-relay-providers": "0.104.4",
-    "agent-relay-sdk": "0.2.121",
+    "agent-relay-sdk": "0.2.122",
     "callmux": "0.23.0"
   },
   "devDependencies": {

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.127.7",
+  "version": "0.127.9",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/plugins/claude/monitors/relay-monitor.provisioned.mjs

@@ -56,8 +56,8 @@ var RUNNER_PROMPT_TEMPLATE_DEFAULTS = [
     category: "runner",
     title: "Runner Workspace Lifecycle Note",
     description: "Lifecycle note injected by the runner for isolated workspaces.",
-    template: lines("[agent-relay] Isolated workspace: you are in a git worktree on branch {{branch}}, based on {{baseRef}} \u2014 NOT the main checkout. Other agents may work in parallel and land to {{baseRef}}, so {{baseRef}} will move under you. That is expected; don't fight it.", "Do NOT push this branch yourself \u2014 not with `git push`, not with `tl push` or any other push wrapper, and do not manually rebase or merge. A steward may be auto-rebasing this branch in the background; pushing concurrently races it and can leave the worktree mid-rebase. Just commit your work here. When the task is done, call `relay_task_deliver` with disposition `complete`, a summary, commits, and passing `typecheck` + `test` gates. Relay records the typed delivery on the Task, then rebases onto the latest {{baseRef}}, lands your work, and pushes for you.", "After `relay_task_deliver` accepts a complete delivery, the workspace status becomes `ready` \u2014 this is the NORMAL, healthy hand-off state, NOT an escalation or a stall. Relay auto-merges clean rebases roughly every 2 minutes; a steward agent is spawned (after a short delay) ONLY if it can't land deterministically, so seeing no steward means it's working, not stuck. Stop your turn after delivery and go idle; do NOT wait or poll the steward queue. Relay wakes you with `landed-success` when your branch lands and refreshes, or `landed-failure` if landing fatally fails. On success you'll be on a fresh rebased branch whose name gains a `--N` suffix \u2014 expected, keep working there. Never `cd` into the main checkout, and never merge/push/resolve conflicts yourself \u2014 Relay and the steward own all of that. `agent-relay workspace status` anytime shows your current state and the exact next step."),
-    defaultTemplate: lines("[agent-relay] Isolated workspace: you are in a git worktree on branch {{branch}}, based on {{baseRef}} \u2014 NOT the main checkout. Other agents may work in parallel and land to {{baseRef}}, so {{baseRef}} will move under you. That is expected; don't fight it.", "Do NOT push this branch yourself \u2014 not with `git push`, not with `tl push` or any other push wrapper, and do not manually rebase or merge. A steward may be auto-rebasing this branch in the background; pushing concurrently races it and can leave the worktree mid-rebase. Just commit your work here. When the task is done, call `relay_task_deliver` with disposition `complete`, a summary, commits, and passing `typecheck` + `test` gates. Relay records the typed delivery on the Task, then rebases onto the latest {{baseRef}}, lands your work, and pushes for you.", "After `relay_task_deliver` accepts a complete delivery, the workspace status becomes `ready` \u2014 this is the NORMAL, healthy hand-off state, NOT an escalation or a stall. Relay auto-merges clean rebases roughly every 2 minutes; a steward agent is spawned (after a short delay) ONLY if it can't land deterministically, so seeing no steward means it's working, not stuck. Stop your turn after delivery and go idle; do NOT wait or poll the steward queue. Relay wakes you with `landed-success` when your branch lands and refreshes, or `landed-failure` if landing fatally fails. On success you'll be on a fresh rebased branch whose name gains a `--N` suffix \u2014 expected, keep working there. Never `cd` into the main checkout, and never merge/push/resolve conflicts yourself \u2014 Relay and the steward own all of that. `agent-relay workspace status` anytime shows your current state and the exact next step."),
+    template: lines("[agent-relay] Isolated workspace: you are in a git worktree on branch {{branch}}, based on {{baseRef}} \u2014 NOT the main checkout. Other agents may work in parallel and land to {{baseRef}}, so {{baseRef}} will move under you. That is expected; don't fight it.", "Do NOT push this branch yourself \u2014 not with `git push`, not with `tl push` or any other push wrapper, and do not manually rebase or merge. A steward may be auto-rebasing this branch in the background; pushing concurrently races it and can leave the worktree mid-rebase. Just commit your work here. When the task is done, call `relay_task_deliver` with disposition `complete`, a summary, commits, and passing `typecheck` + `test` gates when the diff touches code/test/config paths. Relay records the typed delivery on the Task, skips code gates for empty/docs-only diffs, then rebases onto the latest {{baseRef}}, lands your work, and pushes for you.", "After `relay_task_deliver` accepts a complete delivery, the workspace status becomes `ready` \u2014 this is the NORMAL, healthy hand-off state, NOT an escalation or a stall. Relay auto-merges clean rebases roughly every 2 minutes; a steward agent is spawned (after a short delay) ONLY if it can't land deterministically, so seeing no steward means it's working, not stuck. Stop your turn after delivery and go idle; do NOT wait or poll the steward queue. Relay wakes you with `landed-success` when your branch lands and refreshes, or `landed-failure` if landing fatally fails. On success you'll be on a fresh rebased branch whose name gains a `--N` suffix \u2014 expected, keep working there. Never `cd` into the main checkout, and never merge/push/resolve conflicts yourself \u2014 Relay and the steward own all of that. `agent-relay workspace status` anytime shows your current state and the exact next step."),
+    defaultTemplate: lines("[agent-relay] Isolated workspace: you are in a git worktree on branch {{branch}}, based on {{baseRef}} \u2014 NOT the main checkout. Other agents may work in parallel and land to {{baseRef}}, so {{baseRef}} will move under you. That is expected; don't fight it.", "Do NOT push this branch yourself \u2014 not with `git push`, not with `tl push` or any other push wrapper, and do not manually rebase or merge. A steward may be auto-rebasing this branch in the background; pushing concurrently races it and can leave the worktree mid-rebase. Just commit your work here. When the task is done, call `relay_task_deliver` with disposition `complete`, a summary, commits, and passing `typecheck` + `test` gates when the diff touches code/test/config paths. Relay records the typed delivery on the Task, skips code gates for empty/docs-only diffs, then rebases onto the latest {{baseRef}}, lands your work, and pushes for you.", "After `relay_task_deliver` accepts a complete delivery, the workspace status becomes `ready` \u2014 this is the NORMAL, healthy hand-off state, NOT an escalation or a stall. Relay auto-merges clean rebases roughly every 2 minutes; a steward agent is spawned (after a short delay) ONLY if it can't land deterministically, so seeing no steward means it's working, not stuck. Stop your turn after delivery and go idle; do NOT wait or poll the steward queue. Relay wakes you with `landed-success` when your branch lands and refreshes, or `landed-failure` if landing fatally fails. On success you'll be on a fresh rebased branch whose name gains a `--N` suffix \u2014 expected, keep working there. Never `cd` into the main checkout, and never merge/push/resolve conflicts yourself \u2014 Relay and the steward own all of that. `agent-relay workspace status` anytime shows your current state and the exact next step."),
     variables: ["branch", "baseRef"]
   },
   {

package/src/adapter.ts

@@ -92,6 +92,11 @@ export interface ProviderSessionTurnContext {
 
 export interface ProviderSessionTurnResult {
   reasoningSettled?: boolean;
+  // The transcript-embedded event time of the exact tool_use anchor that triggered this
+  // pre-flush harvest (when resolvable) — a more accurate stamp for a resolved permission
+  // prompt's display ordering than the hook's own wall-clock receipt time, which a provider
+  // can flush/timestamp its transcript entry after.
+  toolUseOccurredAt?: number;
 }
 
 export interface ProviderUserPromptInput {

package/src/adapters/claude-permission.ts

@@ -167,9 +167,9 @@ function claudeAnswerInjectionPrompt(view: InteractivePrompt, decision: Provider
   const rows = resolvedQuestionRows(questions, decision.answers, "(no answer given)");
   const qa = rows.map((row) => `Q: ${row.question}\nA: ${row.answer}`).join("\n\n");
   return [
-    "You previously called AskUserQuestion with the following question(s); it was intercepted so the user could answer directly via Agent Relay instead of through the tool call:",
+    "This was answered by the user via the Agent Relay dashboard — the AskUserQuestion tool call itself was intercepted and will not resolve; it will not return a result. Here is their answer:",
     qa,
-    "The user has now answered above. Continue the task using their answer(s) — do not call AskUserQuestion again for the same question(s).",
+    "Continue the task using their answer(s) above — do not call AskUserQuestion again for the same question(s), and do not wait for the original tool call to return.",
   ].join("\n\n");
 }
 

package/src/adapters/claude-session-capture.ts

@@ -13,6 +13,7 @@ import {
   stepDedupKeys,
   transcriptHasToolUseAnchor,
   transcriptLooksComplete,
+  transcriptToolUseOccurredAt,
 } from "./claude-transcript";
 import { IncrementalClaudeTranscriptTail } from "./claude-transcript-tail";
 
@@ -23,10 +24,22 @@ interface ReasoningTailState {
 }
 
 const REASONING_POLL_MS = 1_200;
+// Bounded the same way as control-server.ts's resolvedApprovals so a long session's dedup
+// guard (see emittedStepKeys) can't grow without limit.
+const EMITTED_STEP_KEY_LIMIT = 2048;
 
 export class ClaudeSessionCapture {
   private narrativeFlushEntryCount = 0;
   private reasoningTail?: ReasoningTailState;
+  // Step signatures already published to chat — by the deny-then-hold pre-flush harvest or a
+  // prior reasoning-tail instance — kept for the life of this capture (not reset when a new
+  // tail starts). A fresh tail is created on every new prompt (see startReasoningTail),
+  // including the runner's own injected AskUserQuestion answer; it re-reads the transcript
+  // from byte 0 and recomputes "latest turn" steps from scratch, so if that first poll lands
+  // before the injected prompt's own transcript entry has advanced the "latest turn" window,
+  // it can re-derive the exact same step signatures the earlier tail already emitted. Seeding
+  // each new tail's `seen` set from this closes that gap regardless of the exact timing.
+  private emittedStepKeys = new Set<string>();
   private sessionEventCb: (event: ProviderSessionEvent) => void = () => {};
   private sessionEventsCb: (events: ProviderSessionEventBatch) => void = (events) => { for (const event of events) this.sessionEventCb(event); };
 
@@ -55,7 +68,8 @@ export class ClaudeSessionCapture {
         (ok) => { if (!ok) ctx.log(`pre-flush session outbox incomplete before blocking control (${ctx.pendingSessionEventCount()} pending)`); },
         (error) => ctx.log(`pre-flush session outbox failed before blocking control: ${errMessage(error)}`),
       );
-      return { reasoningSettled: settled.settled };
+      const toolUseOccurredAt = input.toolName ? transcriptToolUseOccurredAt(jsonl, input.toolName, input.toolInput) : undefined;
+      return { reasoningSettled: settled.settled, ...(toolUseOccurredAt ? { toolUseOccurredAt } : {}) };
     }
 
     const turnId = input.promptId ?? ctx.turnId;
@@ -129,7 +143,7 @@ export class ClaudeSessionCapture {
   private startReasoningTail(transcriptPath: string, ctx: ProviderSessionTurnContext): void {
     if (ctx.reasoningCapture === false) return;
     this.stopSessionTrace();
-    const seen = new Set<string>();
+    const seen = new Set<string>(this.emittedStepKeys);
     const emittedNarrationKeys = new Set<string>();
     const transcriptTail = new IncrementalClaudeTranscriptTail();
     const turnIdAtStart = ctx.turnId;
@@ -153,6 +167,7 @@ export class ClaudeSessionCapture {
       for (const { sig, step } of keyed) {
         if (seen.has(sig)) continue;
         seen.add(sig);
+        this.rememberEmittedStepKey(sig);
         emitted += 1;
         events.push({
           type: step.type,
@@ -177,6 +192,16 @@ export class ClaudeSessionCapture {
     void poll();
   }
 
+  private rememberEmittedStepKey(sig: string): void {
+    this.emittedStepKeys.delete(sig);
+    this.emittedStepKeys.add(sig);
+    while (this.emittedStepKeys.size > EMITTED_STEP_KEY_LIMIT) {
+      const oldest = this.emittedStepKeys.values().next().value;
+      if (oldest === undefined) break;
+      this.emittedStepKeys.delete(oldest);
+    }
+  }
+
   private preFlushBodyAlreadyMirroredByReasoningTail(jsonl: string, body: string): boolean {
     const tail = this.reasoningTail;
     if (!tail || !tail.emittedNarrationKeys.size) return false;

package/src/adapters/claude-tmux.ts

@@ -0,0 +1,133 @@
+// Claude tmux transport plumbing (extracted from ./claude for the file-size
+// ratchet, #300/#291): session/socket naming, pane capture, input-ready gating,
+// paste/submit injection, launcher-script materialization, and env-key selection.
+// The adapter (./claude) keeps the lifecycle decisions; this module owns the
+// mechanical tmux interactions they ride on. Public symbols are re-exported from
+// ./claude so existing import paths (including claude.test.ts) keep resolving.
+import { chmodSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { sanitizeFsName } from "agent-relay-sdk/fs-name";
+import { shellEscape as shellQuote } from "agent-relay-sdk/shell-utils";
+import { tmuxCommand, tmuxHasSession } from "agent-relay-sdk/tmux-utils";
+import { claudePaneLooksReady } from "./claude-status-detectors";
+import { launcherScriptPathForSession } from "../session-scratch";
+
+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;
+
+export function tmuxSessionName(prefix: string, instanceId: string, label?: string): string {
+  if (label) return `${prefix}-${sanitizeFsName(label, { replacement: "-", collapse: false, lowercase: true })}`;
+  return `${prefix}-${instanceId.slice(0, 8)}`;
+}
+
+export function tmuxSocketName(sessionName: string): string {
+  const socketName = sanitizeFsName(`agent-relay-${sessionName}`, { replacement: "-", collapse: false, lowercase: true });
+  assertTmuxSocketPathFits(socketName);
+  return socketName;
+}
+
+export function tmuxSocketPath(socketName: string, socketDir = defaultTmuxSocketDir()): string {
+  return join(socketDir, socketName);
+}
+
+export function assertTmuxSocketPathFits(socketName: string, socketDir = defaultTmuxSocketDir()): void {
+  const path = tmuxSocketPath(socketName, socketDir);
+  const bytes = Buffer.byteLength(path);
+  if (bytes < 108) return;
+  throw new Error(`derived name too long for tmux socket; pass a short \`label\` (socket path is ${bytes} bytes; must be < 108)`);
+}
+
+function defaultTmuxSocketDir(): string {
+  const base = process.env.TMUX_TMPDIR || "/tmp";
+  const uid = typeof process.getuid === "function" ? process.getuid() : "user";
+  return join(base, `tmux-${uid}`);
+}
+
+export function captureTmuxPane(sessionName: string, socketName?: string): string {
+  const result = Bun.spawnSync(tmuxCommand(socketName, "capture-pane", "-p", "-t", sessionName, "-S", "-80"), {
+    stdin: "ignore", stdout: "pipe", stderr: "pipe",
+  });
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.toString().trim();
+    throw new Error(`tmux capture-pane failed: ${stderr || `exit code ${result.exitCode}`}`);
+  }
+  return result.stdout.toString();
+}
+
+export async function waitForClaudeInputReady(sessionName: string, timeoutMs = CLAUDE_TMUX_READY_TIMEOUT_MS, socketName?: string): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!tmuxHasSession(sessionName, socketName)) throw new Error("tmux session exited before Claude became ready");
+    if (claudePaneLooksReady(captureTmuxPane(sessionName, socketName))) return;
+    await Bun.sleep(200);
+  }
+  throw new Error(`Claude input was not ready within ${timeoutMs}ms`);
+}
+
+function pasteTextIntoTmux(sessionName: string, text: string, socketName?: string): void {
+  const bufferName = `agent-relay-${crypto.randomUUID()}`;
+  const setResult = Bun.spawnSync(tmuxCommand(socketName, "set-buffer", "-b", bufferName, text), {
+    stdin: "ignore", stdout: "ignore", stderr: "pipe",
+  });
+  if (setResult.exitCode !== 0) {
+    const stderr = setResult.stderr.toString().trim();
+    throw new Error(`tmux set-buffer failed: ${stderr || `exit code ${setResult.exitCode}`}`);
+  }
+  try {
+    const pasteResult = Bun.spawnSync(tmuxCommand(socketName, "paste-buffer", "-b", bufferName, "-t", sessionName), {
+      stdin: "ignore", stdout: "ignore", stderr: "pipe",
+    });
+    if (pasteResult.exitCode !== 0) {
+      const stderr = pasteResult.stderr.toString().trim();
+      throw new Error(`tmux paste-buffer failed: ${stderr || `exit code ${pasteResult.exitCode}`}`);
+    }
+  } finally {
+    Bun.spawnSync(tmuxCommand(socketName, "delete-buffer", "-b", bufferName), {
+      stdin: "ignore", stdout: "ignore", stderr: "ignore",
+    });
+  }
+}
+
+export async function submitTextToTmux(sessionName: string, text: string, socketName?: string): Promise<void> {
+  pasteTextIntoTmux(sessionName, text, socketName);
+  await Bun.sleep(CLAUDE_TMUX_SUBMIT_DELAY_MS);
+  const result = Bun.spawnSync(tmuxCommand(socketName, "send-keys", "-t", sessionName, CLAUDE_TMUX_SUBMIT_KEY), {
+    stdin: "ignore", stdout: "ignore", stderr: "pipe",
+  });
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.toString().trim();
+    throw new Error(`tmux submit failed: ${stderr || `exit code ${result.exitCode}`}`);
+  }
+}
+
+// tmux new-session has a hard command-length limit that includes every argv item,
+// including `-e KEY=value`. The launcher script keeps tmux argv bounded by carrying
+// both env payloads (profile JSON, tokens, etc.) and the provider command/prompt.
+export function writeLauncherScript(sessionName: string, env: Record<string, string>, shellCmd: string): string {
+  const scriptPath = launcherScriptPathForSession(sessionName);
+  const launcherDir = dirname(scriptPath); mkdirSync(launcherDir, { recursive: true, mode: 0o700 }); chmodSync(launcherDir, 0o700);
+  const exports = Object.entries(env)
+    .map(([key, value]) => `export ${shellEnvKey(key)}=${shellQuote(value)}`)
+    .join("\n");
+  writeFileSync(scriptPath, `#!/usr/bin/env bash\n${exports ? `${exports}\n` : ""}exec ${shellCmd}\n`, { mode: 0o700 });
+  return scriptPath;
+}
+
+function shellEnvKey(key: string): string {
+  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) return key;
+  throw new Error(`invalid environment variable name for Claude launcher: ${key}`);
+}
+
+export function tmuxEnvKeys(env: Record<string, string>, providerEnv: Record<string, string>): string[] {
+  const keys = new Set<string>();
+  for (const key of Object.keys(env)) {
+    if (key.startsWith("AGENT_RELAY_") || key.startsWith("CLAUDE_")) {
+      keys.add(key);
+    }
+  }
+  for (const key of Object.keys(providerEnv)) {
+    keys.add(key);
+  }
+  return [...keys].sort();
+}

package/src/adapters/claude-transcript.ts

@@ -267,6 +267,35 @@ export function transcriptHasToolUseAnchor(jsonl: string, toolName: string, tool
   return false;
 }
 
+/**
+ * The transcript-embedded `timestamp` of the specific assistant entry carrying the exact
+ * tool_use block that triggered a PreToolUse hook (same anchor match as
+ * transcriptHasToolUseAnchor above). Used to stamp a resolved permission prompt with the
+ * tool call's real event time — a hook's own wall-clock receipt time can end up earlier than
+ * the entry the provider eventually flushes for that same call, which otherwise sorts the
+ * resolved prompt ahead of the narration that led up to it (#1185).
+ */
+export function transcriptToolUseOccurredAt(jsonl: string, toolName: string, toolInput: unknown): number | undefined {
+  const wantInput = canonicalJson(toolInput ?? {});
+  for (const line of jsonl.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let entry: TranscriptEntry;
+    try {
+      entry = JSON.parse(trimmed) as TranscriptEntry;
+    } catch {
+      continue;
+    }
+    if (entry.type !== "assistant" || isSidechainEntry(entry)) continue;
+    for (const block of blocks(entry.message)) {
+      if (block.type === "tool_use" && block.name === toolName && canonicalJson(block.input ?? {}) === wantInput) {
+        return transcriptEntryOccurredAt(entry);
+      }
+    }
+  }
+  return undefined;
+}
+
 /**
  * Extract the ordered narration, reasoning, and tool steps for the most recent
  * turn (since the last real user prompt). Used by the reasoning tailer to stream

package/src/adapters/claude.ts

@@ -1,8 +1,7 @@
-import { chmodSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { join, resolve } from "node:path";
 import { type Message } from "agent-relay-sdk";
-import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import { shellEscape as shellQuote } from "agent-relay-sdk/shell-utils";
 import { tmuxCommand, tmuxHasSession } from "agent-relay-sdk/tmux-utils";
 import { profileAllowsRelayFeature, type ManagedProcess, type ProviderAdapter, type ProviderConfig, type ProviderStatusUpdate, type RunnerSpawnConfig, type SemanticStatus, type SpawnArgs } from "../adapter";
@@ -14,8 +13,8 @@ import { claudeProviderMessageText } from "./claude-delivery";
 import { claudeProbeActivity, readManagedClaudeStatus, resolveClaudePid, type ClaudeProbeActivity } from "./claude-session-probe";
 import { evaluateClaudePromptGatePane, initialClaudePromptGatePaneState, type ClaudePromptGatePaneState } from "./claude-prompt-gates";
 import { claudePaneLooksReady, claudePaneIsBusy, claudeRateLimitStatus, claudeConnectionRetryStatus, claudeModelUnavailableStatus } from "./claude-status-detectors";
-import { launcherScriptPathForSession } from "../session-scratch";
 import { ClaudeSessionCapture, collectClaudeTranscriptArchiveSegment, collectClaudeTranscriptSessionEvents } from "./claude-session-capture";
+import { CLAUDE_TMUX_READY_TIMEOUT_MS, captureTmuxPane, submitTextToTmux, tmuxEnvKeys, tmuxSessionName, tmuxSocketName, waitForClaudeInputReady, writeLauncherScript } from "./claude-tmux";
 import { claudePermissionPromptHandler } from "./claude-permission";
 
 export class ClaudeAdapter implements ProviderAdapter {
@@ -468,9 +467,9 @@ export class ClaudeAdapter implements ProviderAdapter {
 }
 
 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;
+// tmux transport plumbing moved to ./claude-tmux (#300 ratchet); re-exported so
+// existing `./claude` consumers + tests keep their import paths.
+export { CLAUDE_TMUX_SUBMIT_DELAY_MS, CLAUDE_TMUX_SUBMIT_KEY, CLAUDE_TMUX_READY_TIMEOUT_MS, tmuxSessionName, tmuxSocketName, tmuxSocketPath, assertTmuxSocketPathFits, tmuxEnvKeys, waitForClaudeInputReady, submitTextToTmux } from "./claude-tmux";
 // Monitorless turn detection (Fix: isolated agents reach task "done" like Codex).
 const CLAUDE_TURN_WATCH_ID = "tmux-turn";
 const CLAUDE_TURN_POLL_MS = 1500;
@@ -528,107 +527,13 @@ function stripClaudePermissionArgs(args: string[], stripToolArgs = false): strin
 }
 
 
-export function tmuxSessionName(prefix: string, instanceId: string, label?: string): string {
-  if (label) return `${prefix}-${sanitizeFsName(label, { replacement: "-", collapse: false, lowercase: true })}`;
-  return `${prefix}-${instanceId.slice(0, 8)}`;
-}
-
-export function tmuxSocketName(sessionName: string): string {
-  return sanitizeFsName(`agent-relay-${sessionName}`, { replacement: "-", collapse: false, lowercase: true });
-}
-
 // Shared tmux helpers; tmuxHasSession re-exported for ./claude consumers + tests.
 export { tmuxHasSession };
 
-function captureTmuxPane(sessionName: string, socketName?: string): string {
-  const result = Bun.spawnSync(tmuxCommand(socketName, "capture-pane", "-p", "-t", sessionName, "-S", "-80"), {
-    stdin: "ignore", stdout: "pipe", stderr: "pipe",
-  });
-  if (result.exitCode !== 0) {
-    const stderr = result.stderr.toString().trim();
-    throw new Error(`tmux capture-pane failed: ${stderr || `exit code ${result.exitCode}`}`);
-  }
-  return result.stdout.toString();
-}
-
 // Re-export pane-status detectors (moved to ./claude-status-detectors) so existing
 // import paths (including claude.test.ts) continue to resolve via this module.
 export { claudePaneLooksReady, claudePaneIsBusy, claudeRateLimitStatus, claudeConnectionRetryStatus, claudeModelUnavailableStatus } from "./claude-status-detectors";
 
-async function waitForClaudeInputReady(sessionName: string, timeoutMs = CLAUDE_TMUX_READY_TIMEOUT_MS, socketName?: string): Promise<void> {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (!tmuxHasSession(sessionName, socketName)) throw new Error("tmux session exited before Claude became ready");
-    if (claudePaneLooksReady(captureTmuxPane(sessionName, socketName))) return;
-    await Bun.sleep(200);
-  }
-  throw new Error(`Claude input was not ready within ${timeoutMs}ms`);
-}
-
-function pasteTextIntoTmux(sessionName: string, text: string, socketName?: string): void {
-  const bufferName = `agent-relay-${crypto.randomUUID()}`;
-  const setResult = Bun.spawnSync(tmuxCommand(socketName, "set-buffer", "-b", bufferName, text), {
-    stdin: "ignore", stdout: "ignore", stderr: "pipe",
-  });
-  if (setResult.exitCode !== 0) {
-    const stderr = setResult.stderr.toString().trim();
-    throw new Error(`tmux set-buffer failed: ${stderr || `exit code ${setResult.exitCode}`}`);
-  }
-  try {
-    const pasteResult = Bun.spawnSync(tmuxCommand(socketName, "paste-buffer", "-b", bufferName, "-t", sessionName), {
-      stdin: "ignore", stdout: "ignore", stderr: "pipe",
-    });
-    if (pasteResult.exitCode !== 0) {
-      const stderr = pasteResult.stderr.toString().trim();
-      throw new Error(`tmux paste-buffer failed: ${stderr || `exit code ${pasteResult.exitCode}`}`);
-    }
-  } finally {
-    Bun.spawnSync(tmuxCommand(socketName, "delete-buffer", "-b", bufferName), {
-      stdin: "ignore", stdout: "ignore", stderr: "ignore",
-    });
-  }
-}
-
-async function submitTextToTmux(sessionName: string, text: string, socketName?: string): Promise<void> {
-  pasteTextIntoTmux(sessionName, text, socketName);
-  await Bun.sleep(CLAUDE_TMUX_SUBMIT_DELAY_MS);
-  const result = Bun.spawnSync(tmuxCommand(socketName, "send-keys", "-t", sessionName, CLAUDE_TMUX_SUBMIT_KEY), {
-    stdin: "ignore", stdout: "ignore", stderr: "pipe",
-  });
-  if (result.exitCode !== 0) {
-    const stderr = result.stderr.toString().trim();
-    throw new Error(`tmux submit failed: ${stderr || `exit code ${result.exitCode}`}`);
-  }
-}
-
-function writeLauncherScript(sessionName: string, env: Record<string, string>, shellCmd: string): string {
-  const scriptPath = launcherScriptPathForSession(sessionName);
-  const launcherDir = dirname(scriptPath); mkdirSync(launcherDir, { recursive: true, mode: 0o700 }); chmodSync(launcherDir, 0o700);
-  const exports = Object.entries(env)
-    .map(([key, value]) => `export ${shellEnvKey(key)}=${shellQuote(value)}`)
-    .join("\n");
-  writeFileSync(scriptPath, `#!/usr/bin/env bash\n${exports ? `${exports}\n` : ""}exec ${shellCmd}\n`, { mode: 0o700 });
-  return scriptPath;
-}
-
-function shellEnvKey(key: string): string {
-  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) return key;
-  throw new Error(`invalid environment variable name for Claude launcher: ${key}`);
-}
-
-export function tmuxEnvKeys(env: Record<string, string>, providerEnv: Record<string, string>): string[] {
-  const keys = new Set<string>();
-  for (const key of Object.keys(env)) {
-    if (key.startsWith("AGENT_RELAY_") || key.startsWith("CLAUDE_")) {
-      keys.add(key);
-    }
-  }
-  for (const key of Object.keys(providerEnv)) {
-    keys.add(key);
-  }
-  return [...keys].sort();
-}
-
 // Shared shell-quoting; re-exported so `./claude` consumers + tests resolve it.
 export { shellQuote };
 

package/src/control-server.ts

@@ -60,7 +60,7 @@ interface ControlServerOptions {
   // Provider session-final and pre-flush hooks hand over their capture source so
   // the runner can surface the provider turn in dashboard chat without the agent
   // re-emitting it via /reply.
-  onSessionTurn?(input: { transcriptPath: string; lastAssistantMessage?: unknown; promptId?: string; isPreFlush?: boolean; toolName?: string; toolInput?: unknown }): Promise<{ reasoningSettled: boolean } | void>;
+  onSessionTurn?(input: { transcriptPath: string; lastAssistantMessage?: unknown; promptId?: string; isPreFlush?: boolean; toolName?: string; toolInput?: unknown }): Promise<{ reasoningSettled: boolean; toolUseOccurredAt?: number } | void>;
   onPermissionResolved?(input: ResolvedPermissionPrompt): Promise<void> | void;
   onPermissionAbandoned?(input: PendingPermissionRequestRecord & { reason: string; decisionReason: ProviderPermissionDecisionReason }): Promise<void> | void;
   // #1173: a "questions" (AskUserQuestion) prompt's own PreToolUse hook is answered with `deny`
@@ -385,9 +385,15 @@ async function awaitPermissionDecision(params: {
   // chat. The adapter owns how to settle its capture source; the transport only
   // forwards the hook payload as an anchor and stamps the returned truth value.
   let reasoningSettled = true;
+  // Defaults to the hook's own wall-clock receipt time; refined below to the transcript's own
+  // tool_use event time when the pre-flush harvest can resolve it (#1185) — the hook can receive
+  // before the provider flushes/timestamps that entry, which otherwise sorts the resolved prompt
+  // ahead of the narration that led up to it.
+  let resolvedOccurredAt = occurredAt;
   if (transcriptPath && options.onSessionTurn) {
     const result = await options.onSessionTurn({ transcriptPath, isPreFlush: true, toolName, toolInput }).catch(() => undefined);
     if (result && typeof result.reasoningSettled === "boolean") reasoningSettled = result.reasoningSettled;
+    if (result && typeof result.toolUseOccurredAt === "number") resolvedOccurredAt = result.toolUseOccurredAt;
   }
   const view = handler.buildView(approvalId, body, reasoningSettled);
   const waitMs = options.permissionWaitMs ?? PERMISSION_WAIT_MS;
@@ -423,7 +429,7 @@ async function awaitPermissionDecision(params: {
   });
 
   if (decision.decisionReason?.kind !== "timeout" && options.onPermissionResolved) {
-    await Promise.resolve(options.onPermissionResolved(handler.buildResolvedPrompt(view, decision, body, occurredAt))).catch(() => {});
+    await Promise.resolve(options.onPermissionResolved(handler.buildResolvedPrompt(view, decision, body, resolvedOccurredAt))).catch(() => {});
   }
 
   return { decision, view };