@tekmidian/pai 0.66.6 → 0.66.8

package/dist/{run-ChlIbDJ0.mjs → run-BZNdpUGQ.mjs}

@@ -1,12 +1,14 @@
-import { i as getRegistryBackend } from "./factory-CXFHwvcv.mjs";
-import { a as paiHomePath, o as resolvePaiFile } from "./pai-home-UncxWxlX.mjs";
-import { A as resolveProviderKey, D as readWorkersSection, E as providerKeyPath, O as resolveCapability, T as providerCostTier, _ as classModelCapability, b as getProviderOrNative, f as NATIVE_ANTHROPIC_MODELS, g as assertProviderRunnable, h as WorkersConfigError, k as resolveModelCapability, m as WORKER_CLASSES, n as claudeCommand, o as DEFAULT_LOG_DIR, r as ANTHROPIC_NATIVE, t as buildRunEnv, x as isModelCapability, y as expandHome } from "./run-env-CQRnxNht.mjs";
-import { appendFileSync, closeSync, existsSync, lstatSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
-import { homedir, platform, tmpdir } from "node:os";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { C as providerCostTier, D as resolveModelCapability, E as resolveCapability, O as resolveProviderKey, T as readWorkersSection, f as WORKER_CLASSES, h as classModelCapability, m as assertProviderRunnable, p as WorkersConfigError, t as ANTHROPIC_NATIVE, u as NATIVE_ANTHROPIC_MODELS, v as getProviderOrNative, w as providerKeyPath, y as isModelCapability } from "./config-Dpe2JlbY.mjs";
+import { A as newWorkerId, B as shortText, D as isLive, G as panesDir, H as ensureNoMcpConfig, K as routingStatePath, L as appendSystemPromptArgs, N as parseSleepSecs, O as loadStatus, P as saveStatus, U as eventsPath, V as stripPromptValues, W as ledgerPath, _ as appendLedger, c as recordWorktree, d as worktreeSystemPrompt, f as worktreeWanted, i as gcWorktreesThrottled, j as nowStamp, k as loadStatuses, l as salvageOnExit, o as inPlaceSystemPrompt, q as workersLogDir, t as addWorktree, w as describeTool, y as UNLABELED, z as parseRunnerArgs } from "./worktree-CwMRTa0H.mjs";
+import { i as getRegistryBackend } from "./factory-yElzJc6f.mjs";
+import { n as claudeCommand, t as buildRunEnv } from "./run-env-Cd0Son-Y.mjs";
+import { appendFileSync, closeSync, existsSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { execFileSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { connect, createServer } from "node:net";
-import { execFileSync, spawn } from "node:child_process";
+import { createServer as createServer$1 } from "node:http";
 import { createInterface } from "node:readline";
 
 //#region src/workers/mcp.ts
@@ -224,59 +226,6 @@ function pinNotices(launch, claudeJson) {
 	return lines;
 }
 
-//#endregion
-//#region src/workers/paths.ts
-/**
-* paths.ts — where worker run artefacts live.
-*
-* Everything a run writes (event mirror, status file, pane registry, routing
-* state, the empty MCP config) sits under one logDir so the whole tree is
-* disposable and configurable: `workers.logDir`, default ~/.claude/logs/workers.
-*/
-/**
-* Absolute logDir for the given config. An explicit `logDir` in workers.yaml
-* is honored verbatim (the user chose it). Otherwise this resolves like every
-* other PAI_HOME file: PAI_HOME/logs/workers if it exists, else the old
-* ~/.claude/logs/workers (with a one-time notice), else the new path.
-*/
-function workersLogDir(config) {
-	const expanded = expandHome(config.logDir);
-	if (config.logDir !== DEFAULT_LOG_DIR) return expanded;
-	return resolvePaiFile(paiHomePath("logs", "workers"), [expanded], "pai config migrate --logs");
-}
-/** The strict empty MCP config for headless runs, written on demand. */
-function ensureNoMcpConfig(logDir) {
-	const path = noMcpConfigPath(logDir);
-	if (!existsSync(path)) {
-		mkdirSync(logDir, { recursive: true });
-		writeFileSync(path, "{ \"mcpServers\": {} }\n", "utf8");
-	}
-	return path;
-}
-function statusPath(logDir, id) {
-	return join(logDir, `${id}.status`);
-}
-function eventsPath(logDir, id) {
-	return join(logDir, `${id}.jsonl`);
-}
-function ledgerPath(logDir) {
-	return join(logDir, "ledger.log");
-}
-function routingStatePath(logDir) {
-	return join(logDir, "routing-state.json");
-}
-function panesDir(logDir) {
-	return join(logDir, "panes");
-}
-/**
-* The strict empty MCP config handed to headless workers. Written into the
-* logDir on demand (never into the user's vendor config directory — this is
-* PAI state, not vendor state).
-*/
-function noMcpConfigPath(logDir) {
-	return join(logDir, "no-mcp.json");
-}
-
 //#endregion
 //#region src/workers/routing.ts
 /**
@@ -617,1522 +566,6 @@ function stopProxy(logDir) {
 	return `proxy pid ${pid} stopped`;
 }
 
-//#endregion
-//#region src/workers/args.ts
-function parseRunnerArgs(argv) {
-	let prompt = null;
-	let outputFormat = "text";
-	const rest = [];
-	let headless = false;
-	let callerModel = false;
-	let callerMcpConfig = false;
-	let callerSystemPrompt = false;
-	const callerSystemPrompts = [];
-	let callerTools = false;
-	const mcp = [];
-	const allowedTools = [];
-	let i = 0;
-	while (i < argv.length) {
-		const a = argv[i];
-		if (a === "-p" || a === "--print") {
-			headless = true;
-			rest.push(a);
-			if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
-				prompt = argv[i + 1];
-				rest.push(prompt);
-				i += 1;
-			}
-		} else if (a === "--output-format") {
-			const v = argv[i + 1];
-			if (v === "json" || v === "stream-json") outputFormat = v;
-			i += 1;
-		} else if (a.startsWith("--output-format=")) {
-			const v = a.slice(16);
-			if (v === "json" || v === "stream-json") outputFormat = v;
-		} else if (a === "--verbose") {} else if (a === "--append-system-prompt") {
-			callerSystemPrompt = true;
-			if (i + 1 < argv.length) callerSystemPrompts.push(argv[++i]);
-		} else if (a.startsWith("--append-system-prompt=")) {
-			callerSystemPrompt = true;
-			callerSystemPrompts.push(a.slice(23));
-		} else if (a === "--mcp") {
-			const v = argv[i + 1];
-			if (v !== void 0 && !v.startsWith("-")) {
-				mcp.push(v);
-				i += 1;
-			}
-		} else if (a.startsWith("--mcp=")) mcp.push(a.slice(6));
-		else if (a === "--allowedTools") {
-			rest.push(a);
-			const v = argv[i + 1];
-			if (v !== void 0 && !v.startsWith("-")) {
-				allowedTools.push(v);
-				rest.push(v);
-				i += 1;
-			}
-		} else if (a.startsWith("--allowedTools=")) {
-			allowedTools.push(a.slice(15));
-			rest.push(a);
-		} else {
-			if (a === "--model") callerModel = true;
-			if (a.startsWith("--model=")) callerModel = true;
-			if (a === "--mcp-config") callerMcpConfig = true;
-			if (a.startsWith("--mcp-config=")) callerMcpConfig = true;
-			if (a === "--tools") callerTools = true;
-			if (a.startsWith("--tools=")) callerTools = true;
-			if (prompt === null && !a.startsWith("-") && rest.length > 0 && (rest[rest.length - 1] === "-p" || rest[rest.length - 1] === "--print")) prompt = a;
-			rest.push(a);
-		}
-		i += 1;
-	}
-	return {
-		prompt,
-		outputFormat,
-		rest,
-		headless,
-		callerModel,
-		callerMcpConfig,
-		callerSystemPrompt,
-		callerSystemPrompts,
-		callerTools,
-		mcp,
-		allowedTools
-	};
-}
-/**
-* The one --append-system-prompt flag for a spawn: claude keeps only the LAST
-* occurrence, so every piece is joined (blank line between) into a single flag.
-* Empty parts are dropped; no parts, no flag.
-*/
-function appendSystemPromptArgs(parts) {
-	const text = parts.filter((p) => p.trim()).join("\n\n");
-	return text ? ["--append-system-prompt", text] : [];
-}
-/**
-* Turn `-p "<prompt>"` into bare `-p` (same for --print): for stream-json
-* stdin runs the prompt moves to the first user message on stdin, so the
-* value must not stay on the command line. Only prompt values directly
-* following the flag are touched; everything else passes through.
-*/
-function stripPromptValues(argv) {
-	const out = [];
-	for (let i = 0; i < argv.length; i++) {
-		const a = argv[i];
-		const isPrint = a === "-p" || a === "--print";
-		out.push(a);
-		if (isPrint && i + 1 < argv.length && !argv[i + 1].startsWith("-")) i += 1;
-	}
-	return out;
-}
-/**
-* A one-line stderr hint (never blocking) for an inline -p prompt long or
-* multi-line enough to be a shell-quoting risk — write it to a file and pass
-* --spec instead. null when the prompt is short/simple enough to be fine.
-*/
-function longInlinePromptHint(prompt) {
-	if (!prompt) return null;
-	const newlines = (prompt.match(/\n/g) ?? []).length;
-	if (prompt.length > 600 || newlines > 3) return "hint: long inline prompts break on shell quoting — write the spec to a file and use --spec <file>";
-	return null;
-}
-/** Collapse whitespace and cut to n chars with an ellipsis (label rendering). */
-function shortText(s, n) {
-	const t = String(s ?? "").split(/\s+/).filter(Boolean).join(" ");
-	return t.length <= n ? t : t.slice(0, n - 1) + "…";
-}
-
-//#endregion
-//#region src/workers/status.ts
-/**
-* status.ts — the live per-worker status file.
-*
-* One JSON file per run, rewritten atomically on every turn, read by `ps`,
-* `follow`, the status line and the pane logic. Same field set the Python
-* runner wrote, plus `provider` (routing is multi-provider now) and `session`
-* (the AIBroker identity of the launching session, see scope.ts).
-*/
-/** Label a worker gets when launched with neither --label nor a prompt. */
-const UNLABELED = "unlabeled";
-/**
-* Whether a status is the terminal's interactive chat pane, not a spawned
-* task worker. `origin` is the real discriminator; the fallback catches
-* running entries from before the flag existed (unlabeled, no turns yet).
-* Removable once every pane runs code that writes `origin`.
-*/
-function isChatPane(s) {
-	return s.origin === "chat" || !s.origin && (s.label === UNLABELED || s.label === "(no prompt)") && s.turns === 0;
-}
-/** Context-meter percentage 0–100, null when the numbers are missing. */
-function contextPercent(s) {
-	if (!s.contextTokens || !s.contextWindow) return null;
-	return Math.round(s.contextTokens / s.contextWindow * 100);
-}
-/** Compact token count: 84k, 200k, 900. */
-function fmtContextK(n) {
-	return n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n);
-}
-/**
-* The one context-meter label, shared by every renderer so identical
-* numbers always render identically: `ctx 84k/200k (42%)` — used-style
-* percent. Empty when the numbers are missing (callers drop the part).
-*/
-function contextLabel(s) {
-	const pct = contextPercent(s);
-	if (pct === null) return "";
-	return `ctx ${fmtContextK(s.contextTokens ?? 0)}/${fmtContextK(s.contextWindow ?? 0)} (${pct}%)`;
-}
-/** Timestamp format shared by status files and the ledger. */
-function nowStamp(d = /* @__PURE__ */ new Date()) {
-	const p = (n) => String(n).padStart(2, "0");
-	return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
-}
-let lastId = "";
-let idSeq = 0;
-function newWorkerId(d = /* @__PURE__ */ new Date(), pid = process.pid) {
-	const p = (n) => String(n).padStart(2, "0");
-	const base = `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}-${pid}`;
-	if (base === lastId) {
-		idSeq += 1;
-		return `${base}-${String(idSeq).padStart(2, "0")}`;
-	}
-	lastId = base;
-	idSeq = 0;
-	return base;
-}
-let tmpSeq = 0;
-/** A temp path only this call owns — never the same string twice. */
-function statusTmpPath(logDir, id) {
-	return `${statusPath(logDir, id)}.${process.pid}.${tmpSeq++}.tmp`;
-}
-const firstWrittenLabel = /* @__PURE__ */ new Map();
-/** Write status atomically (temp + rename) and stamp `updated`. */
-function saveStatus(logDir, status, d = /* @__PURE__ */ new Date()) {
-	status.updated = nowStamp(d);
-	const path = statusPath(logDir, status.id);
-	const baseline = firstWrittenLabel.get(status.id);
-	if (baseline === void 0) firstWrittenLabel.set(status.id, status.label);
-	const onDisk = baseline === void 0 ? void 0 : loadStatus(logDir, status.id);
-	if (onDisk) {
-		if (status.label === baseline && onDisk.label !== status.label) status.label = onDisk.label;
-		if (onDisk.controlsHeld) status.controlsHeld = true;
-	}
-	const tmp = statusTmpPath(logDir, status.id);
-	if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
-	try {
-		writeFileSync(tmp, JSON.stringify(status), "utf8");
-		renameSync(tmp, path);
-	} catch (e) {
-		try {
-			rmSync(tmp, { force: true });
-		} catch {}
-		throw e;
-	}
-}
-/**
-* Set a worker's goal (the operator's `--label`), atomically, through the
-* same saveStatus path everything else writes with. Used by `pai worker
-* goal` and the `--goal` option of `say`: a fresh call in a fresh process, so
-* it always carries no baseline yet and always wins over the worker's own
-* next periodic write (see saveStatus above).
-*/
-function setWorkerLabel(logDir, id, label) {
-	const status = loadStatus(logDir, id);
-	if (!status) throw new Error(`no worker named "${id}"`);
-	status.label = label;
-	saveStatus(logDir, status);
-	return status;
-}
-/** Load every status file in the logDir, oldest id first, skipping damage. */
-function loadStatuses(logDir) {
-	if (!existsSync(logDir)) return [];
-	const out = [];
-	for (const name of readdirSync(logDir).sort()) {
-		if (!name.endsWith(".status")) continue;
-		try {
-			out.push(JSON.parse(readFileSync(join(logDir, name), "utf8")));
-		} catch {}
-	}
-	return out;
-}
-function loadStatus(logDir, id) {
-	const path = statusPath(logDir, id);
-	if (!existsSync(path)) return null;
-	try {
-		return JSON.parse(readFileSync(path, "utf8"));
-	} catch {
-		return null;
-	}
-}
-/**
-* Wait for a worker to record its own terminal state (the run's signal
-* handler writes killed/rc/secs). Returns that status, or null when it is
-* still "running" after `timeoutMs` — the caller then writes the state itself.
-*/
-async function waitForTerminalStatus(logDir, id, timeoutMs = 2e3, stepMs = 50) {
-	const deadline = Date.now() + timeoutMs;
-	for (;;) {
-		const s = loadStatus(logDir, id);
-		if (s && s.state !== "running") return s;
-		if (Date.now() >= deadline) return null;
-		await new Promise((r) => setTimeout(r, stepMs));
-	}
-}
-function alive(pid) {
-	if (!pid || pid <= 0) return false;
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Whether `status.pid` still names the process that was started as this
-* worker, not a later, unrelated process the OS handed the same pid to after
-* the worker exited. `alive()` alone can't tell these apart — a pid observed
-* live on 2026-09-19 (worker 20260919-083549-90913) had been reused, and
-* `pai worker kill` signalled the wrong, unrelated process. `ps -o lstart=`
-* reads the running process's actual start time and compares it against the
-* status file's own `started` stamp; a reused pid almost never starts within
-* 120s of the original, so a wider drift means "different process".
-*/
-function ownsPid(status) {
-	if (status.pid <= 0 || !alive(status.pid)) return false;
-	try {
-		const out = execFileSync("ps", [
-			"-o",
-			"lstart=",
-			"-p",
-			String(status.pid)
-		], {
-			encoding: "utf8",
-			env: {
-				...process.env,
-				LC_ALL: "C"
-			}
-		}).trim();
-		const psStart = Date.parse(out);
-		const started = Date.parse(status.started.replace(" ", "T"));
-		if (Number.isNaN(psStart) || Number.isNaN(started)) return alive(status.pid);
-		return Math.abs(psStart - started) <= 12e4;
-	} catch {
-		return alive(status.pid);
-	}
-}
-/** Whether a status is both marked "running" and still owns its recorded pid. */
-function isLive(status) {
-	return status.state === "running" && ownsPid(status);
-}
-/** "42s" under 90s, "7m" above — the coarse age the table and bar show. */
-function ageOf(ts, now = /* @__PURE__ */ new Date()) {
-	const t = Date.parse(ts.replace(" ", "T"));
-	if (Number.isNaN(t)) return "?";
-	const s = Math.max(0, Math.floor((now.getTime() - t) / 1e3));
-	return s < 90 ? `${s}s` : `${Math.floor(s / 60)}m`;
-}
-/** Precise elapsed time: "45s", "1m 23s", "12m 05s", "1h 02m 05s" — seconds zero-padded after a larger unit. */
-function elapsedOf(ts, now = /* @__PURE__ */ new Date()) {
-	const t = Date.parse(ts.replace(" ", "T"));
-	if (Number.isNaN(t)) return "?";
-	const secs = Math.max(0, Math.floor((now.getTime() - t) / 1e3));
-	const hours = Math.floor(secs / 3600);
-	const mins = Math.floor(secs % 3600 / 60);
-	const sec = secs % 60;
-	if (hours > 0) return `${hours}h ${String(mins).padStart(2, "0")}m ${String(sec).padStart(2, "0")}s`;
-	if (mins > 0) return `${mins}m ${String(sec).padStart(2, "0")}s`;
-	return `${sec}s`;
-}
-/** Shorter sleeps are legitimate polling — not worth a supervision event. */
-const SLEEP_FLOOR_SECS = 60;
-const SLEEP_RE = /^\s*sleep\s+([0-9]+(?:\.[0-9]+)?)([smhd]?)\s*(?:$|[;&|])/;
-/** s/m/h/d suffix to seconds multiplier, shared by every `sleep N<unit>` parse below. */
-function sleepUnitMultiplier(unit) {
-	return unit === "m" ? 60 : unit === "h" ? 3600 : unit === "d" ? 86400 : 1;
-}
-/**
-* Seconds of a `sleep N` (N plain or with an s/m/h/d suffix) that stands alone
-* or leads a compound command (`sleep 150; cat f`, `sleep 2m && tail f`,
-* `sleep 90 || true`, `sleep 60 &`), or null when no long sleep leads: anchored
-* to the start of the command, so a filename containing "sleep" or an
-* `echo sleep 500` never trips it, and floored at SLEEP_FLOOR_SECS so ordinary
-* polling stays invisible.
-*/
-function parseSleepSecs(command) {
-	const m = command.match(SLEEP_RE);
-	if (!m) return null;
-	const secs = Number(m[1]) * sleepUnitMultiplier(m[2]);
-	return Number.isFinite(secs) && secs >= SLEEP_FLOOR_SECS ? secs : null;
-}
-/** One-line description of a tool call, e.g. "Bash: npm test". */
-function describeTool(name, inp) {
-	if (typeof inp !== "object" || inp === null) return name;
-	const i = inp;
-	const get = (k) => typeof i[k] === "string" ? i[k] : "";
-	if (name === "Bash") return `Bash: ${shortText(get("command"), 70)}`;
-	if (name === "Read" || name === "Edit" || name === "Write" || name === "MultiEdit") return `${name}: ${get("file_path").split("/").pop() ?? ""}`;
-	if (name === "Grep" || name === "Glob") return `${name}: ${shortText(get("pattern"), 50)}`;
-	if (name === "WebSearch") return `${name}: ${shortText(get("query"), 50)}`;
-	if (name === "WebFetch") return `${name}: ${shortText(get("url"), 60)}`;
-	return name;
-}
-
-//#endregion
-//#region src/workers/ledger.ts
-/**
-* ledger.ts — the routing ledger, one append-only log for every worker event.
-*
-* Line shapes (whitespace-aligned so `tail` reads as a table):
-*
-*   2026-09-17 12:00:00 WORKER-START id=<id> provider=<p> mode=headless model=<m> cwd=<cwd> label=<label>
-*   2026-09-17 12:01:00 WORKER-END   id=<id> provider=<p> mode=headless model=<m> rc=0 secs=60 turns=3 tools=8 label=<label>
-*   2026-09-17 12:00:20 WORKER-REROUTE from=<a> to=<b> reason=quota
-*   2026-09-17 12:00:00 DENIED-ANTHROPIC-AGENT cwd=<cwd> desc=<desc>
-*   2026-09-17 12:00:00 ALLOWED-ANTHROPIC-AGENT cwd=<cwd> desc=<desc>
-*
-* `pai worker log` (and glm-log before it) counts these; keep the tags stable.
-*/
-function ledgerStamp(d = /* @__PURE__ */ new Date()) {
-	const p = (n) => String(n).padStart(2, "0");
-	return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
-}
-/** Parse `2026-09-17 12:00:00 TAG key=value …` into its parts. */
-function parseLedgerLine(line) {
-	const m = line.match(/^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) (\S+)(?: (.*))?$/);
-	if (!m) return null;
-	const fields = {};
-	for (const part of (m[3] ?? "").split(" ")) {
-		if (!part) continue;
-		const eq = part.indexOf("=");
-		if (eq <= 0) continue;
-		fields[part.slice(0, eq)] = part.slice(eq + 1);
-	}
-	return {
-		stamp: m[1],
-		event: m[2],
-		fields
-	};
-}
-/** Append one ledger line. `kv` order is the caller's; values are flattened. */
-function appendLedger(path, event, kv, now = /* @__PURE__ */ new Date()) {
-	const parts = [];
-	for (const [k, v] of Object.entries(kv)) {
-		if (v === void 0 || v === null) continue;
-		parts.push(`${k}=${String(v).replace(/\s+/g, " ")}`);
-	}
-	const dir = dirname(path);
-	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-	const tail = parts.length ? " " + parts.join(" ") : "";
-	appendFileSync(path, `${ledgerStamp(now)} ${event}${tail}\n`, "utf8");
-}
-/** The counts `pai worker log` prints, over today's lines or the whole file. */
-function ledgerSummary(path, scope, lastN = 15, now = /* @__PURE__ */ new Date()) {
-	if (!existsSync(path)) return null;
-	const text = readFileSync(path, "utf8");
-	const today = ledgerStamp(now).slice(0, 10);
-	const lines = text.split("\n").filter((l) => l.trim());
-	const parsed = (scope === "all" ? lines : lines.filter((l) => l.startsWith(today))).map(parseLedgerLine).filter((x) => x !== null);
-	const count = (ev) => parsed.filter((p) => p.event === ev).length;
-	const ends = parsed.filter((p) => p.event === "WORKER-END");
-	const ok = ends.filter((p) => p.fields.rc === "0").length;
-	return {
-		scope: scope === "all" ? "all time" : `today ${today}`,
-		started: count("WORKER-START"),
-		endedOk: ok,
-		endedFailed: ends.length - ok,
-		denied: count("DENIED-ANTHROPIC-AGENT"),
-		allowed: count("ALLOWED-ANTHROPIC-AGENT"),
-		reroutes: count("WORKER-REROUTE"),
-		lastLines: lines.slice(-lastN)
-	};
-}
-
-//#endregion
-//#region src/workers/pending.ts
-/**
-* Pending worker results: finished workers whose worktree branch still holds
-* work that never reached the repo (commits not in HEAD, or uncommitted
-* files). Surfaced by `pai worker ps/pending`, the SessionStart hook, the
-* status line and the prepublish gate so an unmerged fix cannot be forgotten.
-*/
-/** Stale after this long: `pai worker gc` (archive) instead of merge. */
-const STALE_HOURS = 24;
-function toplevel(dir) {
-	try {
-		return git(dir, ["rev-parse", "--show-toplevel"]);
-	} catch {
-		return null;
-	}
-}
-function fmtAge(ms) {
-	const h = Math.floor(ms / 36e5);
-	return h >= 48 ? `${Math.floor(h / 24)}d` : h >= 1 ? `${h}h` : `${Math.floor(ms / 6e4)}m`;
-}
-/** Finished workers with unmerged work; `repoRoot` limits to one repo, else every repo. */
-function pendingResults(logDir, repoRoot, now = Date.now()) {
-	const want = repoRoot ? toplevel(repoRoot) : null;
-	if (repoRoot && !want) return [];
-	const out = [];
-	for (const st of loadStatuses(logDir)) {
-		if (st.archived || st.merged || isLive(st)) continue;
-		if (!st.worktreeDir || !existsSync(st.worktreeDir)) continue;
-		const repo = toplevel(st.cwd);
-		if (!repo || want && repo !== want) continue;
-		let commits = 0;
-		let dirty = 0;
-		try {
-			if (st.branch) commits = git(repo, [
-				"cherry",
-				"HEAD",
-				`refs/heads/${st.branch}`
-			]).split("\n").filter((l) => l.startsWith("+")).length;
-			dirty = uncommittedPaths(st.worktreeDir).filter((p) => !/(^|\/)node_modules(\/|$)/.test(p)).length;
-		} catch {
-			continue;
-		}
-		if (!commits && !dirty) continue;
-		let ageMs = 0;
-		try {
-			ageMs = Math.max(0, now - statSync(statusPath(logDir, st.id)).mtimeMs);
-		} catch {}
-		out.push({
-			id: st.id,
-			label: st.label,
-			repo,
-			ageMs,
-			age: fmtAge(ageMs),
-			commits,
-			dirty
-		});
-	}
-	return out;
-}
-/** One human line per result, with the exact next command. */
-function formatPending(results, showRepo = false) {
-	return results.map((r) => {
-		const next = r.ageMs > STALE_HOURS * 36e5 ? "pai worker gc" : `pai worker merge ${r.id}`;
-		const repo = showRepo ? `  ${r.repo}` : "";
-		return `${r.id}  ${r.age}  ${r.commits} commit(s), ${r.dirty} dirty  ${r.label}${repo}  -> ${next}`;
-	}).join("\n");
-}
-/**
-* Release gate: exit code and message for `pai worker pending --gate`.
-* PAI_ALLOW_PENDING=1 overrides.
-*/
-function pendingGate(results, env = process.env) {
-	if (!results.length || env.PAI_ALLOW_PENDING === "1") return {
-		code: 0,
-		message: ""
-	};
-	return {
-		code: 1,
-		message: `${results.length} unmerged worker result(s) in this repo — merge or discard before publishing:\n${formatPending(results)}\nOverride deliberately with PAI_ALLOW_PENDING=1.`
-	};
-}
-/** Invalidate pending cache entries for a repo and its subdirectories. */
-function invalidatePendingCache(logDir, repoRoot) {
-	const file = join(logDir, "pending-cache.json");
-	let cache = {};
-	try {
-		cache = JSON.parse(readFileSync(file, "utf8"));
-	} catch {
-		return;
-	}
-	const resolved = repoRoot.endsWith("/") ? repoRoot : `${repoRoot}/`;
-	let changed = false;
-	for (const key of Object.keys(cache)) if (key === repoRoot || key.startsWith(resolved)) {
-		delete cache[key];
-		changed = true;
-	}
-	if (!changed) return;
-	try {
-		writeFileSync(file, JSON.stringify(cache));
-	} catch {}
-}
-
-//#endregion
-//#region src/workers/worktree.ts
-/**
-* worktree.ts — one git worktree per writing worker.
-*
-* A run whose class edits files (implement, complex, plan) and whose cwd is a
-* git repository gets its own worktree by default: `git worktree add
-* <logDir>/worktrees/<id> -b worker/<id>` from the current HEAD. The worker
-* commits its own work on that branch — the no-commit rule applies to the
-* main branch only — and the parent (or the operator) merges the result back:
-*
-*   pai worker merge <id>     git merge --no-ff worker/<id> + remove worktree + delete branch
-*   pai worker discard <id>   remove worktree and branch, keep nothing
-*
-* `ps` marks a worker with an unmerged branch `⎇`. Draft and review run in
-* place; `--no-worktree` opts out, `--worktree` forces one on.
-*/
-function worktreesDir(logDir) {
-	return join(logDir, "worktrees");
-}
-function worktreeBranch(id) {
-	return `worker/${id}`;
-}
-function worktreePath(logDir, id) {
-	return join(worktreesDir(logDir), id);
-}
-/** Run git in `cwd` with an optional env override, trimmed stdout, stderr on failure. */
-function runGit(cwd, args, env, timeout = 3e4) {
-	try {
-		return execFileSync("git", [
-			"-C",
-			cwd,
-			...args
-		], {
-			encoding: "utf8",
-			timeout,
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			],
-			...env ? { env } : {}
-		}).trim();
-	} catch (e) {
-		const err = e;
-		const why = (typeof err.stderr === "string" ? err.stderr : err.stderr?.toString("utf8")) || err.message || String(e);
-		throw new Error(`git ${args.join(" ")} in ${cwd}: ${why.trim()}`);
-	}
-}
-/** Run git in `cwd`, returning trimmed stdout; throws with stderr on failure. */
-function git(cwd, args, timeoutMs) {
-	return runGit(cwd, args, void 0, timeoutMs);
-}
-/** Is `cwd` inside a git repository (a .git dir — worktrees: a .git file)? */
-function isGitRepo(cwd) {
-	try {
-		return git(cwd, ["rev-parse", "--git-dir"]) !== "";
-	} catch {
-		return false;
-	}
-}
-/** Tools that can write to the checkout (Bash can, via the shell). */
-const WRITING_TOOLS = [
-	"Edit",
-	"Write",
-	"MultiEdit",
-	"NotebookEdit",
-	"Bash"
-];
-/** Can a run with these --allowedTools write? No restriction at all means yes. */
-function toolsCanWrite(allowedTools) {
-	const names = allowedTools.flatMap((e) => e.split(",")).map((s) => s.trim().replace(/\(.*$/, "")).filter(Boolean);
-	return !names.length || names.some((n) => WRITING_TOOLS.includes(n));
-}
-/** Should this run get a worktree? Explicit flag first, then: can it write? */
-function worktreeWanted(flag, opts) {
-	if (flag !== void 0) return flag;
-	return toolsCanWrite(opts.allowedTools) && isGitRepo(opts.cwd);
-}
-/**
-* Commit `cwd`'s current index + working tree (including untracked files) as
-* a floating commit on top of HEAD, without touching the real index, working
-* tree or HEAD: a temporary `GIT_INDEX_FILE` collects the snapshot, `git
-* commit-tree` writes the commit object directly (it updates no ref). The
-* caller then branches a worktree from that commit, so the worktree sees
-* exactly what was on disk, uncommitted or not.
-*/
-function snapshotUncommitted(cwd, id, head) {
-	const idxDir = mkdtempSync(join(tmpdir(), "pai-worktree-idx-"));
-	const idx = join(idxDir, "index");
-	try {
-		const env = {
-			...process.env,
-			GIT_INDEX_FILE: idx
-		};
-		runGit(cwd, ["read-tree", head], env);
-		runGit(cwd, ["add", "-A"], env);
-		return runGit(cwd, [
-			"commit-tree",
-			runGit(cwd, ["write-tree"], env),
-			"-p",
-			head,
-			"-m",
-			`worker ${id}: snapshot of uncommitted checkout`
-		]);
-	} finally {
-		rmSync(idxDir, {
-			recursive: true,
-			force: true
-		});
-	}
-}
-/**
-* Create the worktree and branch for `id` from `cwd`'s HEAD — or, when the
-* checkout has uncommitted changes, from a snapshot commit of that dirty
-* state (see `snapshotUncommitted`), so a worktree worker sees the same
-* files the operator sees, not just what was last committed. Throws when git
-* refuses (no commits yet, branch exists, …) — the caller decides whether to
-* degrade to an in-place run.
-*/
-function addWorktree(logDir, id, cwd) {
-	const dir = worktreePath(logDir, id);
-	const branch = worktreeBranch(id);
-	const head = git(cwd, ["rev-parse", "HEAD"]);
-	const dirty = dirtyPaths(cwd).length > 0;
-	const base = dirty ? snapshotUncommitted(cwd, id, head) : head;
-	git(cwd, [
-		"worktree",
-		"add",
-		dir,
-		"-b",
-		branch,
-		base
-	]);
-	provisionDeps(logDir, id, cwd, dir);
-	return {
-		dir,
-		branch,
-		base,
-		snapshot: dirty
-	};
-}
-/**
-* Give the worktree its own dependencies so the worker never has to improvise
-* (symlinking node_modules to the main checkout, building in a /tmp copy).
-* A real node_modules directory in the main checkout is APFS-cloned
-* (`cp -c`, copy-on-write, near instant); elsewhere the lockfile installs it.
-* Never a symlink. Time-boxed and best effort: a failure is logged, the run
-* goes on.
-*/
-function provisionDeps(logDir, id, cwd, wtDir) {
-	const note = (n) => appendLedger(ledgerPath(logDir), "WORKER-NOTE", {
-		id,
-		note: n
-	});
-	try {
-		const main = join(git(cwd, ["rev-parse", "--show-toplevel"]), "node_modules");
-		const dest = join(wtDir, "node_modules");
-		if (!existsSync(main) || lstatSync(main).isSymbolicLink() || existsSync(dest)) return;
-		try {
-			git(wtDir, [
-				"check-ignore",
-				"-q",
-				"node_modules"
-			]);
-		} catch {
-			return;
-		}
-		const t0 = Date.now();
-		const opts = {
-			cwd: wtDir,
-			stdio: "ignore",
-			timeout: 18e4
-		};
-		if (platform() === "darwin") try {
-			execFileSync("cp", [
-				"-cR",
-				main,
-				dest
-			], opts);
-			note(`node_modules cloned (apfs) in ${Date.now() - t0}ms`);
-			return;
-		} catch {
-			rmSync(dest, {
-				recursive: true,
-				force: true
-			});
-		}
-		if (existsSync(join(wtDir, "bun.lock"))) execFileSync("bun", ["install", "--frozen-lockfile"], opts);
-		else if (existsSync(join(wtDir, "package-lock.json"))) execFileSync("npm", ["ci"], opts);
-		else return;
-		note(`node_modules installed from lockfile in ${Date.now() - t0}ms`);
-	} catch (e) {
-		try {
-			note(`node_modules provisioning failed: ${e.message}`);
-		} catch {}
-	}
-}
-/** Commits the branch collected on top of its base. */
-function commitsSince(dir, base) {
-	try {
-		return parseInt(git(dir, [
-			"rev-list",
-			"--count",
-			`${base}..HEAD`
-		]), 10) || 0;
-	} catch {
-		return 0;
-	}
-}
-/**
-* Record the worktree result in the status file: branch and commit count on
-* success, the worktree cleaned up on failure. Returns the updated status.
-*/
-function recordWorktree(logDir, status, info, ok) {
-	const s = { ...status };
-	if (ok) {
-		s.branch = info.branch;
-		s.commits = commitsSince(info.dir, info.base);
-		s.worktreeDir = info.dir;
-		s.worktreeBase = info.base;
-		s.worktreeSnapshot = info.snapshot;
-	} else if (safeCommitsSince(info.dir, info.base) > 0) {
-		s.branch = info.branch;
-		s.commits = commitsSince(info.dir, info.base);
-		s.worktreeDir = info.dir;
-		s.worktreeBase = info.base;
-		s.worktreeSnapshot = info.snapshot;
-	} else {
-		removeWorktree(s.cwd, info.dir, true);
-		try {
-			git(s.cwd, [
-				"branch",
-				"-D",
-				info.branch
-			]);
-		} catch {}
-		s.branch = null;
-		s.worktreeDir = null;
-		s.worktreeBase = null;
-		s.commits = null;
-		s.worktreeSnapshot = null;
-	}
-	saveStatus(logDir, s);
-	invalidatePendingCache(logDir, s.cwd);
-	return s;
-}
-function safeCommitsSince(dir, base) {
-	try {
-		return commitsSince(dir, base);
-	} catch {
-		return 0;
-	}
-}
-/**
-* Salvage for an exit path (run finaliser, kill signal): commit whatever the
-* worker left uncommitted, log WORKER-SALVAGE, never throw. Bounded by
-* `timeoutMs` per git call. Returns the committed paths.
-*/
-function salvageOnExit(ledger, id, label, wtDir, timeoutMs) {
-	try {
-		const { committed, skipped } = salvageUncommitted(wtDir, label, timeoutMs);
-		if (committed.length) appendLedger(ledger, "WORKER-SALVAGE", {
-			id,
-			paths: committed.join(","),
-			skipped: skipped.length
-		});
-		if (skipped.length) appendLedger(ledger, "WORKER-NOTE", {
-			id,
-			note: `salvage skipped: ${skipped.join("; ")}`
-		});
-		return committed;
-	} catch (e) {
-		try {
-			appendLedger(ledger, "WORKER-NOTE", {
-				id,
-				note: `salvage failed: ${e.message}`
-			});
-		} catch {}
-		return [];
-	}
-}
-/** Remove a worktree directory from git's books and the filesystem. */
-function removeWorktree(cwd, dir, force) {
-	try {
-		git(cwd, [
-			"worktree",
-			"remove",
-			...force ? ["--force"] : [],
-			dir
-		]);
-		return;
-	} catch {}
-	if (existsSync(dir)) try {
-		rmSync(dir, {
-			recursive: true,
-			force: true
-		});
-		git(cwd, ["worktree", "prune"]);
-	} catch {}
-}
-/**
-* Tracked changes (staged or not) plus untracked files — everything a
-* `git add -A` in `wtDir` would commit. The same two calls the old patch
-* carry used; name-only, not porcelain: a worktree-only change renders as
-* " M path" and the shared git() helper trims that leading space away.
-*/
-function uncommittedPaths(wtDir, timeoutMs) {
-	const tracked = git(wtDir, [
-		"diff",
-		"--name-only",
-		"HEAD"
-	], timeoutMs).split("\n").filter(Boolean);
-	const untracked = git(wtDir, [
-		"ls-files",
-		"--others",
-		"--exclude-standard"
-	], timeoutMs).split("\n").filter(Boolean);
-	return [...tracked, ...untracked];
-}
-/**
-* True when `wtDir`/`relPath` is a symlink whose target resolves outside
-* `wtDir` — e.g. a worker's `node_modules -> <main checkout>/node_modules`
-* convenience link. A `.gitignore` using `dir/` (directories only) does not
-* ignore such a link, so it turns up as untracked; staging and merging it
-* lets git replace the real directory on the other side with a symlink to
-* itself. Never a candidate for salvage.
-*/
-function symlinkEscapesWorktree(wtDir, relPath) {
-	const full = join(wtDir, relPath);
-	let stat;
-	try {
-		stat = lstatSync(full);
-	} catch {
-		return false;
-	}
-	if (!stat.isSymbolicLink()) return false;
-	const target = readlinkSync(full);
-	const resolvedTarget = isAbsolute(target) ? target : resolve(dirname(full), target);
-	const realTarget = existsSync(resolvedTarget) ? realpathSync(resolvedTarget) : resolvedTarget;
-	const realWtDir = realpathSync(wtDir);
-	return realTarget !== realWtDir && !realTarget.startsWith(realWtDir + sep);
-}
-/**
-* Commit a worktree's uncommitted changes to its branch so the merge carries
-* them. `git merge` only moves committed work, so a worker that stopped
-* without committing would lose its edits to `worktree remove` — exactly
-* what happened live on 2026-09-17. Returns the salvaged paths, empty when
-* the worktree is clean. A symlink pointing outside the worktree (see
-* `symlinkEscapesWorktree`) is never staged; it is left on disk and reported
-* as skipped instead. A failed commit throws with the worktree untouched:
-* its edits are still on disk, so nothing is lost.
-*/
-function salvageUncommitted(wtDir, label, timeoutMs) {
-	const paths = uncommittedPaths(wtDir, timeoutMs);
-	if (!paths.length) return {
-		committed: [],
-		skipped: []
-	};
-	const skipped = [];
-	const missing = new Set(git(wtDir, ["ls-files", "--deleted"], timeoutMs).split("\n").filter(Boolean));
-	const toStage = [];
-	for (const p of paths) if (missing.has(p)) skipped.push(`${p} (missing, not committed)`);
-	else if (symlinkEscapesWorktree(wtDir, p)) skipped.push(`symlink ${p} -> ${readlinkSync(join(wtDir, p))} (points outside the worktree)`);
-	else toStage.push(p);
-	if (!toStage.length) return {
-		committed: [],
-		skipped
-	};
-	try {
-		git(wtDir, [
-			"add",
-			"--ignore-removal",
-			"--",
-			".",
-			...paths.filter((p) => !toStage.includes(p)).map((p) => `:(exclude,literal)${p}`)
-		], timeoutMs);
-		const deleted = git(wtDir, [
-			"diff",
-			"--cached",
-			"--diff-filter=D",
-			"--name-only"
-		], timeoutMs).split("\n").filter(Boolean);
-		if (deleted.length > MAX_SALVAGE_DELETES) {
-			git(wtDir, ["reset", "-q"], timeoutMs);
-			throw new Error(`salvage would delete ${deleted.length} tracked files (${deleted.slice(0, 5).join(", ")}, ...), refused`);
-		}
-		git(wtDir, [
-			"commit",
-			"-m",
-			`salvaged: ${label}`
-		], timeoutMs);
-	} catch (e) {
-		throw new Error(`cannot salvage the uncommitted changes in ${wtDir} — ${e.message}; nothing was lost: commit them there by hand, then re-run merge`);
-	}
-	return {
-		committed: toStage,
-		skipped
-	};
-}
-/** A salvage commit that deletes more tracked files than this is refused. */
-const MAX_SALVAGE_DELETES = 5;
-/**
-* The dirty paths of a checkout, parsed from `git status --porcelain -z`:
-* NUL-separated (a path with a newline in it cannot corrupt the parse),
-* rename entries contribute both sides, and any quoting is stripped.
-*/
-function dirtyPaths(cwd) {
-	const fields = execFileSync("git", [
-		"-C",
-		cwd,
-		"status",
-		"--porcelain",
-		"-z"
-	], {
-		encoding: "utf8",
-		timeout: 3e4,
-		stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		]
-	}).split("\0");
-	const strip = (p) => p.startsWith("\"") && p.endsWith("\"") ? p.slice(1, -1) : p;
-	const out = [];
-	for (let i = 0; i < fields.length; i++) {
-		const f = fields[i];
-		if (!f || f.length < 4 || f.charAt(2) !== " ") continue;
-		out.push(strip(f.slice(3)));
-		const xy = f.slice(0, 2);
-		if (xy.includes("R") || xy.includes("C")) {
-			const orig = fields[i + 1];
-			if (orig && orig.charAt(2) !== " ") {
-				out.push(strip(orig));
-				i += 1;
-			}
-		}
-	}
-	return out;
-}
-/**
-* Refuse the merge when the original checkout is dirty in paths the branch
-* touches: the merge would overwrite those edits or fail on them, either way
-* leaving a half-state. No merge is made, the worktree stays.
-*/
-function assertNoDirtyOverlap(cwd, incoming, id, branch) {
-	const dirty = new Set(dirtyPaths(cwd));
-	const overlap = [...new Set(incoming)].filter((p) => dirty.has(p)).sort();
-	if (!overlap.length) return;
-	throw new Error(`worker ${id}: the checkout ${cwd} has uncommitted changes in paths ${branch} touches: ${overlap.join(", ")}. Commit or stash them in the checkout, then re-run: pai worker merge ${id}. No merge was made; the worktree was kept.`);
-}
-/**
-* Never remove a worktree that still holds uncommitted changes — except a
-* symlink escaping the worktree (see `symlinkEscapesWorktree`): it was
-* deliberately left uncommitted by `salvageUncommitted`, and deleting the
-* link itself touches nothing outside the worktree.
-*/
-function assertWorktreeClean(wtDir, id) {
-	const leftover = uncommittedPaths(wtDir).filter((p) => !symlinkEscapesWorktree(wtDir, p));
-	if (leftover.length) throw new Error(`worker ${id}: the worktree ${wtDir} still holds uncommitted changes (${leftover.join(", ")}) — it was NOT removed; commit or copy them by hand, then re-run merge`);
-}
-/** Blob sha of `path` at `rev` in `cwd`, or null when it does not exist there. */
-function blobAt(cwd, rev, path) {
-	try {
-		return git(cwd, [
-			"rev-parse",
-			"--verify",
-			"-q",
-			`${rev}:${path}`
-		]);
-	} catch {
-		return null;
-	}
-}
-/** Blob sha of `path` as it sits on disk in `cwd`, or null when it is absent. */
-function workingBlob(cwd, path) {
-	if (!existsSync(join(cwd, path))) return null;
-	try {
-		return git(cwd, [
-			"hash-object",
-			"--",
-			path
-		]);
-	} catch {
-		return null;
-	}
-}
-/**
-* Refuse a snapshot merge when the checkout differs from the snapshot the
-* worker branched from, for any path the branch touched: the operator edited
-* it, or it was created/deleted since — applying the branch's diff on top
-* would silently discard that. Absent-in-both counts as equal.
-*/
-function assertNoSnapshotDrift(cwd, snapshot, paths, id) {
-	const drifted = paths.filter((p) => blobAt(cwd, snapshot, p) !== workingBlob(cwd, p)).sort();
-	if (!drifted.length) return;
-	throw new Error(`worker ${id}: the checkout ${cwd} has changed since the worktree's snapshot in paths the branch touches: ${drifted.join(", ")}. Resolve by hand, then re-run: pai worker merge ${id}. No merge was made; the worktree was kept.`);
-}
-/**
-* `pai worker merge <id>` for a snapshot-based worktree (see `addWorktree`):
-* git's own merge only moves committed history, and the snapshot commit was
-* never on any branch reachable from `cwd`'s HEAD, so there is nothing to
-* `git merge` here. Instead the worker's own changes — `git diff --binary
-* <snapshot> <branch>` — are applied straight onto the checkout's working
-* tree as uncommitted edits, exactly like the uncommitted state the worker
-* started from. Works even if `cwd`'s HEAD moved since the snapshot: the
-* diff is applied to files, not merged into a tree.
-*/
-function mergeSnapshotWorker(logDir, id, st, noCommit = false) {
-	const snapshot = st.worktreeBase;
-	const branch = st.branch;
-	const worktreeDir = st.worktreeDir;
-	const salvage = existsSync(worktreeDir) ? salvageUncommitted(worktreeDir, st.label || UNLABELED) : {
-		committed: [],
-		skipped: []
-	};
-	if ((parseInt(git(st.cwd, [
-		"rev-list",
-		"--count",
-		`${snapshot}..${branch}`
-	]), 10) || 0) <= 0) throw new Error(`worker ${id}: branch ${branch} has no commits beyond its snapshot to merge. The worktree ${worktreeDir} was NOT removed — uncommitted work there would be destroyed. Commit it yourself, or drop everything with: pai worker discard ${id}`);
-	const changedPaths = git(st.cwd, [
-		"diff",
-		"--name-only",
-		snapshot,
-		branch
-	]).split("\n").filter(Boolean);
-	assertNoSnapshotDrift(st.cwd, snapshot, changedPaths, id);
-	const diff = execFileSync("git", [
-		"-C",
-		st.cwd,
-		"diff",
-		"--binary",
-		snapshot,
-		branch
-	], {
-		encoding: "utf8",
-		timeout: 3e4,
-		maxBuffer: 64 * 1024 * 1024
-	});
-	if (diff.trim()) try {
-		execFileSync("git", [
-			"-C",
-			st.cwd,
-			"apply",
-			"--binary"
-		], {
-			input: diff,
-			encoding: "utf8",
-			timeout: 3e4,
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			]
-		});
-	} catch (e) {
-		const err = e;
-		const why = (typeof err.stderr === "string" ? err.stderr : err.stderr?.toString("utf8")) || err.message || String(e);
-		throw new Error(`worker ${id}: git refused to apply ${branch}'s changes to ${st.cwd} — ${why.trim()}. The worktree ${worktreeDir} was kept: resolve by hand, then re-run merge`);
-	}
-	if (noCommit) return noCommitNextSteps(id, branch, worktreeDir, changedPaths);
-	removeWorktree(st.cwd, worktreeDir, true);
-	try {
-		git(st.cwd, [
-			"branch",
-			"-D",
-			branch
-		]);
-	} catch {}
-	saveStatus(logDir, {
-		...st,
-		merged: true
-	});
-	const base = `applied worker ${id}'s changes (branch ${branch}) to ${st.cwd} as uncommitted changes: ${changedPaths.join(", ")} (worktree removed, branch deleted)`;
-	const notes = [];
-	if (salvage.committed.length) notes.push(`salvaged ${salvage.committed.length} uncommitted change(s) onto the branch first: ${salvage.committed.join(", ")}`);
-	if (salvage.skipped.length) notes.push(`skipped ${salvage.skipped.join(", ")}`);
-	return notes.length ? `${base}; ${notes.join("; ")}` : base;
-}
-function noCommitNextSteps(id, branch, worktreeDir, paths) {
-	return `applied worker ${id}'s changes (branch ${branch}) to the checkout as uncommitted changes: ${paths.join(", ")}. Branch and worktree ${worktreeDir} were kept. Next: review (git diff), commit, then run: pai worker gc`;
-}
-/**
-* `merge --no-commit`: apply base..branch to the checkout with a 3-way
-* `git apply`, leaving the result uncommitted. On conflict the tree is left
-* as is (markers + unmerged index entries) and the conflicted paths are listed.
-*/
-function applyNoCommit(cwd, id, branch, worktreeDir, base, paths) {
-	const diff = execFileSync("git", [
-		"-C",
-		cwd,
-		"diff",
-		"--binary",
-		`${base}..${branch}`
-	], {
-		encoding: "buffer",
-		timeout: 3e4,
-		maxBuffer: 64 * 1024 * 1024,
-		env: {
-			...process.env,
-			LC_ALL: "C"
-		}
-	});
-	try {
-		execFileSync("git", [
-			"-C",
-			cwd,
-			"apply",
-			"--3way",
-			"--binary"
-		], {
-			input: diff,
-			timeout: 3e4,
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			],
-			env: {
-				...process.env,
-				LC_ALL: "C"
-			}
-		});
-	} catch (e) {
-		const conflicted = git(cwd, [
-			"diff",
-			"--name-only",
-			"--diff-filter=U"
-		]).split("\n").filter(Boolean);
-		const err = e;
-		const why = ((typeof err.stderr === "string" ? err.stderr : err.stderr?.toString("utf8")) || err.message || "").trim();
-		throw new Error(conflicted.length ? `worker ${id}: applying ${branch} conflicted in ${conflicted.join(", ")}. The tree was left for you: resolve those paths, review, commit; branch and worktree ${worktreeDir} were kept` : `worker ${id}: git refused to apply ${branch} to ${cwd} — ${why}. Nothing was changed; branch and worktree were kept`);
-	}
-	return noCommitNextSteps(id, branch, worktreeDir, paths);
-}
-/**
-* `pai worker verify <id>`: for every file the worker's branch (or its
-* refs/pai-archive/<id> archive once the branch is gone) changed since its
-* base, compare bytes with the working tree or `--against <ref>`.
-* identical = the target already holds the worker's version (a worker delete
-* counts as identical when the target lacks the file too); differs = other
-* bytes; missing = the worker's file is absent in the target; deleted = the
-* worker deleted it but the target still has it. ok = every file identical.
-*/
-function verifyWorker(logDir, id, opts = {}) {
-	const st = loadStatus(logDir, id);
-	if (!st) throw new Error(`no worker named "${id}"`);
-	const env = {
-		...process.env,
-		LC_ALL: "C"
-	};
-	const bytes = (args) => {
-		try {
-			return execFileSync("git", [
-				"-C",
-				st.cwd,
-				...args
-			], {
-				env,
-				timeout: 3e4,
-				maxBuffer: 256 * 1024 * 1024,
-				stdio: [
-					"ignore",
-					"pipe",
-					"pipe"
-				]
-			});
-		} catch {
-			return null;
-		}
-	};
-	const has = (ref) => bytes([
-		"rev-parse",
-		"--verify",
-		"-q",
-		`${ref}^{commit}`
-	]) !== null;
-	const ref = [`refs/heads/${worktreeBranch(id)}`, `refs/pai-archive/${id}`].find(has);
-	if (!ref) throw new Error(`worker ${id}: neither ${worktreeBranch(id)} nor refs/pai-archive/${id} exists in ${st.cwd}`);
-	const base = st.worktreeSnapshot && st.worktreeBase ? st.worktreeBase : git(st.cwd, [
-		"merge-base",
-		"HEAD",
-		ref
-	]);
-	const list = (bytes([
-		"diff",
-		"--name-status",
-		"--no-renames",
-		"-z",
-		`${base}..${ref}`
-	]) ?? Buffer.alloc(0)).toString("utf8").split("\0").filter(Boolean);
-	const files = [];
-	for (let i = 0; i + 1 < list.length; i += 2) {
-		const path = list[i + 1];
-		const deleted = list[i] === "D";
-		const target = opts.against ? bytes(["show", `${opts.against}:${path}`]) : existsSync(join(st.cwd, path)) ? readFileSync(join(st.cwd, path)) : null;
-		let state;
-		if (deleted) state = target ? "deleted" : "identical";
-		else {
-			const mine = bytes(["show", `${ref}:${path}`]);
-			state = !target ? "missing" : mine && mine.equals(target) ? "identical" : "differs";
-		}
-		files.push({
-			path,
-			state
-		});
-	}
-	return {
-		id,
-		ref,
-		base,
-		against: opts.against ?? "working tree",
-		files,
-		ok: files.every((f) => f.state === "identical")
-	};
-}
-/**
-* `pai worker merge <id>`: salvage whatever the worker left uncommitted onto
-* its branch, refuse when the original checkout is dirty in paths the branch
-* touches, merge with --no-ff (the merge commit names the worker), then
-* remove the worktree and delete the branch; the status gains `merged: true`.
-* A branch with nothing to merge is refused loudly — after salvage that
-* genuinely means it holds nothing, and reporting success there would
-* destroy the worktree for no gain.
-*/
-function mergeWorker(logDir, id, opts = {}) {
-	const st = mustHaveBranch(logDir, id);
-	if (st.merged) return `worker ${id}: branch ${st.branch} already merged`;
-	if (st.worktreeSnapshot) return mergeSnapshotWorker(logDir, id, st, opts.noCommit);
-	const salvage = existsSync(st.worktreeDir) ? salvageUncommitted(st.worktreeDir, st.label || UNLABELED) : {
-		committed: [],
-		skipped: []
-	};
-	if ((parseInt(git(st.cwd, [
-		"rev-list",
-		"--count",
-		`HEAD..${st.branch}`
-	]), 10) || 0) <= 0) throw new Error(`worker ${id}: branch ${st.branch} has no commits to merge. The worktree ${st.worktreeDir} was NOT removed — uncommitted work there would be destroyed. Commit it yourself, or drop everything with: pai worker discard ${id}`);
-	const mergeBase = git(st.cwd, [
-		"merge-base",
-		"HEAD",
-		st.branch
-	]);
-	const incomingPaths = git(st.cwd, [
-		"diff",
-		"--name-only",
-		mergeBase,
-		st.branch
-	]).split("\n").filter(Boolean);
-	assertNoDirtyOverlap(st.cwd, incomingPaths, id, st.branch);
-	if (opts.noCommit) return applyNoCommit(st.cwd, id, st.branch, st.worktreeDir, mergeBase, incomingPaths);
-	try {
-		git(st.cwd, [
-			"merge",
-			"--no-ff",
-			st.branch,
-			"-m",
-			`merge worker ${id} (${st.label})`
-		]);
-	} catch (e) {
-		throw new Error(`worker ${id}: git refused the merge of ${st.branch} — ${e.message}. The worktree ${st.worktreeDir} was kept: resolve the conflict, then re-run merge`);
-	}
-	if (existsSync(st.worktreeDir)) assertWorktreeClean(st.worktreeDir, id);
-	removeWorktree(st.cwd, st.worktreeDir, true);
-	let branchGone = true;
-	try {
-		git(st.cwd, [
-			"branch",
-			"-d",
-			st.branch
-		]);
-	} catch {
-		branchGone = false;
-	}
-	saveStatus(logDir, {
-		...st,
-		merged: true
-	});
-	invalidatePendingCache(logDir, st.cwd);
-	const base = `merged ${st.branch} into ${st.cwd} (worktree removed${branchGone ? ", branch deleted" : "; branch kept: git refused -d"})`;
-	const notes = [];
-	if (salvage.committed.length) notes.push(`salvaged ${salvage.committed.length} uncommitted change(s): ${salvage.committed.join(", ")}`);
-	if (salvage.skipped.length) notes.push(`skipped ${salvage.skipped.join(", ")}`);
-	return notes.length ? `${base}; ${notes.join("; ")}` : base;
-}
-/** `pai worker discard <id>`: drop worktree and branch, keep nothing. */
-function discardWorker(logDir, id) {
-	const st = mustHaveBranch(logDir, id);
-	removeWorktree(st.cwd, st.worktreeDir, true);
-	let branchGone = false;
-	try {
-		git(st.cwd, [
-			"branch",
-			"-D",
-			st.branch
-		]);
-		branchGone = true;
-	} catch {
-		branchGone = false;
-	}
-	saveStatus(logDir, {
-		...st,
-		branch: null,
-		worktreeDir: null,
-		worktreeBase: null,
-		worktreeSnapshot: null,
-		commits: null,
-		merged: false
-	});
-	invalidatePendingCache(logDir, st.cwd);
-	return `discarded worker ${id}: worktree removed${branchGone ? `, branch ${st.branch} deleted` : ""}`;
-}
-function mustHaveBranch(logDir, id) {
-	const st = loadStatus(logDir, id);
-	if (!st) throw new Error(`no worker named "${id}"`);
-	if (!st.branch || !st.worktreeDir) throw new Error(`worker ${id} has no worktree branch to ${st.branch ? "clean up" : "merge"} — it ran in place or its branch was already handled`);
-	return st;
-}
-/**
-* The paragraph a worktree run's system prompt gains: it may commit on its
-* own branch (the no-commit rule holds for the main branch only), it must not
-* merge or push itself, and the parent or operator merges.
-*/
-function worktreeSystemPrompt(id, branch, dir, snapshot = false) {
-	return [
-		"You are running in your own git worktree:",
-		`  ${dir} on branch ${branch} (worker id ${id}).`,
-		"Commit your work on that branch as you go (git add / git commit) — committing here is expected;",
-		"the no-commit rule applies to the main branch only, and this is not it.",
-		"Do not merge, rebase or push; the operator merges your branch back with `pai worker merge`.",
-		"Use ONLY relative paths inside the worktree, never absolute worktree paths — absolute paths break after merge and leak machine layout.",
-		...snapshot ? ["This worktree was branched from a snapshot that includes files the parent checkout had uncommitted at spawn time — not just its last commit."] : []
-	].join("\n");
-}
-/**
-* For headless runs WITHOUT a worktree: the worker shares the operator's
-* checkout with other in-flight workers, so a hook blocks git stash (except
-* list/show), reset, clean, checkout/restore of paths, switch, rebase and
-* merge — take baselines from measurements before editing, not from stash.
-*/
-function inPlaceSystemPrompt() {
-	return [
-		"You are running in the operator's shared git checkout, alongside other workers editing it at the same time.",
-		"A hook blocks git stash (except list/show), reset, clean, checkout/restore of files, switch, rebase and merge — take baselines from measurements taken before you edit, not from stashing.",
-		"Read-only git (status, diff, log, show, stash list) is fine."
-	].join("\n");
-}
-const GC_STAMP = "gc-last";
-/**
-* Archive worktrees of finished workers older than `olderThanHours` and
-* status-less orphan directories: uncommitted state is salvaged onto the
-* branch, the branch is x, the worktree is
-* removed. Nothing is deleted without a salvage first; a failed salvage skips
-* that worktree. Running workers are never touched. `dryRun` reports only.
-*/
-function gcWorktrees(logDir, olderThanHours = 24, dryRun = false, now = Date.now()) {
-	const cutoff = now - olderThanHours * 36e5;
-	const out = [];
-	const root = worktreesDir(logDir);
-	const known = /* @__PURE__ */ new Set();
-	const archive = (id, dir, st) => {
-		const target = `refs/pai-archive/${id}`;
-		if (dryRun) return void out.push({
-			id,
-			archive: target
-		});
-		try {
-			let repo;
-			try {
-				const raw = git(dir, ["rev-parse", "--git-common-dir"]);
-				repo = isAbsolute(raw) ? raw : resolve(dir, raw);
-			} catch {
-				throw new Error("not a git worktree");
-			}
-			const label = `archive: leftover state of worker ${id}`;
-			if (uncommittedPaths(dir).length) {
-				const res = salvageUncommitted(dir, label);
-				if (res.committed.length) git(dir, [
-					"commit",
-					"--amend",
-					"-q",
-					"-m",
-					label
-				]);
-				if (res.skipped.length && uncommittedPaths(dir).some((p) => !symlinkEscapesWorktree(dir, p))) throw new Error("uncommitted paths remain");
-			}
-			const src = worktreeBranch(id);
-			let hasBranch = true;
-			try {
-				git(repo, [
-					"rev-parse",
-					"--verify",
-					"-q",
-					`refs/heads/${src}`
-				]);
-			} catch {
-				hasBranch = false;
-			}
-			const tip = git(dir, ["rev-parse", "HEAD"]);
-			if (hasBranch) git(repo, [
-				"merge-base",
-				"--is-ancestor",
-				`refs/heads/${src}`,
-				tip
-			]);
-			git(repo, [
-				"update-ref",
-				target,
-				tip
-			]);
-			git(repo, [
-				"worktree",
-				"remove",
-				"--force",
-				dir
-			]);
-			if (hasBranch) git(repo, [
-				"branch",
-				"-D",
-				src
-			]);
-			if (st) saveStatus(logDir, {
-				...st,
-				branch: null,
-				worktreeDir: null,
-				archived: target
-			});
-			appendLedger(ledgerPath(logDir), "WORKER-GC", {
-				id,
-				archive: target
-			});
-			out.push({
-				id,
-				archive: target
-			});
-		} catch (e) {
-			out.push({
-				id,
-				skipped: e.message.split("\n")[0]
-			});
-		}
-	};
-	for (const st of loadStatuses(logDir)) {
-		known.add(st.id);
-		if (!st.worktreeDir || !existsSync(st.worktreeDir) || isLive(st)) continue;
-		let end = 0;
-		try {
-			end = statSync(statusPath(logDir, st.id)).mtimeMs;
-		} catch {
-			continue;
-		}
-		if (end > cutoff) continue;
-		archive(st.id, st.worktreeDir, st);
-	}
-	if (existsSync(root)) for (const ent of readdirSync(root, { withFileTypes: true })) {
-		if (!ent.isDirectory() || known.has(ent.name) || existsSync(statusPath(logDir, ent.name))) continue;
-		const dir = join(root, ent.name);
-		try {
-			if (statSync(dir).mtimeMs > cutoff) continue;
-		} catch {
-			continue;
-		}
-		archive(ent.name, dir, null);
-	}
-	if (!dryRun) for (const repo of new Set(loadStatuses(logDir).map((s) => s.cwd))) {
-		try {
-			git(repo, ["worktree", "prune"]);
-		} catch {}
-		invalidatePendingCache(logDir, repo);
-	}
-	return out;
-}
-/** Run `gcWorktrees` at most once per `everyMin` minutes (stamp file in the logDir). */
-function gcWorktreesThrottled(logDir, everyMin = 60, now = Date.now()) {
-	const stamp = join(logDir, GC_STAMP);
-	try {
-		if (now - statSync(stamp).mtimeMs < everyMin * 6e4) return null;
-	} catch {}
-	mkdirSync(logDir, { recursive: true });
-	writeFileSync(stamp, String(now), "utf8");
-	return gcWorktrees(logDir, 24, false, now);
-}
-
 //#endregion
 //#region src/workers/scope.ts
 /**
@@ -2577,183 +1010,100 @@ const PROFILE_NAME = "pai-worker";
 function dynamicProfilePath() {
 	return process.env.PAI_WORKER_PROFILE ?? join(homedir(), "Library", "Application Support", "iTerm2", "DynamicProfiles", "pai-worker.json");
 }
-const WORKER_SPLIT_SCRIPT = `on run(argv)
-    set targetID to item 1 of argv
-    set candList to item 2 of argv
-    set followCmd to item 3 of argv
-    set profileName to item 4 of argv
-    tell application id "com.googlecode.iterm2"
-        if not running then return "notrunning"
-        repeat with w in windows
-            repeat with t in tabs of w
-                repeat with s in sessions of t
-                    if id of s is targetID then
-                        -- sizing the new session would grow the whole window:
-                        -- pin the window's bounds now and restore them after
-                        -- the split, so the panes share the existing space.
-                        -- copy, never set: set stores the property
-                        -- reference lazily, so restoring it would re-read the
-                        -- post-split bounds instead of these — observed as the
-                        -- window jumping to the main display
-                        copy bounds of w to winBounds
-                        set sessIDs to {}
-                        repeat with other in sessions of t
-                            set end of sessIDs to (id of other as text)
-                        end repeat
-                        set lived to {}
-                        set splitS to missing value
-                        repeat with cid in my splitIds(candList)
-                            set cidText to (cid as text)
-                            if sessIDs contains cidText then
-                                set end of lived to cidText
-                                if splitS is missing value then
-                                    set splitS to first session of t whose id is cidText
-                                end if
-                            end if
-                        end repeat
-                        -- the follow command is part of the split itself: the
-                        -- pane is born already running it, so no text is ever
-                        -- typed into any session — a typing step raced the
-                        -- operator's keystrokes and could even land in the
-                        -- operator's own session
-                        if profileName is "" then
-                            if splitS is missing value then
-                                tell s
-                                    set newS to split vertically with default profile command followCmd
-                                end tell
-                            else
-                                tell splitS
-                                    set newS to split horizontally with default profile command followCmd
-                                end tell
-                            end if
-                        else
-                            if splitS is missing value then
-                                tell s
-                                    set newS to split vertically with profile profileName command followCmd
-                                end tell
-                            else
-                                tell splitS
-                                    set newS to split horizontally with profile profileName command followCmd
-                                end tell
-                            end if
-                        end if
-                        -- a split makes the new session the tab's active one:
-                        -- re-select the launching session so focus returns to
-                        -- where the operator was typing, never the new pane
-                        try
-                            select s
-                        end try
-                        try
-                            set bounds of w to winBounds
-                        end try
-                        set out to ""
-                        repeat with lid in lived
-                            set out to out & lid & ","
-                        end repeat
-                        return out & "|" & (id of newS as text)
-                    end if
-                end repeat
-            end repeat
-        end repeat
-    end tell
-    return "notfound"
-end run
-
-on splitIds(s)
-    set out to {}
-    if s is "" then return out
-    set prevDels to AppleScript's text item delimiters
-    set AppleScript's text item delimiters to ","
-    repeat with part in text items of s
-        set end of out to (part as text)
-    end repeat
-    set AppleScript's text item delimiters to prevDels
-    return out
-end splitIds`;
-const TAB_TTYS_SCRIPT = `on run(argv)
-    set targetID to item 1 of argv
-    tell application id "com.googlecode.iterm2"
-        if not running then return "notrunning"
-        repeat with w in windows
-            repeat with t in tabs of w
-                repeat with s in sessions of t
-                    if id of s is targetID then
-                        set ttys to {}
-                        repeat with other in sessions of t
-                            copy (tty of other) to end of ttys
-                        end repeat
-                        return ttys
-                    end if
-                end repeat
-            end repeat
-        end repeat
-    end tell
-    return "notfound"
-end run`;
-const WINDOW_BOUNDS_SCRIPT = `on run(argv)
-    set targetID to item 1 of argv
-    tell application id "com.googlecode.iterm2"
-        if not running then return "notrunning"
-        repeat with w in windows
-            repeat with t in tabs of w
-                repeat with s in sessions of t
-                    if id of s is targetID then
-                        copy bounds of w to winBounds
-                        set prevDels to AppleScript's text item delimiters
-                        set AppleScript's text item delimiters to ", "
-                        set out to winBounds as text
-                        set AppleScript's text item delimiters to prevDels
-                        return out
-                    end if
-                end repeat
-            end repeat
-        end repeat
-    end tell
-    return "notfound"
-end run`;
-const SPLIT_SCRIPT = `on run(argv)
-    set targetID to item 1 of argv
-    set followCmd to item 2 of argv
-    tell application id "com.googlecode.iterm2"
-        if not running then return "notrunning"
-        repeat with w in windows
-            repeat with t in tabs of w
-                repeat with s in sessions of t
-                    if id of s is targetID then
-                        -- the follow command is part of the split itself (see
-                        -- WORKER_SPLIT_SCRIPT): nothing is ever typed into a
-                        -- session afterwards
-                        tell s
-                            set newS to split vertically with default profile command followCmd
-                        end tell
-                        -- keep the tab's active session where it was (see
-                        -- WORKER_SPLIT_SCRIPT)
-                        try
-                            select s
-                        end try
-                        return "opened"
-                    end if
-                end repeat
-            end repeat
-        end repeat
-    end tell
-    return "notfound"
-end run`;
-/**
-* True for the transient "every window doesn't understand the count message"
-* (-1708) failure iTerm throws while enumerating windows during a race with
-* window/session churn — seen to succeed on immediate retry. No other error
-* matches: a retry here only re-runs the enumeration, before any split, so it
-* cannot double-create a pane.
-*/
-function isRetryableIterm2Error(stderr) {
-	return stderr.includes("every window doesn") && stderr.includes("(-1708)");
-}
-const OSASCRIPT_MAX_ATTEMPTS = 6;
-const OSASCRIPT_RETRY_DELAY_MS = 500;
-function runOsascriptOnce(script, args) {
+const FIND_SESSION = `function findSession(app, id) {
+    var ws = app.windows();
+    for (var i = 0; i < ws.length; i++) {
+        var ts = ws[i].tabs();
+        for (var j = 0; j < ts.length; j++) {
+            var ss = ts[j].sessions();
+            for (var k = 0; k < ss.length; k++) {
+                if (ss[k].id() === id) return { w: ws[i], t: ts[j], s: ss[k], all: ss };
+            }
+        }
+    }
+    return null;
+}`;
+const WORKER_SPLIT_SCRIPT = `${FIND_SESSION}
+function run(argv) {
+    var targetID = argv[0], candList = argv[1], followCmd = argv[2], profileName = argv[3];
+    var app = Application("iTerm2");
+    if (!app.running()) return "notrunning";
+    var f = findSession(app, targetID);
+    if (!f) return "notfound";
+    // sizing the new session would grow the whole window: pin the window's
+    // bounds now and restore them after the split, so the panes share the
+    // existing space
+    var winBounds = f.w.bounds();
+    var sessIDs = f.all.map(function (o) { return o.id(); });
+    var lived = [];
+    var splitS = null;
+    (candList === "" ? [] : candList.split(",")).forEach(function (cid) {
+        var at = sessIDs.indexOf(cid);
+        if (at < 0) return;
+        lived.push(cid);
+        if (!splitS) splitS = f.all[at];
+    });
+    // the follow command is part of the split itself: the pane is born already
+    // running it, so no text is ever typed into any session — a typing step
+    // raced the operator's keystrokes and could even land in the operator's
+    // own session
+    var newS;
+    if (!splitS) {
+        newS = profileName === ""
+            ? f.s.splitVerticallyWithDefaultProfile({ command: followCmd })
+            : f.s.splitVertically({ withProfile: profileName, command: followCmd });
+    } else {
+        newS = profileName === ""
+            ? splitS.splitHorizontallyWithDefaultProfile({ command: followCmd })
+            : splitS.splitHorizontally({ withProfile: profileName, command: followCmd });
+    }
+    // a split makes the new session the tab's active one: re-select the
+    // launching session so focus returns to where the operator was typing,
+    // never the new pane
+    try { f.s.select(); } catch (e) {}
+    try { f.w.bounds = winBounds; } catch (e) {}
+    return lived.map(function (l) { return l + ","; }).join("") + "|" + newS.id();
+}`;
+const TAB_TTYS_SCRIPT = `${FIND_SESSION}
+function run(argv) {
+    var app = Application("iTerm2");
+    if (!app.running()) return "notrunning";
+    var f = findSession(app, argv[0]);
+    if (!f) return "notfound";
+    return f.all.map(function (o) { return o.tty(); }).join(",");
+}`;
+const WINDOW_BOUNDS_SCRIPT = `${FIND_SESSION}
+function run(argv) {
+    var app = Application("iTerm2");
+    if (!app.running()) return "notrunning";
+    var f = findSession(app, argv[0]);
+    if (!f) return "notfound";
+    var b = f.w.bounds();
+    return [b.x, b.y, b.x + b.width, b.y + b.height].join(", ");
+}`;
+const SPLIT_SCRIPT = `${FIND_SESSION}
+function run(argv) {
+    var followCmd = argv[1];
+    var app = Application("iTerm2");
+    if (!app.running()) return "notrunning";
+    var f = findSession(app, argv[0]);
+    if (!f) return "notfound";
+    // the follow command is part of the split itself (see WORKER_SPLIT_SCRIPT):
+    // nothing is ever typed into a session afterwards
+    f.s.splitVerticallyWithDefaultProfile({ command: followCmd });
+    // keep the tab's active session where it was (see WORKER_SPLIT_SCRIPT)
+    try { f.s.select(); } catch (e) {}
+    return "opened";
+}`;
+/** Run a JXA script with argv. Rejects when osascript itself cannot run. */
+function osascript(script, args) {
 	return new Promise((resolve, reject) => {
-		const proc = spawn("osascript", ["-", ...args], { stdio: [
+		const proc = spawn("osascript", [
+			"-l",
+			"JavaScript",
+			"-",
+			...args
+		], { stdio: [
 			"pipe",
 			"pipe",
 			"pipe"
@@ -2771,15 +1121,6 @@ function runOsascriptOnce(script, args) {
 		proc.stdin.end();
 	});
 }
-/** Run an AppleScript with argv. Rejects when osascript itself cannot run. */
-async function osascript(script, args) {
-	let result = await runOsascriptOnce(script, args);
-	for (let attempt = 1; attempt < OSASCRIPT_MAX_ATTEMPTS && isRetryableIterm2Error(result.stderr); attempt++) {
-		await new Promise((r) => setTimeout(r, OSASCRIPT_RETRY_DELAY_MS));
-		result = await runOsascriptOnce(script, args);
-	}
-	return result;
-}
 function psOutput(format) {
 	try {
 		return execFileSync("ps", ["-axo", format], { encoding: "utf8" });
@@ -3023,37 +1364,28 @@ function dropEntry(logDir, e) {
 		writeFileSync(legacy, JSON.stringify(rest.map(({ scope: _s, ...x }) => x), null, 1), "utf8");
 	}
 }
-const LIST_SESSIONS_SCRIPT = `on run(argv)
-    set out to ""
-    tell application id "com.googlecode.iterm2"
-        if not running then return ""
-        repeat with w in windows
-            repeat with t in tabs of w
-                repeat with s in sessions of t
-                    set out to out & (id of s as text) & (ASCII character 9) & (tty of s as text) & (ASCII character 9) & (name of s as text) & linefeed
-                end repeat
-            end repeat
-        end repeat
-    end tell
-    return out
-end run`;
-const END_SESSION_SCRIPT = `on run(argv)
-    set targetID to item 1 of argv
-    tell application id "com.googlecode.iterm2"
-        if not running then return "notrunning"
-        repeat with w in windows
-            repeat with t in tabs of w
-                repeat with s in sessions of t
-                    if id of s is targetID then
-                        close s
-                        return "closed"
-                    end if
-                end repeat
-            end repeat
-        end repeat
-    end tell
-    return "notfound"
-end run`;
+const LIST_SESSIONS_SCRIPT = `function run(argv) {
+    var app = Application("iTerm2");
+    if (!app.running()) return "";
+    var out = "";
+    app.windows().forEach(function (w) {
+        w.tabs().forEach(function (t) {
+            t.sessions().forEach(function (s) {
+                out += s.id() + "\t" + s.tty() + "\t" + s.name() + "\n";
+            });
+        });
+    });
+    return out;
+}`;
+const END_SESSION_SCRIPT = `${FIND_SESSION}
+function run(argv) {
+    var app = Application("iTerm2");
+    if (!app.running()) return "notrunning";
+    var f = findSession(app, argv[0]);
+    if (!f) return "notfound";
+    f.s.close();
+    return "closed";
+}`;
 const realPaneOps = {
 	async listIterm() {
 		if (process.platform !== "darwin") return [];
@@ -3607,6 +1939,103 @@ async function handoffFromInside(logDir, env, payload, deps = {}) {
 	}), deps);
 }
 
+//#endregion
+//#region src/workers/wait-on.ts
+/**
+* wait-on.ts — bounded wait for a detached job, the worker alternative to a
+* long blocking foreground call (which starves operator messages and
+* supervision). Recipe: `nohup sh -c 'CMD; echo $? > /tmp/job.rc' > /tmp/job.log 2>&1 & echo $! > /tmp/job.pid`,
+* then `pai worker wait-on $(cat /tmp/job.pid) --log /tmp/job.log` until exit 0.
+*
+* Exit codes: 0 pid gone, 3 still running at --max, 2 pid never existed or not ours.
+*/
+const WAIT_DEFAULT_SECS = 110;
+const WAIT_CAP_SECS = 115;
+const POLL_MS = 2e3;
+const HEARTBEAT_MS = 2e4;
+/** Slack between the first observation and a process start time (ps lstart has 1 s resolution). */
+const REUSE_SLACK_MS = 2e3;
+const realDeps = {
+	probe(pid) {
+		try {
+			process.kill(pid, 0);
+			return "alive";
+		} catch (e) {
+			return e.code === "EPERM" ? "foreign" : "gone";
+		}
+	},
+	startTime(pid) {
+		try {
+			const t = Date.parse(execFileSync("ps", [
+				"-o",
+				"lstart=",
+				"-p",
+				String(pid)
+			], { encoding: "utf8" }).trim());
+			return Number.isFinite(t) ? t : null;
+		} catch {
+			return null;
+		}
+	},
+	now: () => Date.now(),
+	sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+	out: (l) => console.log(l)
+};
+const readLines = (file) => {
+	if (!file || !existsSync(file)) return [];
+	const t = readFileSync(file, "utf8");
+	return t === "" ? [] : t.replace(/\n$/, "").split("\n");
+};
+function rcOf(pid, log) {
+	for (const f of [
+		log && `${log}.rc`,
+		log && log.replace(/\.[^./]+$/, ".rc"),
+		`/tmp/${pid}.rc`
+	]) if (f && existsSync(f)) return readFileSync(f, "utf8").trim();
+	return null;
+}
+async function waitOn(o, d = realDeps) {
+	const maxMs = Math.min(o.maxSecs ?? WAIT_DEFAULT_SECS, WAIT_CAP_SECS) * 1e3;
+	const tail = o.tail ?? 20;
+	const t0 = d.now();
+	const baseLines = readLines(o.log).length;
+	const finish = () => {
+		const rc = rcOf(o.pid, o.log);
+		d.out(`pid ${o.pid} gone${rc !== null ? `, exit code ${rc}` : ""}`);
+		if (tail > 0) for (const l of readLines(o.log).slice(-tail)) d.out(l);
+		return 0;
+	};
+	if (!Number.isInteger(o.pid) || o.pid <= 0) {
+		d.out(`wait-on: invalid pid ${o.pid}`);
+		return 2;
+	}
+	const first = d.probe(o.pid);
+	if (first === "foreign") {
+		d.out(`wait-on: pid ${o.pid} is not owned by this user`);
+		return 2;
+	}
+	if (first === "gone") {
+		if (rcOf(o.pid, o.log) !== null || o.log && existsSync(o.log)) return finish();
+		d.out(`wait-on: pid ${o.pid} does not exist`);
+		return 2;
+	}
+	let nextBeat = t0 + HEARTBEAT_MS;
+	while (d.now() - t0 < maxMs) {
+		await d.sleep(Math.min(POLL_MS, Math.max(0, maxMs - (d.now() - t0))));
+		const st = d.startTime(o.pid);
+		if (d.probe(o.pid) !== "alive" || st !== null && st > t0 + REUSE_SLACK_MS) return finish();
+		if (d.now() >= nextBeat) {
+			d.out(`running ${Math.round((d.now() - t0) / 1e3)}s, log +${readLines(o.log).length - baseLines} lines`);
+			nextBeat += HEARTBEAT_MS;
+		}
+	}
+	d.out(`still running after ${Math.round((d.now() - t0) / 1e3)}s (pid ${o.pid}); call wait-on again`);
+	if (tail > 0) for (const l of readLines(o.log).slice(-tail)) d.out(l);
+	return 3;
+}
+/** The documented long-job recipe, quoted by the worker contract and every deny message. */
+const WAIT_RECIPE = "`nohup sh -c 'CMD; echo $? > /tmp/job.rc' > /tmp/job.log 2>&1 & echo $! > /tmp/job.pid`, then repeat `pai worker wait-on $(cat /tmp/job.pid) --log /tmp/job.log` (each call returns within 2 min; do other work between calls) until it exits 0";
+
 //#endregion
 //#region src/workers/agentish.ts
 /**
@@ -3894,8 +2323,8 @@ function fullContractPrompt(format) {
 		"Never sleep-poll: no `sleep N` over 60 seconds, anywhere in a command — standalone, after `&&`/`||`/",
 		"`;`/`|`, or inside a loop or subshell — and the sleeps of one command add up (`sleep 58; sleep 58` is",
 		"116 s). Ending your turn ends this process, so a background job gets no later wake-up here:",
-		"run_in_background is denied. Run the long command in the FOREGROUND with a Bash timeout up to 600000 ms",
-		"and split longer jobs into steps that each fit it.",
+		"run_in_background is denied. Foreground Bash calls stay under 2 min (longer ones block operator messages and supervision and are denied);",
+		`run a long job detached: ${WAIT_RECIPE}.`,
 		"Kill only processes you started, by PID (`cmd & echo $! > /tmp/x.pid`, then `kill $(cat /tmp/x.pid)`); never `pkill`/`killall`/`kill $(pgrep ...)` — other workers' command lines contain your spec text.",
 		...fileNotInlineBlock(),
 		"",
@@ -4581,7 +3010,7 @@ async function runWorker(opts) {
 		if (gc?.length) process.stderr.write(`pai worker: archived ${gc.length} leftover worktree(s) (pai worker gc)\n`);
 	} catch {}
 	if (opts.className === "plan" && !opts._planner) {
-		const { runPlanner } = await import("./planner-C-gzg7ye.mjs");
+		const { runPlanner } = await import("./planner-CspP59ya.mjs");
 		return runPlanner(opts);
 	}
 	const parent = launchParent(opts.parent);
@@ -5840,5 +4269,5 @@ function resultFromOutput(out) {
 }
 
 //#endregion
-export { setWorkerLabel as $, git as A, ageOf as B, itermUuid as C, workerInScope as D, sessionTag as E, pendingGate as F, isChatPane as G, contextLabel as H, pendingResults as I, loadStatuses as J, isLive as K, appendLedger as L, verifyWorker as M, worktreesDir as N, discardWorker as O, formatPending as P, saveStatus as Q, ledgerSummary as R, itermForClaudeSession as S, sessionMapPath as T, contextPercent as U, alive as V, elapsedOf as W, nowStamp as X, newWorkerId as Y, ownsPid as Z, markControlsHeld as _, describeMcp as _t, deadlineLabel as a, ensureProxyRunning as at, requestKill as b, handoffFromInside as c, probeQuota as ct, workerDepth as d, ensureNoMcpConfig as dt, waitForTerminalStatus as et, checkPaneForWorker as f, eventsPath as ft, clickrControlsArgv as g, projectLaunchConfig as gt, openPaneForWorker as h, pinNotices as ht, usageContextTokens as i, DEFAULT_PROXY_PORT as it, mergeWorker as j, gcWorktrees as k, readInbox as l, quotaSkipThreshold as lt, openFollowPane as m, workersLogDir as mt, runWorker as n, parseRunnerArgs as nt, parseWorkerReport as o, stopProxy as ot, closeEndedPanes as p, ledgerPath as pt, loadStatus as q, testProvider as r, shortText as rt, renderReport as s, clearCooldown as st, printResult as t, longInlinePromptHint as tt, sayToWorker as u, resolveTarget as ut, callerDescription as v, expandMcpNames as vt, resolveSession as w, currentTabKey as x, endLabel as y, UNLABELED as z };
-//# sourceMappingURL=run-ChlIbDJ0.mjs.map
+export { ensureProxyRunning as A, itermForClaudeSession as C, sessionTag as D, sessionMapPath as E, resolveTarget as F, pinNotices as I, projectLaunchConfig as L, clearCooldown as M, probeQuota as N, workerInScope as O, quotaSkipThreshold as P, describeMcp as R, currentTabKey as S, resolveSession as T, clickrControlsArgv as _, deadlineLabel as a, endLabel as b, waitOn as c, sayToWorker as d, workerDepth as f, openPaneForWorker as g, openFollowPane as h, usageContextTokens as i, stopProxy as j, DEFAULT_PROXY_PORT as k, handoffFromInside as l, closeEndedPanes as m, runWorker as n, parseWorkerReport as o, checkPaneForWorker as p, testProvider as r, renderReport as s, printResult as t, readInbox as u, markControlsHeld as v, itermUuid as w, requestKill as x, callerDescription as y, expandMcpNames as z };
+//# sourceMappingURL=run-BZNdpUGQ.mjs.map