@tekmidian/pai 0.42.0 → 0.42.2

package/dist/{chain-DGXNoTwc.mjs → run-CGXbhf2k.mjs}

@@ -1,6 +1,5 @@
-import { a as WorkersConfigError, h as resolveModelCapability, l as isModelCapability, m as readWorkersSection, o as assertProviderRunnable, p as providerKeyPath, s as classModelCapability } from "./config-DgzR5sfb.mjs";
-import { _ as workersLogDir, d as setCooldown, f as eventsPath, g as statusPath, h as panesDir, i as buildRunEnv, m as noMcpConfigPath, n as ensureProxyRunning, o as isQuotaFailure, p as ledgerPath, s as nextAutoProvider, t as DEFAULT_PROXY_PORT, u as resolveTarget } from "./server-Cp7tNzNC.mjs";
-import { S as stripPromptValues, _ as newWorkerId, a as resolveSpawnerSession, b as parseRunnerArgs, d as alive, g as loadStatuses, h as loadStatus, i as resolveSession, l as UNLABELED, m as describeTool, o as scopeKey, r as itermUuid, v as nowStamp, x as shortText, y as saveStatus } from "./scope-NIwCGxRI.mjs";
+import { _ as readWorkersSection, c as classModelCapability, f as isModelCapability, g as providerKeyPath, o as WorkersConfigError, s as assertProviderRunnable, v as resolveModelCapability } from "./config-_lQI_W08.mjs";
+import { _ as workersLogDir, d as setCooldown, f as ensureNoMcpConfig, g as statusPath, h as panesDir, i as buildRunEnv, m as ledgerPath, n as ensureProxyRunning, o as isQuotaFailure, p as eventsPath, s as nextAutoProvider, t as DEFAULT_PROXY_PORT, u as resolveTarget } from "./server-D4vAieF4.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";
@@ -8,6 +7,100 @@ import { connect, createServer } from "node:net";
 import { execFileSync, spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 
+//#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 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 === "--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 === "--append-system-prompt") callerSystemPrompt = true;
+			if (a.startsWith("--append-system-prompt=")) callerSystemPrompt = 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,
+		mcp,
+		allowedTools
+	};
+}
+/**
+* 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;
+}
+/** 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/ledger.ts
 /**
 * ledger.ts — the routing ledger, one append-only log for every worker event.
@@ -77,6 +170,265 @@ function ledgerSummary(path, scope, lastN = 15, now = /* @__PURE__ */ new Date()
 	};
 }
 
+//#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;
+}
+/** 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 tmp = `${path}.tmp`;
+	writeFileSync(tmp, JSON.stringify(status), "utf8");
+	renameSync(tmp, path);
+}
+/** 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;
+	}
+}
+function alive(pid) {
+	if (!pid || pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** "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`;
+}
+/** 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/scope.ts
+/**
+* scope.ts — which workers "belong" to the terminal asking about them.
+*
+* Two identities, in priority order:
+*
+*   1. AIBroker's session registry (~/.aibroker/session-names.json): iTerm
+*      session UUID → session name. The launching session's UUID is stored in
+*      each worker's status file as `session.id`, so every pane of a named
+*      session sees its workers — regardless of tab layout.
+*   2. The iTerm tab key (`w<window>t<tab>` prefix of ITERM_SESSION_ID): the
+*      original heuristic, kept as the fallback when no registry entry
+*      matches (AIBroker absent, unnamed session, non-iTerm terminal).
+*
+* If neither is available, viewers fall back to "all workers".
+*
+* A third case: workers spawned from a Claude Code Bash tool (the
+* orchestrator pattern) have neither — Claude Code exports no terminal or
+* session identity to its Bash children. Those record `spawnerSession`, the
+* orchestrator's claude session id bridged through the status line's
+* session map (see below), so their tab still claims them.
+*/
+const AIBROKER_REGISTRY = join(homedir(), ".aibroker", "session-names.json");
+/**
+* `w<window>t<tab>` prefix of an iTerm session id, "" if empty or malformed.
+* Panes split from the same tab share this prefix and differ only in `p<n>`.
+*/
+function tabKey(term) {
+	if (!term) return "";
+	const head = term.split("p", 1)[0];
+	const parts = head.slice(1).split("t");
+	if (head.startsWith("w") && parts.length === 2 && parts.every((p) => /^\d+$/.test(p))) return head;
+	return "";
+}
+/** Tab key of the iTerm tab this process runs in, "" if not inside iTerm2. */
+function currentTabKey(env = process.env) {
+	return tabKey(env.ITERM_SESSION_ID ?? "");
+}
+/** The iTerm UUID part of an ITERM_SESSION_ID (after the last colon). */
+function itermUuid(term) {
+	if (!term) return "";
+	return term.split(":").pop() ?? "";
+}
+/**
+* Resolve the AIBroker session for an ITERM_SESSION_ID. Reads the persistent
+* name registry (the same store `aibroker_rename` writes); returns null when
+* AIBroker is absent or the session is not in it — callers then use the tab
+* key, which is the pre-AIBroker behaviour.
+*/
+function resolveSession(term, registryPath = AIBROKER_REGISTRY) {
+	const uuid = itermUuid(term);
+	if (!uuid) return null;
+	let names;
+	try {
+		if (!existsSync(registryPath)) return null;
+		names = JSON.parse(readFileSync(registryPath, "utf8"));
+	} catch {
+		return null;
+	}
+	const name = names[uuid];
+	if (typeof name !== "string" || !name) return null;
+	return {
+		id: uuid,
+		name
+	};
+}
+/**
+* True when `worker` was launched from `term` (the terminal asking about it).
+* Session-id match first; the tab key only when no registry entry matched —
+* a session without a name keeps the tab-scoped behaviour it always had.
+*/
+function workerInScope(worker, term) {
+	if (!term) return false;
+	const uuid = itermUuid(term);
+	if (worker.session?.id && uuid) return worker.session.id === uuid;
+	return tabKey(worker.term) === tabKey(term) && tabKey(term) !== "";
+}
+/**
+* Registry key for pane files: the session id when AIBroker knows this
+* terminal, else the tab key, else the raw iTerm UUID.
+*/
+function scopeKey(term) {
+	const session = resolveSession(term);
+	if (session) return session.id;
+	return currentTabKey() || itermUuid(term);
+}
+/** `[Name]` when the worker has an AIBroker session name, else "". */
+function sessionTag(worker) {
+	return worker.session?.name ? `[${worker.session.name}]` : "";
+}
+/** How old a map entry may be for a spawn to adopt it (status lines refresh constantly while a session lives). */
+const SPAWNER_SESSION_TTL_MS = 10 * 6e4;
+/** Map entries not refreshed within this window are pruned on write. */
+const SESSION_MAP_PRUNE_MS = 60 * 6e4;
+function sessionMapPath(logDir) {
+	return join(logDir, "claude-session-map.json");
+}
+/**
+* The claude session a new run was spawned by, when it can be known: a run
+* inside another worker inherits its spawner (chain stages keep the
+* orchestrator's tab that way); otherwise a fresh map entry for `cwd`.
+*/
+function resolveSpawnerSession(logDir, cwd, env = process.env, now = Date.now()) {
+	const parentId = env.PAI_WORKER_ID;
+	if (parentId) {
+		const inherited = loadStatus(logDir, parentId)?.spawnerSession;
+		if (inherited) return inherited;
+	}
+	const path = sessionMapPath(logDir);
+	if (!existsSync(path) || !cwd) return null;
+	try {
+		const entry = JSON.parse(readFileSync(path, "utf8"))[cwd];
+		if (entry && entry.session && now - entry.ts < SPAWNER_SESSION_TTL_MS) return entry.session;
+	} catch {}
+	return null;
+}
+/**
+* The iTerm UUID a claude session last rendered its status line in, when the
+* map knows one: the freshest entry naming that session. This is the reverse
+* of resolveSpawnerSession — worker → orchestrator there, orchestrator →
+* terminal here — and it exists so daemon-side pushes (supervision) can reach
+* a session that has no iTerm identity of its own in any worker status.
+*/
+function itermForClaudeSession(logDir, claudeSession, now = Date.now()) {
+	const path = sessionMapPath(logDir);
+	if (!existsSync(path) || !claudeSession) return null;
+	let map;
+	try {
+		map = JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return null;
+	}
+	let best = null;
+	for (const e of Object.values(map)) {
+		if (e.session !== claudeSession || !e.term) continue;
+		if (now - e.ts >= SESSION_MAP_PRUNE_MS) continue;
+		if (!best || e.ts > best.ts) best = e;
+	}
+	const term = best?.term;
+	return term ? itermUuid(term) : null;
+}
+
 //#endregion
 //#region src/workers/pane.ts
 /**
@@ -87,10 +439,14 @@ function ledgerSummary(path, scope, lastN = 15, now = /* @__PURE__ */ new Date()
 * one splits the lowest live worker pane horizontally, so panes stack top to
 * bottom. The split never sizes the new session — that would grow the whole
 * window; instead the window's bounds are read before the split and restored
-* right after, so the panes share the space the window already had. A split
-* would also make the new session the tab's active one — the scripts re-select
-* the launching session right after, so a pane opening never steals the
-* keystrokes the operator is typing. Each
+* right after, so the panes share the space the window already had. The follow
+* command is part of the split itself — iTerm creates the new session already
+* running it — so no text is ever typed into any session afterwards; a separate
+* typing step raced the operator's keystrokes (focus briefly sits on the new
+* pane after a split, and in one observed failure the command landed in the
+* operator's own shell). A split still makes the new session the tab's active
+* one — the scripts re-select the launching session right after, so a pane
+* opening never steals the keystrokes the operator is typing. Each
 * pane runs `pai worker follow <id> --auto-exit <n>` under the `pai-worker`
 * dynamic profile (Close Sessions On End), so panes disappear by themselves.
 *
@@ -145,34 +501,35 @@ const WORKER_SPLIT_SCRIPT = `on run(argv)
                                 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
+                                    set newS to split vertically with default profile command followCmd
                                 end tell
                             else
                                 tell splitS
-                                    set newS to split horizontally with default profile
+                                    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
+                                    set newS to split vertically with profile profileName command followCmd
                                 end tell
                             else
                                 tell splitS
-                                    set newS to split horizontally with profile profileName
+                                    set newS to split horizontally with profile profileName command followCmd
                                 end tell
                             end if
                         end if
-                        tell newS
-                            write text followCmd
-                        end tell
                         -- a split makes the new session the tab's active one:
-                        -- re-select the launching session so keystrokes keep
-                        -- going where the operator was typing, not into the
-                        -- pane's chat prompt
+                        -- re-select the launching session so focus returns to
+                        -- where the operator was typing, never the new pane
                         try
                             select s
                         end try
@@ -253,11 +610,11 @@ const SPLIT_SCRIPT = `on run(argv)
             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
-                        end tell
-                        tell newS
-                            write text followCmd
+                            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)
@@ -490,6 +847,23 @@ function saveRegistry(path, reg) {
 	writeFileSync(tmp, JSON.stringify(reg, null, 1), "utf8");
 	renameSync(tmp, path);
 }
+/**
+* The command a worker pane runs: one exec-able line with no shell syntax —
+* iTerm's split command parameter execs without a shell (proven live: panes
+* survive `sleep 30` and a single-quoted `/bin/sh -c`, die instantly on
+* `export …; …` or a redirect), so the command must be one exec-able line.
+* Absolute node on the CLI entry file also sidesteps the panes' bare launchd
+* PATH (no pai, no node) and the `#!/usr/bin/env node` shebang.
+*/
+function followCommand(wid, autoExitSecs) {
+	return `${process.execPath} ${absoluteCliPath()} worker follow ${wid} --auto-exit ${autoExitSecs}`;
+}
+/** Absolute path of the running pai CLI; falls back to PATH lookup at spawn. */
+function absoluteCliPath() {
+	const argv1 = process.argv[1] ?? "";
+	if (argv1.endsWith("pai")) return argv1;
+	return "pai";
+}
 /** Open (or only report on) the stacked follow pane of one worker. */
 async function openPaneForWorker(logDir, config, wid, term) {
 	if (workerPaneOpen(wid)) return `pane for ${wid} already open`;
@@ -497,7 +871,7 @@ async function openPaneForWorker(logDir, config, wid, term) {
 	const regPath = join(panesDir(logDir), `${scopeKey(term)}.json`);
 	const reg = loadRegistry(regPath);
 	const profile = await followProfile(config.pane.fontSize);
-	const cmd = ` exec pai worker follow ${JSON.stringify(wid)} --auto-exit ${config.pane.autoExitSecs}`;
+	const cmd = followCommand(wid, config.pane.autoExitSecs);
 	const p = await osascript(WORKER_SPLIT_SCRIPT, [
 		uid,
 		[...reg].reverse().map((e) => e.session).join(","),
@@ -571,7 +945,7 @@ async function openFollowPane(logDir, _config, term, checkOnly) {
 	if (out === "notrunning") throw new Error("pai worker pane: iTerm2 is not running");
 	if ([...new Set(out.split(",").map((t) => t.trim()).filter(Boolean))].filter((t) => followTtys().has(t)).length > 0) return "follow pane already open";
 	if (checkOnly) return "no follow pane";
-	const s = await osascript(SPLIT_SCRIPT, [uid, " exec pai worker follow"]);
+	const s = await osascript(SPLIT_SCRIPT, [uid, `${process.execPath} ${absoluteCliPath()} worker follow`]);
 	const sout = s.stdout.trim();
 	if (sout === "opened") return "follow pane opened";
 	if (sout === "notfound") throw new Error("pai worker pane: no open iTerm2 session matches ITERM_SESSION_ID");
@@ -1627,8 +2001,12 @@ function codexInstalled() {
 *     demand, the provider name in the URL path); codex-engine providers run
 *     the Codex CLI.
 *   - headless (-p): strict empty MCP config unless the caller brings one or
-*     names servers via --mcp / a role (then a filtered <id>.mcp.json),
-*     PAI_WORKER=1 so PAI's per-session hooks leave it alone, the worker
+*     names servers via --mcp / a role (then a filtered <id>.mcp.json), the
+*     core tool grants the caller did not bring (a headless run cannot
+*     approve a permission-gated tool mid-flight — with no grant at all,
+*     claude drops the file/shell tools entirely and the worker is
+*     tool-blind), PAI_WORKER=1 so PAI's per-session hooks leave it alone,
+*     the worker
 *     contract appended to the system prompt, `--input-format stream-json`
 *     with the prompt as the first stdin user message (the operator socket
 *     can add more mid-run), stream-json mirroring (every line stamped `_ts`)
@@ -1641,15 +2019,6 @@ function codexInstalled() {
 * Auto-routed runs that die of a quota error before the first tool call are
 * restarted on the next provider in routing order (WORKER-REROUTE ledger line).
 */
-/** The strict empty MCP config for headless workers, written on demand. */
-function ensureNoMcpConfig(logDir) {
-	const path = noMcpConfigPath(logDir);
-	if (!existsSync(path)) {
-		mkdirSync(logDir, { recursive: true });
-		writeFileSync(path, "{ \"mcpServers\": {} }\n", "utf8");
-	}
-	return path;
-}
 /** A stream-json user message for the child's stdin. */
 function stdinUserMessage(text) {
 	return JSON.stringify({
@@ -1725,7 +2094,7 @@ async function runWorker(opts) {
 	const logDir = workersLogDir(config);
 	mkdirSync(logDir, { recursive: true });
 	if (opts.className === "plan" && !opts._planner) {
-		const { runPlanner } = await import("./planner-BLDJt3ZS.mjs");
+		const { runPlanner } = await import("./planner-BfEGcEs1.mjs");
 		return runPlanner(opts);
 	}
 	const parent = launchParent(opts.parent);
@@ -1784,6 +2153,19 @@ async function runWorker(opts) {
 		throw e;
 	}
 }
+/**
+* The core tools a headless run grants when the caller brings none of its
+* own. Permission-gated tools (Bash, Read, Write, …) are never offered to a
+* headless session that has no allow rule for them — the child starts with
+* only the tools that never ask (tool search, web, cron, tasks) and cannot
+* touch a file or shell (2026-09-18). A caller's own --allowedTools is a
+* deliberate restriction and passes through untouched.
+*/
+const DEFAULT_WORKER_TOOLS = "Read,Edit,Write,Bash,Grep,Glob";
+/** The --allowedTools args a headless run needs; [] when the caller granted. */
+function headlessToolGrants(allowedTools) {
+	return allowedTools.length ? [] : ["--allowedTools", DEFAULT_WORKER_TOOLS];
+}
 async function executeRun(a) {
 	const { config, logDir, target, model, label, parsed, noPane } = a;
 	const headless = parsed.headless;
@@ -1872,9 +2254,10 @@ async function executeRun(a) {
 		];
 	}
 	const restArgs = headless ? stripPromptValues(parsed.rest) : parsed.rest;
+	const toolArgs = headless ? headlessToolGrants(parsed.allowedTools) : [];
 	const cmd = ["claude"];
-	if (!parsed.callerModel) cmd.push("--model", model);
-	cmd.push(...mcpArgs, ...restArgs);
+	if (!parsed.callerModel && model) cmd.push("--model", model);
+	cmd.push(...mcpArgs, ...toolArgs, ...restArgs);
 	if (headless) {
 		cmd.push("--output-format", "stream-json", "--verbose", "--input-format", "stream-json");
 		if (!parsed.callerSystemPrompt) cmd.push("--append-system-prompt", WORKER_CONTRACT_PROMPT);
@@ -2410,161 +2793,5 @@ function resultFromOutput(out) {
 }
 
 //#endregion
-//#region src/workers/chain.ts
-/**
-* chain.ts — draft-then-implement chains: `--chain draft,implement[,review]`.
-*
-* The chain runs each stage as its own worker (own id, own pane, `parent` set
-* to the chain id), so `ps` shows the chain as a tree and every stage can be
-* followed, replayed and said to like any other worker:
-*
-*   - draft    turns the operator's brief into a full spec file under
-*              <logDir>/specs/<chain id>.md (goal, constraints, files likely
-*              touched, acceptance checks, verification commands);
-*   - any other stage (implement, plan, …) runs with that spec as its prompt
-*              and the original brief attached;
-*   - review   reads the spec and the working-tree diff and produces the
-*              structured report.
-*
-* A stage that fails (or a draft that produces no spec file) stops the chain;
-* the caller then writes the spec itself and re-runs without the draft stage.
-*/
-/** Where a chain's spec file lives: <logDir>/specs/<chain id>.md. */
-function specPathFor(logDir, chainId) {
-	return join(logDir, "specs", `${chainId}.md`);
-}
-/**
-* Replace the caller's -p value with `prompt`, dropping every existing
-* -p/--print pair first (two -p flags on one claude command line are an error,
-* so the chain must never leave the brief in place when swapping prompts).
-*/
-function swapPromptArg(claudeArgs, prompt) {
-	const out = [];
-	for (let i = 0; i < claudeArgs.length; i++) {
-		const a = claudeArgs[i];
-		if (a === "-p" || a === "--print") {
-			if (i + 1 < claudeArgs.length && !claudeArgs[i + 1].startsWith("-")) i += 1;
-			continue;
-		}
-		out.push(a);
-	}
-	out.push("-p", prompt);
-	return out;
-}
-function draftPrompt(brief, specPath) {
-	return [
-		"You are the DRAFT stage of a worker chain. Turn the operator's brief below into a full implementation spec and write it to",
-		specPath,
-		"with the Write tool.",
-		"",
-		"Use exactly these five sections as Markdown headings:",
-		"# Goal",
-		"# Constraints",
-		"# Files likely touched",
-		"# Acceptance checks",
-		"# Verification commands",
-		"",
-		"Read the repository first (Glob/Grep/Read) so the spec names real files and real commands. Do not implement anything.",
-		"",
-		"## Operator brief",
-		"",
-		brief
-	].join("\n");
-}
-function implementPrompt(brief, specPath, spec) {
-	return [
-		...spec ? [
-			"You are the IMPLEMENT stage of a worker chain. The draft stage wrote the spec below (also at " + specPath + "). Implement it exactly, then run the spec's verification commands before finishing.",
-			"",
-			"## Spec",
-			"",
-			spec
-		] : ["Implement the operator's brief below."],
-		"",
-		"## Operator brief",
-		"",
-		brief
-	].join("\n");
-}
-function reviewPrompt(brief, specPath, spec) {
-	return [
-		"You are the REVIEW stage of a worker chain. The implement stage just ran. Read the repository's diff (run `git diff` and `git status`; use `git diff --stat` for the overview) and check it against the spec's acceptance checks and verification commands — run the checks when they are cheap. Do not fix anything you find; report it.",
-		...spec ? [
-			"",
-			"## Spec (also at " + specPath + ")",
-			"",
-			spec
-		] : [],
-		"",
-		"## Operator brief",
-		"",
-		brief
-	].join("\n");
-}
-/** Run a chain of stages; returns the exit code of the first failed stage, 0 when all pass. */
-async function runChain(opts, deps = {}) {
-	const stages = opts.stages.map((s) => s.trim()).filter(Boolean);
-	if (!stages.length) throw new Error("--chain needs at least one class, e.g. --chain draft,implement");
-	const runStage = deps.runStage ?? runWorker;
-	const logDir = deps.logDir ?? workersLogDir(readWorkersSection().workers);
-	const chainId = newWorkerId();
-	const specPath = specPathFor(logDir, chainId);
-	mkdirSync(join(logDir, "specs"), { recursive: true });
-	const baseLabel = opts.label ?? shortText(opts.brief, 40);
-	appendLedger(ledgerPath(logDir), "WORKER-CHAIN", {
-		chain: chainId,
-		stages: stages.join(","),
-		label: baseLabel
-	});
-	opts.onChainStart?.(chainId);
-	let spec = null;
-	for (let i = 0; i < stages.length; i++) {
-		const stage = stages[i];
-		if (stage === "draft") spec = null;
-		else if (spec === null && existsSync(specPath)) spec = readFileSync(specPath, "utf8");
-		const prompt = stage === "draft" ? draftPrompt(opts.brief, specPath) : stage === "review" ? reviewPrompt(opts.brief, spec ? specPath : null, spec) : implementPrompt(opts.brief, spec ? specPath : null, spec);
-		process.stderr.write(`chain ${chainId}: stage ${i + 1}/${stages.length} ${stage} (spec: ${specPath})\n`);
-		const rc = await runStage({
-			className: opts.className ?? stage,
-			providerFlag: opts.providerFlag,
-			modelFlag: opts.modelFlag,
-			label: `${baseLabel} · ${stage}`,
-			noPane: opts.noPane,
-			mcpFlag: opts.mcpFlag,
-			claudeArgs: swapPromptArg(opts.claudeArgs, prompt),
-			cwd: opts.cwd,
-			parent: chainId,
-			stage,
-			quiet: opts.quiet
-		});
-		if (stage === "draft") {
-			if (!existsSync(specPath)) {
-				process.stderr.write(`chain ${chainId}: draft stage produced no spec at ${specPath} — stopping. Write the spec yourself and re-run without the draft stage.\n`);
-				appendLedger(ledgerPath(logDir), "WORKER-CHAIN-END", {
-					chain: chainId,
-					rc: rc !== 0 ? rc : 1,
-					failed: "draft"
-				});
-				return rc !== 0 ? rc : 1;
-			}
-			spec = readFileSync(specPath, "utf8");
-		}
-		if (rc !== 0) {
-			appendLedger(ledgerPath(logDir), "WORKER-CHAIN-END", {
-				chain: chainId,
-				rc,
-				failed: stage
-			});
-			return rc;
-		}
-	}
-	appendLedger(ledgerPath(logDir), "WORKER-CHAIN-END", {
-		chain: chainId,
-		rc: 0
-	});
-	return 0;
-}
-
-//#endregion
-export { openPaneForWorker as _, testProvider as a, renderReport as c, handoffFromInside as d, readInbox as f, openFollowPane as g, checkPaneForWorker as h, runWorker as i, discardWorker as l, workerDepth as m, swapPromptArg as n, describeMcp as o, sayToWorker as p, printResult as r, parseWorkerReport as s, runChain as t, mergeWorker as u, appendLedger as v, ledgerSummary as y };
-//# sourceMappingURL=chain-DGXNoTwc.mjs.map
+export { nowStamp as A, alive as C, loadStatus as D, isChatPane as E, ledgerSummary as M, parseRunnerArgs as N, loadStatuses as O, shortText as P, ageOf as S, contextPercent as T, itermForClaudeSession as _, parseWorkerReport as a, workerInScope as b, mergeWorker as c, sayToWorker as d, workerDepth as f, currentTabKey as g, openPaneForWorker as h, describeMcp as i, appendLedger as j, newWorkerId as k, handoffFromInside as l, openFollowPane as m, runWorker as n, renderReport as o, checkPaneForWorker as p, testProvider as r, discardWorker as s, printResult as t, readInbox as u, resolveSession as v, contextLabel as w, UNLABELED as x, sessionTag as y };
+//# sourceMappingURL=run-CGXbhf2k.mjs.map