@tekmidian/pai 0.42.4 → 0.42.6

package/dist/{run-D7K5UALn.mjs → run-DDdT9teG.mjs}

@@ -1,12 +1,163 @@
-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 { n as openRegistry, r as registryDbPath } from "./db-Ddns80yf.mjs";
+import { _ as providerKeyPath, b as resolveProviderKey, c as classModelCapability, f as isModelCapability, o as WorkersConfigError, s as assertProviderRunnable, v as readWorkersSection, y as resolveModelCapability } from "./config-DxMZjpvY.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-Ch99xt5K.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 { connect, createServer } from "node:net";
 import { execFileSync, spawn } from "node:child_process";
+import { connect, createServer } from "node:net";
 import { createInterface } from "node:readline";
 
+//#region src/workers/mcp.ts
+/**
+* mcp.ts — the MCP allowlist for headless workers.
+*
+* Headless workers start with NO MCP servers: every server definition is a
+* prompt-time tool inventory the model pays to know, and a worker that only
+* reads and edits files needs none of it. A run may opt in with `--mcp
+* name[,name…]`, a role carrying `"mcp": [...]`, or implicitly by naming
+* `mcp__server__tool` in --allowedTools (a grant without its server loaded is
+* a dead letter). Names may be single servers from ~/.claude.json's
+* `mcpServers` or `workers.mcpSets` set names, which expand to their member
+* list. The filtered config lands in
+* `<logDir>/<id>.mcp.json` and is passed with `--strict-mcp-config
+* --mcp-config` so exactly those servers load. MCP servers are chosen at
+* launch only — a mid-run `say` cannot add any.
+*
+* One name in that space is not a server at all: `claude-in-chrome` is the
+* Chrome native-host bridge, which no config file can load and which the
+* `--chrome` flag switches on instead. It is recognised here so a grant
+* naming it becomes that flag rather than an "unknown MCP server" rejection.
+*/
+/** ~/.claude.json — the user's MCP server definitions (top-level mcpServers). */
+const CLAUDE_JSON = join(homedir(), ".claude.json");
+/**
+* The browser bridge is not an MCP server. It rides the Chrome native-host
+* channel, so it never appears in `mcpServers`; a spawned claude has it off
+* and the `--chrome` flag switches it on. Tool grants naming it must
+* therefore neither resolve to a server nor be rejected as unknown — they
+* select a flag. See `grantsChrome`.
+*/
+const CHROME_SERVER = "claude-in-chrome";
+/**
+* True for a real server definition, false for anything else that happens to
+* sit under `mcpServers`.
+*
+* The vendor config is not ours and has been observed carrying non-server
+* entries under that key — tool-usage records keyed by tool name
+* (`Read`, `Bash`, `mcp__server__tool`, …). Those are not servers: handing
+* one to `--mcp-config` yields "invalid MCP server config", and listing one
+* as available invites a run that cannot work. A server has a `command` (or a
+* `url` for remote transports); an `mcp__…` key is a tool name whatever its
+* shape.
+*/
+function isServerDefinition(name, value) {
+	if (name.startsWith("mcp__")) return false;
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const v = value;
+	return typeof v.command === "string" && v.command.length > 0 || typeof v.url === "string" && v.url.length > 0;
+}
+function readMcpServers(claudeJson = CLAUDE_JSON) {
+	try {
+		if (!existsSync(claudeJson)) return {};
+		const servers = JSON.parse(readFileSync(claudeJson, "utf8")).mcpServers;
+		if (typeof servers !== "object" || servers === null || Array.isArray(servers)) return {};
+		const out = {};
+		for (const [name, value] of Object.entries(servers)) if (isServerDefinition(name, value)) out[name] = value;
+		return out;
+	} catch {
+		return {};
+	}
+}
+/**
+* True when any `--mcp` name or `--allowedTools` grant asks for the browser
+* bridge: the bare server name, `mcp__claude-in-chrome`, or any
+* `mcp__claude-in-chrome__<tool>`. The runner turns this into `--chrome` on
+* the claude argv.
+*/
+function grantsChrome(entries) {
+	for (const entry of entries) for (const name of entry.split(",").map((s) => s.trim()).filter(Boolean)) {
+		if (name === CHROME_SERVER) return true;
+		if (name === `mcp__${CHROME_SERVER}`) return true;
+		if (name.startsWith(`mcp__${CHROME_SERVER}__`)) return true;
+	}
+	return false;
+}
+/**
+* Split a `--mcp a,b,c` flag value (also accepts repeated flags already split
+* by the caller) and expand set names from workers.mcpSets.
+*/
+function expandMcpNames(names, config, claudeJson = CLAUDE_JSON) {
+	const available = readMcpServers(claudeJson);
+	const out = [];
+	for (const raw of names) for (const name of raw.split(",").map((s) => s.trim()).filter(Boolean)) {
+		if (name === CHROME_SERVER) continue;
+		if (name in config.mcpSets) {
+			for (const member of config.mcpSets[name]) if (!out.includes(member)) out.push(member);
+			continue;
+		}
+		if (!(name in available)) {
+			const sets = Object.keys(config.mcpSets);
+			throw new WorkersConfigError(`unknown MCP server "${name}". Available servers: ${Object.keys(available).join(", ") || "(none in ~/.claude.json)"}${sets.length ? `; sets: ${sets.join(", ")}` : ""}`);
+		}
+		if (!out.includes(name)) out.push(name);
+	}
+	return out;
+}
+/**
+* Derive server names from tool grants: every `mcp__<server>__<tool>` (or bare
+* `mcp__<server>`, or `mcp__<server>__*`) in an --allowedTools list names a
+* server the run expects to be loaded. A grant is a dead letter unless its
+* server is in the filtered config, so the runner treats these as implicit
+* --mcp names — and only these; non-mcp grants load nothing.
+*/
+function mcpServersFromToolGrants(tools) {
+	const out = [];
+	for (const entry of tools) for (const name of entry.split(",").map((s) => s.trim()).filter(Boolean)) {
+		if (!name.startsWith("mcp__")) continue;
+		const server = name.slice(5).split("__")[0];
+		if (server === CHROME_SERVER) continue;
+		if (server && !out.includes(server)) out.push(server);
+	}
+	return out;
+}
+/** Path of a run's filtered MCP config. */
+function runMcpConfigPath(logDir, id) {
+	return join(logDir, `${id}.mcp.json`);
+}
+/**
+* Write a config containing only `names` (already expanded) and return its
+* path. Unknown names fail fast with the available list.
+*/
+function writeMcpConfig(logDir, id, names, claudeJson = CLAUDE_JSON) {
+	const available = readMcpServers(claudeJson);
+	const unknown = names.filter((n) => !(n in available));
+	if (unknown.length) throw new WorkersConfigError(`unknown MCP server(s): ${unknown.join(", ")}. Available: ${Object.keys(available).join(", ") || "(none in ~/.claude.json)"}`);
+	const servers = {};
+	for (const n of names) servers[n] = available[n];
+	const path = runMcpConfigPath(logDir, id);
+	if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
+	writeFileSync(path, JSON.stringify({ mcpServers: servers }, null, 2) + "\n", "utf8");
+	return path;
+}
+/** `pai worker mcp list`: the servers and sets a run could name. */
+function describeMcp(config, claudeJson = CLAUDE_JSON) {
+	const servers = Object.keys(readMcpServers(claudeJson));
+	const lines = [];
+	if (servers.length) {
+		lines.push(`servers (~/.claude.json):`);
+		for (const s of servers) lines.push(`  ${s}`);
+	} else lines.push(`no MCP servers defined in ~/.claude.json`);
+	const sets = Object.entries(config.mcpSets);
+	if (sets.length) {
+		lines.push(`sets (workers.mcpSets):`);
+		for (const [name, members] of sets) lines.push(`  ${name} = ${members.join(", ")}`);
+	}
+	lines.push(`usage: pai worker run --mcp <name>[,<name>…] -p '<task>'`);
+	return lines;
+}
+
+//#endregion
 //#region src/workers/args.ts
 function parseRunnerArgs(argv) {
 	let prompt = null;
@@ -16,6 +167,7 @@ function parseRunnerArgs(argv) {
 	let callerModel = false;
 	let callerMcpConfig = false;
 	let callerSystemPrompt = false;
+	let callerTools = false;
 	const mcp = [];
 	const allowedTools = [];
 	let i = 0;
@@ -61,6 +213,8 @@ function parseRunnerArgs(argv) {
 			if (a.startsWith("--mcp-config=")) callerMcpConfig = true;
 			if (a === "--append-system-prompt") callerSystemPrompt = true;
 			if (a.startsWith("--append-system-prompt=")) callerSystemPrompt = 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);
 		}
@@ -74,6 +228,7 @@ function parseRunnerArgs(argv) {
 		callerModel,
 		callerMcpConfig,
 		callerSystemPrompt,
+		callerTools,
 		mcp,
 		allowedTools
 	};
@@ -94,82 +249,23 @@ function stripPromptValues(argv) {
 	}
 	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/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/status.ts
 /**
@@ -228,13 +324,47 @@ function newWorkerId(d = /* @__PURE__ */ new Date(), pid = process.pid) {
 	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 tmp = `${path}.tmp`;
-	writeFileSync(tmp, JSON.stringify(status), "utf8");
-	renameSync(tmp, path);
+	const baseline = firstWrittenLabel.get(status.id);
+	if (baseline === void 0) firstWrittenLabel.set(status.id, status.label);
+	else if (status.label === baseline) {
+		const onDisk = loadStatus(logDir, status.id);
+		if (onDisk && onDisk.label !== status.label) status.label = onDisk.label;
+	}
+	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) {
@@ -257,6 +387,20 @@ function loadStatus(logDir, id) {
 		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 {
@@ -286,6 +430,76 @@ function describeTool(name, inp) {
 	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/scope.ts
 /**
@@ -1626,14 +1840,28 @@ const OPERATOR_MARK = "[operator]";
 /** Appended to the caller's system prompt on every headless run (2h). */
 const WORKER_CONTRACT_PROMPT = [
 	"You are a headless implementation worker, run non-interactively by an orchestrating session.",
+	"You are the worker: this task is yours to finish in this process. Never hand your whole task to a",
+	"single child worker and step back — that is delegation, not work. Child workers are for two things",
+	"only: (1) PARALLELISING independent parts of your task, each part a self-contained spec; (2) CHEAPER",
+	"bounded sub-tasks — probes, renders, test runs, lookups — run one tier down with --class spotcheck or",
+	"--class simple. Always pin --provider anthropic on children.",
+	"You own your children's results: run them in the foreground or poll until each has finished, read",
+	"their result, verify it, and fold it into your own report. When your turn ends this run ends and any",
+	"running child is killed, so never end with a child still running.",
+	"Ending your turn ends this run. There is no later wake-up: never call ScheduleWakeup, never say you",
+	"will pick something up later, never leave a background command as your final action. Finish, then",
+	"report.",
 	"No narration, no timestamps, no greetings, no summaries of what you read; act, verify, then stop.",
 	"Your ONE final message is a JSON object and nothing else — no prose before or after, no code fence:",
 	"{\"changed\":[{\"path\":\"…\",\"summary\":\"…\"}],\"commands\":[\"…\"],\"checks\":[{\"name\":\"…\",\"ok\":true,\"detail\":\"…\"}],\"open\":[\"…\"],\"notes\":\"one line\"}",
 	"changed: files you touched (path + one-line summary). commands: the commands that verify the work.",
 	"checks: each with ok true/false and the evidence in detail. open: what you could not finish, if anything.",
 	"notes: one line, the headline a reviewer reads first.",
-	"Never write shell heredocs — write the script to a file with the Write tool, then run it",
-	"(heredocs fail silently or get swallowed).",
+	"NEVER put a multi-line or quoted payload inline in a shell command — no heredocs (<<EOF), no long",
+	"-p '…' specs for child workers, no inline JSON, no inline scripts. ALWAYS write it to a file with",
+	"the Write tool first and pass the file: -p \"$(cat spec.txt)\", --file spec.txt, or < spec.txt.",
+	"Inline quoting fails silently or dies with a parse error and burns a worker launch; there are no",
+	"exceptions.",
 	"Never inline code one-liners (python3 -c, node -e, ruby -e and friends) — the permission layer",
 	"denies them (\"ztk: command denied by permission rules\"); write the script to a file with the",
 	"Write tool and run it (python3 script.py), or use jq for JSON inspection.",
@@ -1717,104 +1945,56 @@ function relShort(p, cwd) {
 }
 
 //#endregion
-//#region src/workers/mcp.ts
+//#region src/workers/project-config.ts
 /**
-* mcp.ts — the MCP allowlist for headless workers.
+* project-config.ts — the project registry's optional launch pin, read for
+* the interactive branch of run.ts only: which MCP servers and built-in
+* tools a project's supervisor session (`pai worker run`, no -p) loads. Set
+* with `pai project mcp` / `pai project tools` (src/cli/commands/project/
+* session-config.ts), stored in the same `projects.session_config` JSON
+* column as the rest of a project's launch config. Unset = today's
+* behavior: every server, every tool.
 *
-* Headless workers start with NO MCP servers: every server definition is a
-* prompt-time tool inventory the model pays to know, and a worker that only
-* reads and edits files needs none of it. A run may opt in with `--mcp
-* name[,name…]`, a role carrying `"mcp": [...]`, or implicitly by naming
-* `mcp__server__tool` in --allowedTools (a grant without its server loaded is
-* a dead letter). Names may be single servers from ~/.claude.json's
-* `mcpServers` or `workers.mcpSets` set names, which expand to their member
-* list. The filtered config lands in
-* `<logDir>/<id>.mcp.json` and is passed with `--strict-mcp-config
-* --mcp-config` so exactly those servers load. MCP servers are chosen at
-* launch only — a mid-run `say` cannot add any.
+* A standalone SQL lookup rather than importing the CLI's detectProject:
+* workers/ is a dependency of cli/, not the other way around.
 */
-/** ~/.claude.json — the user's MCP server definitions (top-level mcpServers). */
-const CLAUDE_JSON = join(homedir(), ".claude.json");
-function readMcpServers(claudeJson = CLAUDE_JSON) {
-	try {
-		if (!existsSync(claudeJson)) return {};
-		const servers = JSON.parse(readFileSync(claudeJson, "utf8")).mcpServers;
-		if (typeof servers !== "object" || servers === null || Array.isArray(servers)) return {};
-		return servers;
-	} catch {
-		return {};
-	}
+function asStringArray(v) {
+	if (!Array.isArray(v)) return void 0;
+	const out = v.filter((x) => typeof x === "string");
+	return out.length ? out : void 0;
 }
 /**
-* Split a `--mcp a,b,c` flag value (also accepts repeated flags already split
-* by the caller) and expand set names from workers.mcpSets.
+* The launch config of the project whose root_path is `cwd` or an ancestor
+* of it (longest match wins) — null when no registered project covers it,
+* or when the matching project has no mcp/tools pin set. `dbPath` is
+* injectable for tests; production callers take the default.
 */
-function expandMcpNames(names, config, claudeJson = CLAUDE_JSON) {
-	const available = readMcpServers(claudeJson);
-	const out = [];
-	for (const raw of names) for (const name of raw.split(",").map((s) => s.trim()).filter(Boolean)) {
-		if (name in config.mcpSets) {
-			for (const member of config.mcpSets[name]) if (!out.includes(member)) out.push(member);
-			continue;
-		}
-		if (!(name in available)) {
-			const sets = Object.keys(config.mcpSets);
-			throw new WorkersConfigError(`unknown MCP server "${name}". Available servers: ${Object.keys(available).join(", ") || "(none in ~/.claude.json)"}${sets.length ? `; sets: ${sets.join(", ")}` : ""}`);
+function projectLaunchConfig(cwd, dbPath = registryDbPath()) {
+	const target = resolve(cwd);
+	const db = openRegistry(dbPath);
+	try {
+		const rows = db.prepare(`SELECT root_path, session_config FROM projects WHERE status != 'archived' ORDER BY LENGTH(root_path) DESC`).all();
+		for (const row of rows) {
+			const root = resolve(row.root_path);
+			if (target !== root && !target.startsWith(root + "/")) continue;
+			if (!row.session_config) return null;
+			let parsed;
+			try {
+				parsed = JSON.parse(row.session_config);
+			} catch {
+				return null;
+			}
+			const mcp = asStringArray(parsed.mcp);
+			const tools = asStringArray(parsed.tools);
+			return mcp || tools ? {
+				mcp,
+				tools
+			} : null;
 		}
-		if (!out.includes(name)) out.push(name);
-	}
-	return out;
-}
-/**
-* Derive server names from tool grants: every `mcp__<server>__<tool>` (or bare
-* `mcp__<server>`, or `mcp__<server>__*`) in an --allowedTools list names a
-* server the run expects to be loaded. A grant is a dead letter unless its
-* server is in the filtered config, so the runner treats these as implicit
-* --mcp names — and only these; non-mcp grants load nothing.
-*/
-function mcpServersFromToolGrants(tools) {
-	const out = [];
-	for (const entry of tools) for (const name of entry.split(",").map((s) => s.trim()).filter(Boolean)) {
-		if (!name.startsWith("mcp__")) continue;
-		const server = name.slice(5).split("__")[0];
-		if (server && !out.includes(server)) out.push(server);
-	}
-	return out;
-}
-/** Path of a run's filtered MCP config. */
-function runMcpConfigPath(logDir, id) {
-	return join(logDir, `${id}.mcp.json`);
-}
-/**
-* Write a config containing only `names` (already expanded) and return its
-* path. Unknown names fail fast with the available list.
-*/
-function writeMcpConfig(logDir, id, names, claudeJson = CLAUDE_JSON) {
-	const available = readMcpServers(claudeJson);
-	const unknown = names.filter((n) => !(n in available));
-	if (unknown.length) throw new WorkersConfigError(`unknown MCP server(s): ${unknown.join(", ")}. Available: ${Object.keys(available).join(", ") || "(none in ~/.claude.json)"}`);
-	const servers = {};
-	for (const n of names) servers[n] = available[n];
-	const path = runMcpConfigPath(logDir, id);
-	if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
-	writeFileSync(path, JSON.stringify({ mcpServers: servers }, null, 2) + "\n", "utf8");
-	return path;
-}
-/** `pai worker mcp list`: the servers and sets a run could name. */
-function describeMcp(config, claudeJson = CLAUDE_JSON) {
-	const servers = Object.keys(readMcpServers(claudeJson));
-	const lines = [];
-	if (servers.length) {
-		lines.push(`servers (~/.claude.json):`);
-		for (const s of servers) lines.push(`  ${s}`);
-	} else lines.push(`no MCP servers defined in ~/.claude.json`);
-	const sets = Object.entries(config.mcpSets);
-	if (sets.length) {
-		lines.push(`sets (workers.mcpSets):`);
-		for (const [name, members] of sets) lines.push(`  ${name} = ${members.join(", ")}`);
+		return null;
+	} finally {
+		db.close();
 	}
-	lines.push(`usage: pai worker run --mcp <name>[,<name>…] -p '<task>'`);
-	return lines;
 }
 
 //#endregion
@@ -1855,7 +2035,7 @@ function buildCodexEnv(provider) {
 	delete env.ANTHROPIC_DEFAULT_SONNET_MODEL;
 	delete env.ANTHROPIC_DEFAULT_OPUS_MODEL;
 	const keyPath = providerKeyPath(provider);
-	if (keyPath && existsSync(keyPath)) env.OPENAI_API_KEY = readFileSync(keyPath, "utf8").trim();
+	if (provider.key || keyPath && existsSync(keyPath)) env.OPENAI_API_KEY = resolveProviderKey(provider) ?? "";
 	if (provider.upstreamUrl) env.OPENAI_BASE_URL = provider.upstreamUrl;
 	for (const [k, v] of Object.entries(provider.env)) env[k] = v;
 	env.PAI_WORKER = "1";
@@ -2014,7 +2194,12 @@ function codexInstalled() {
 *     (context meter included), ledger lines, result printed in the caller's
 *     --output-format (json adds the parsed `report`), and the follow pane
 *     (unless --no-pane).
-*   - interactive: no MCP restriction, no pane, ENABLE_TOOL_SEARCH=true.
+*   - interactive: no MCP/tool restriction by default, no pane,
+*     ENABLE_TOOL_SEARCH=true. A project that pinned a list with `pai
+*     project mcp` / `pai project tools` gets `--strict-mcp-config
+*     --mcp-config <filtered>` / `--tools <list>` built the same way a
+*     headless run's allowlist is; an explicit --mcp or --tools on this
+*     command line still wins over the project's pin.
 *
 * 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).
@@ -2077,6 +2262,56 @@ function resetContextTokensOnCompact(status, e) {
 function isCompactBoundary(e) {
 	return e.type === "system" && (e.subtype === "compact_boundary" || e.subtype === "compact");
 }
+/**
+* The model the init event announces, adopted into the status when the spawn
+* could not name one (a caller that passed `--model` itself in the claude
+* args, or a provider whose table has no entry for the capability). The run's
+* real model is then only knowable from the first event it sends. Never
+* overwrites an explicit model — a resolved or pinned model stays the
+* recorded truth.
+*/
+function adoptInitModel(status, e) {
+	if (status.model) return;
+	const m = (e.model ?? "").trim();
+	if (m) status.model = m;
+}
+/**
+* The model a run goes out on: an explicit `--model` wins; else the class
+* target's alias ("glm/fast") names the capability; else the capability the
+* class implies (image → image model, spotcheck/simple → fast, everything
+* else → default), resolved against the provider's model table. The built-in
+* anthropic provider resolves through the same table as any other, so a
+* worker never inherits the orchestrator session's model.
+*/
+function resolveRunModel(target, className, modelFlag) {
+	if (modelFlag) return modelFlag;
+	const alias = target.modelAlias;
+	const capability = alias && isModelCapability(alias) ? alias : classModelCapability(className);
+	return resolveModelCapability(target.provider, capability);
+}
+/**
+* The `--model` part of the claude argv. Skipped when the caller already
+* pinned one in the claude args (it must not be clobbered) or when nothing
+* resolved — `--model ""` would break the spawn.
+*/
+function modelArgs(model, callerPinned) {
+	return !callerPinned && model ? ["--model", model] : [];
+}
+/**
+* Whether the run's assembled cmd gets a forced --model. Headless workers
+* always take the resolved class/provider model — that table exists so
+* spawned subagents stay cheap. An interactive launch (`pai worker run` with
+* no -p) IS the chat pane, not a subagent: with no --model of the caller's
+* own it gets none here either, so Claude Code's own settings.json model
+* applies, exactly as launching `claude` by hand would (2026-09-20: an
+* interactive supervisor came up on the class model instead of the
+* settings.json [1m] variant, then needed a manual /model switch that
+* rebuilt the whole cache). A caller's own --model, headless or not, is
+* already in the passthrough args and must not be duplicated here.
+*/
+function modelFlagArgs(headless, model, callerPinned) {
+	return headless ? modelArgs(model, callerPinned) : [];
+}
 /** Context window announced by the init event, when the endpoint sends one. */
 function initContextWindow(e) {
 	if (typeof e.context_window === "number" && e.context_window > 0) return e.context_window;
@@ -2094,7 +2329,7 @@ async function runWorker(opts) {
 	const logDir = workersLogDir(config);
 	mkdirSync(logDir, { recursive: true });
 	if (opts.className === "plan" && !opts._planner) {
-		const { runPlanner } = await import("./planner-D5Ui7DAm.mjs");
+		const { runPlanner } = await import("./planner-pXRc-8yt.mjs");
 		return runPlanner(opts);
 	}
 	const parent = launchParent(opts.parent);
@@ -2106,9 +2341,7 @@ async function runWorker(opts) {
 	assertProviderRunnable(target.providerName, target.provider);
 	const parsed = parseRunnerArgs(opts.claudeArgs);
 	const label = opts.label ?? shortText(parsed.prompt ?? UNLABELED, 70);
-	const alias = target.modelAlias;
-	const capability = alias && isModelCapability(alias) ? alias : classModelCapability(opts.className);
-	const model = opts.modelFlag ?? resolveModelCapability(target.provider, capability);
+	const model = resolveRunModel(target, opts.className, opts.modelFlag);
 	try {
 		if (target.provider.engine === "codex") return await executeCodexRun({
 			config,
@@ -2120,6 +2353,7 @@ async function runWorker(opts) {
 			claudeArgs: opts.claudeArgs,
 			noPane: opts.noPane ?? false,
 			cwd: opts.cwd,
+			specPath: opts.specPath,
 			parent: parent ?? void 0,
 			stage: opts.stage,
 			quiet: opts.quiet,
@@ -2139,6 +2373,7 @@ async function runWorker(opts) {
 			noPane: opts.noPane ?? false,
 			mcpFlag: opts.mcpFlag,
 			cwd: opts.cwd,
+			specPath: opts.specPath,
 			parent: parent ?? void 0,
 			stage: opts.stage,
 			quiet: opts.quiet,
@@ -2146,7 +2381,8 @@ async function runWorker(opts) {
 			id: opts.id,
 			worktreeFlag: opts.worktreeFlag,
 			className: opts.className,
-			reroutes: opts._reroutes ?? 0
+			reroutes: opts._reroutes ?? 0,
+			printCmd: opts.printCmd
 		});
 	} catch (e) {
 		if (e instanceof Error && e.message.startsWith("key file")) throw new Error(`provider "${target.providerName}": ${e.message}\nPut the token in that file (chmod 600) or point keyFile elsewhere.`);
@@ -2166,6 +2402,59 @@ const DEFAULT_WORKER_TOOLS = "Read,Edit,Write,Bash,Grep,Glob";
 function headlessToolGrants(allowedTools) {
 	return allowedTools.length ? [] : ["--allowedTools", DEFAULT_WORKER_TOOLS];
 }
+/**
+* `--tools` narrows which built-in tool *schemas* claude loads into the
+* system prompt — distinct from `--allowedTools`, which narrows which of
+* those loaded tools may run without asking. A headless worker with a small
+* grant (say, just Read) still pays for every built-in schema (Bash, Web*,
+* NotebookEdit, …) it never uses: ~9k tokens per spawn (29,270 -> 20,352,
+* measured 2026-09-20). Passing --tools built from the same grant removes
+* the unused schemas.
+*
+* MCP grants (`mcp__server__tool` / `mcp__server__*`) are left out of the
+* --tools list: they are not built-in tool names, --tools does not
+* recognize them, and the MCP server's tools load through --mcp-config
+* regardless. Tested 2026-09-20: with an --allowedTools grant of
+* `Read,mcp__pai__memory_search`, passing `--tools Read` (mcp name
+* omitted) still let the worker call memory_search successfully; the tool
+* loads from the filtered MCP config, not from --tools.
+*/
+function headlessToolsFlag(allowedTools) {
+	const names = [];
+	for (const entry of allowedTools) for (const raw of entry.split(",").map((s) => s.trim()).filter(Boolean)) {
+		if (raw.startsWith("mcp__")) continue;
+		const patterned = raw.match(/^([A-Za-z]+)\(.*\)$/);
+		const name = patterned ? patterned[1] : raw;
+		if (!names.includes(name)) names.push(name);
+	}
+	return names.length ? ["--tools", names.join(",")] : [];
+}
+/**
+* The claude flag that turns on the browser bridge, when the run asked for it.
+*
+* The bridge is not an MCP server — it rides the Chrome native-host channel,
+* is absent from `mcpServers`, and is off in a spawned claude until `--chrome`
+* is passed. A grant such as `mcp__claude-in-chrome__tabs_context_mcp` is
+* therefore a request for that flag, not for a server to load; without this
+* the grant names a tool that never exists. `rest` is the caller's own argv:
+* a `--chrome` they passed themselves is kept rather than duplicated.
+*/
+function chromeGrantArgs(wanted, rest = []) {
+	if (rest.includes("--chrome")) return [];
+	return grantsChrome(wanted) ? ["--chrome"] : [];
+}
+/**
+* Which MCP server names and --tools list an interactive launch (`pai
+* worker run`, no -p) uses: an explicit --mcp on this command line beats
+* the project's `pai project mcp` pin; an explicit --tools beats `pai
+* project tools`. Neither given: [] — today's "everything loads" default.
+*/
+function interactiveMcpTools(explicitMcp, callerTools, projectLaunch) {
+	return {
+		mcpNames: explicitMcp.length ? explicitMcp : projectLaunch?.mcp ?? [],
+		tools: !callerTools && projectLaunch?.tools?.length ? projectLaunch.tools : []
+	};
+}
 async function executeRun(a) {
 	const { config, logDir, target, model, label, parsed, noPane } = a;
 	const headless = parsed.headless;
@@ -2178,7 +2467,7 @@ async function executeRun(a) {
 	const session = resolveSession(term);
 	const spawnerSession = resolveSpawnerSession(logDir, cwd);
 	let worktree = null;
-	if (headless && worktreeWanted(a.worktreeFlag, {
+	if (headless && !a.printCmd && worktreeWanted(a.worktreeFlag, {
 		cwd,
 		className: a.className,
 		prompt: parsed.prompt
@@ -2193,6 +2482,59 @@ async function executeRun(a) {
 		});
 	}
 	env.PAI_WORKER_ID = wid;
+	const chromeArgs = chromeGrantArgs([
+		...a.mcpFlag ? [a.mcpFlag] : [],
+		...parsed.mcp,
+		...target.classMcp ?? [],
+		...parsed.allowedTools
+	], parsed.rest);
+	let mcpArgs = [];
+	let toolsFlag = headless ? headlessToolsFlag(parsed.allowedTools) : [];
+	if (headless && !parsed.callerMcpConfig) {
+		const wanted = [
+			...a.mcpFlag ? [a.mcpFlag] : [],
+			...parsed.mcp,
+			...target.classMcp ?? [],
+			...mcpServersFromToolGrants(parsed.allowedTools)
+		];
+		if (wanted.length) mcpArgs = [
+			"--strict-mcp-config",
+			"--mcp-config",
+			writeMcpConfig(logDir, wid, expandMcpNames(wanted, config))
+		];
+		else mcpArgs = [
+			"--strict-mcp-config",
+			"--mcp-config",
+			ensureNoMcpConfig(logDir)
+		];
+	} else if (!headless && !parsed.callerMcpConfig) {
+		const explicitMcp = [...a.mcpFlag ? [a.mcpFlag] : [], ...parsed.mcp];
+		const projectLaunch = projectLaunchConfig(cwd);
+		const picked = interactiveMcpTools(explicitMcp, parsed.callerTools, projectLaunch);
+		if (picked.mcpNames.length) mcpArgs = [
+			"--strict-mcp-config",
+			"--mcp-config",
+			writeMcpConfig(logDir, wid, expandMcpNames(picked.mcpNames, config))
+		];
+		if (picked.tools.length) toolsFlag = ["--tools", picked.tools.join(",")];
+	}
+	const restArgs = headless ? stripPromptValues(parsed.rest) : parsed.rest;
+	const toolArgs = headless ? headlessToolGrants(parsed.allowedTools) : [];
+	const cmd = ["claude"];
+	cmd.push(...modelFlagArgs(headless, model, Boolean(parsed.callerModel)));
+	cmd.push(...chromeArgs, ...mcpArgs, ...toolArgs, ...toolsFlag, ...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);
+		if (worktree) cmd.push("--append-system-prompt", worktreeSystemPrompt(wid, worktree.branch, worktree.dir));
+	}
+	if (a.printCmd) {
+		console.log(JSON.stringify({
+			cmd,
+			cwd: worktree?.dir ?? cwd
+		}));
+		return 0;
+	}
 	const status = {
 		id: wid,
 		pid: process.pid,
@@ -2210,6 +2552,7 @@ async function executeRun(a) {
 		rc: null,
 		secs: null,
 		origin: headless ? "spawn" : "chat",
+		outputFormat: parsed.outputFormat,
 		...session ? { session } : {},
 		...spawnerSession ? { spawnerSession } : {},
 		...a.parent ? {
@@ -2220,7 +2563,8 @@ async function executeRun(a) {
 			worktreeDir: worktree.dir,
 			branch: worktree.branch,
 			worktreeBase: worktree.base
-		} : {}
+		} : {},
+		...a.specPath ? { spec: a.specPath } : {}
 	};
 	saveStatus(logDir, status);
 	a.onWorkerStart?.(wid);
@@ -2231,38 +2575,10 @@ async function executeRun(a) {
 		mode: headless ? "headless" : "interactive",
 		model,
 		cwd,
-		label
+		label,
+		...a.specPath ? { spec: a.specPath } : {}
 	});
 	if (headless && !noPane && config.pane.enabled && term && process.env.PAI_WORKER_AUTOPANE !== "0") openPaneForWorker(logDir, config, wid, term).catch(() => {});
-	let mcpArgs = [];
-	if (headless && !parsed.callerMcpConfig) {
-		const wanted = [
-			...a.mcpFlag ? [a.mcpFlag] : [],
-			...parsed.mcp,
-			...target.classMcp ?? [],
-			...mcpServersFromToolGrants(parsed.allowedTools)
-		];
-		if (wanted.length) mcpArgs = [
-			"--strict-mcp-config",
-			"--mcp-config",
-			writeMcpConfig(logDir, wid, expandMcpNames(wanted, config))
-		];
-		else mcpArgs = [
-			"--strict-mcp-config",
-			"--mcp-config",
-			ensureNoMcpConfig(logDir)
-		];
-	}
-	const restArgs = headless ? stripPromptValues(parsed.rest) : parsed.rest;
-	const toolArgs = headless ? headlessToolGrants(parsed.allowedTools) : [];
-	const cmd = ["claude"];
-	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);
-		if (worktree) cmd.push("--append-system-prompt", worktreeSystemPrompt(wid, worktree.branch, worktree.dir));
-	}
 	const t0 = Date.now();
 	const proc = spawn(cmd[0], cmd.slice(1), {
 		env,
@@ -2363,6 +2679,7 @@ async function executeRun(a) {
 			writeEvent(e);
 			if (e.type === "system" && e.subtype === "init") {
 				if (e.session_id) status.claudeSession = e.session_id;
+				adoptInitModel(status, e);
 				const cw = initContextWindow(e);
 				if (cw) status.contextWindow = cw;
 				saveStatus(logDir, status);
@@ -2436,6 +2753,7 @@ async function executeRun(a) {
 				noPane: a.noPane,
 				mcpFlag: a.mcpFlag,
 				cwd: a.cwd,
+				specPath: a.specPath,
 				parent: a.parent,
 				stage: a.stage,
 				claudeArgs: a.claudeArgs,
@@ -2516,6 +2834,7 @@ async function executeCodexRun(a) {
 		rc: null,
 		secs: null,
 		origin: "spawn",
+		outputFormat: parsed.outputFormat,
 		...session ? { session } : {},
 		...spawnerSession ? { spawnerSession } : {},
 		...target.provider.contextWindow ? { contextWindow: target.provider.contextWindow } : {},
@@ -2527,7 +2846,8 @@ async function executeCodexRun(a) {
 			worktreeDir: worktree.dir,
 			branch: worktree.branch,
 			worktreeBase: worktree.base
-		} : {}
+		} : {},
+		...a.specPath ? { spec: a.specPath } : {}
 	};
 	saveStatus(logDir, status);
 	a.onWorkerStart?.(wid);
@@ -2793,5 +3113,5 @@ function resultFromOutput(out) {
 }
 
 //#endregion
-export { nowStamp as A, alive as C, loadStatus as D, isChatPane as E, shortText as F, appendLedger as M, ledgerSummary as N, loadStatuses as O, parseRunnerArgs 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, saveStatus 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-D7K5UALn.mjs.map
+export { newWorkerId as A, ageOf as C, isChatPane as D, contextPercent as E, longInlinePromptHint as F, parseRunnerArgs as I, shortText as L, saveStatus as M, setWorkerLabel as N, loadStatus as O, waitForTerminalStatus as P, describeMcp as R, UNLABELED as S, contextLabel as T, resolveSession as _, renderReport as a, appendLedger as b, handoffFromInside as c, workerDepth as d, checkPaneForWorker as f, itermForClaudeSession as g, currentTabKey as h, parseWorkerReport as i, nowStamp as j, loadStatuses as k, readInbox as l, openPaneForWorker as m, runWorker as n, discardWorker as o, openFollowPane as p, testProvider as r, mergeWorker as s, printResult as t, sayToWorker as u, sessionTag as v, alive as w, ledgerSummary as x, workerInScope as y, expandMcpNames as z };
+//# sourceMappingURL=run-DDdT9teG.mjs.map