@tekmidian/pai 0.42.5 → 0.43.0

package/dist/{run-D7K5UALn.mjs → run-ByBKowN5.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
 /**
@@ -1611,56 +1825,333 @@ function worktreeSystemPrompt(id, branch, dir) {
 	].join("\n");
 }
 
+//#endregion
+//#region src/workers/agentish.ts
+/**
+* agentish.ts — Agentish v2 (AG2), the wire format a worker's final report
+* uses by default: a kind line plus one-letter k=v lines instead of JSON
+* prose. Spec and validator live in the `aibroker` CLI
+* (see /Users/i052341/Daten/Cloud/Development/ai/AIBroker/docs/agentish.md);
+* this module shells out to it when present and falls back to a frozen copy
+* of the spec text otherwise, so a worker still gets a contract when
+* `aibroker` is not installed on its box.
+*/
+/** Frozen copy of `aibroker agentish spec`'s first line, for when the CLI is absent. */
+const AG2_SPEC_FALLBACK = "AG2. msg=kind line+k=v lines. kinds T R S Q A X. keys i id g goal o own n forbid d steps p proof u out l limits r res c changes t tests G gate I inst m images # nums w worst x next z note(<200ch). sep |. outcomes + - ~ ? !. @n=path declared once then reused; @n:12=file:line. tests as Name+ Name-. no prose, no articles, never restate, unknown=?. r=+ only if all t +.";
+/** Frozen copy of the `y` (why) extension line. */
+const AG2_EXTENSIONS_FALLBACK = "y why(≤600ch)";
+let cachedSpec = null;
+/**
+* The AG2 spec + extensions lines: from `aibroker agentish spec` when the
+* CLI runs and its output looks right, else the frozen fallback. Memoised —
+* every caller in one process gets the same spec without re-spawning aibroker.
+*/
+function ag2Spec() {
+	if (cachedSpec) return cachedSpec;
+	try {
+		const lines = execFileSync("aibroker", ["agentish", "spec"], {
+			timeout: 3e3,
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			encoding: "utf8"
+		}).split("\n").filter((l) => l.trim());
+		if (lines[0]?.startsWith("AG2.")) {
+			cachedSpec = {
+				spec: lines[0],
+				extensions: lines[1] ?? AG2_EXTENSIONS_FALLBACK,
+				source: "aibroker"
+			};
+			return cachedSpec;
+		}
+	} catch {}
+	cachedSpec = {
+		spec: AG2_SPEC_FALLBACK,
+		extensions: AG2_EXTENSIONS_FALLBACK,
+		source: "builtin"
+	};
+	return cachedSpec;
+}
+/**
+* Parse one AG2 message: first non-empty line is the kind (T R S Q A X,
+* optionally followed by trailing text — only the first character is the
+* kind), later lines are `key=value` or `@n=path` symbol declarations.
+* ```-fenced lines are ignored so a message pasted inside a code fence still
+* parses. Returns null when the first non-empty line is not a known kind.
+*/
+function parseAg2Report(text) {
+	const kinds = new Set([
+		"T",
+		"R",
+		"S",
+		"Q",
+		"A",
+		"X"
+	]);
+	const lines = (text ?? "").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("```"));
+	if (!lines.length) return null;
+	const kind = lines[0][0];
+	if (!kinds.has(kind)) return null;
+	const fields = {};
+	const symbols = {};
+	for (const line of lines.slice(1)) {
+		const eq = line.indexOf("=");
+		if (eq < 0) continue;
+		const key = line.slice(0, eq).trim();
+		const value = line.slice(eq + 1).trim();
+		if (key.startsWith("@")) symbols[key.slice(1)] = value;
+		else fields[key] = value;
+	}
+	return {
+		kind,
+		fields,
+		symbols
+	};
+}
+/** true iff the value ends with the AG2 pass outcome character. */
+function passed(entry) {
+	return entry.endsWith("+");
+}
+/**
+* Map a parsed AG2 report onto the runner's WorkerReport shape, so the
+* viewer and `printResult` can render an AG2 `R` exactly like a JSON one.
+*/
+function ag2ToWorkerReport(parsed) {
+	const f = parsed.fields;
+	const out = { format: "ag2" };
+	if (f.c) out.changed = f.c.split("|").map((s) => s.trim()).filter(Boolean).map((entry) => {
+		const colon = entry.indexOf(":");
+		const space = entry.indexOf(" ");
+		const cut = colon >= 0 && (space < 0 || colon < space) ? colon : space;
+		if (cut < 0) return {
+			path: entry,
+			summary: ""
+		};
+		return {
+			path: entry.slice(0, cut).trim(),
+			summary: entry.slice(cut + 1).trim()
+		};
+	});
+	if (f.t) out.checks = f.t.split(/\s+/).filter(Boolean).map((entry) => ({
+		name: entry.slice(0, -1),
+		ok: passed(entry),
+		detail: entry.slice(-1)
+	}));
+	if (f.p) out.commands = f.p.split("|").map((s) => s.trim()).filter(Boolean);
+	const open = [];
+	if (f.x) open.push(f.x);
+	for (const [k, v] of Object.entries(f)) if ((v.endsWith("!") || v.endsWith("?")) && k !== "r" && k !== "res") open.push(`${k}: ${v}`);
+	if (open.length) out.open = open;
+	if (f.z) out.notes = f.z;
+	const res = f.r ?? f.res;
+	if (res === "+" || res === "-" || res === "~" || res === "?" || res === "!") out.result = res;
+	if (f.y) out.why = f.y;
+	return out;
+}
+/**
+* Validate an AG2 message with `aibroker agentish check - --json`. Never
+* fails the caller: a missing/broken CLI reports ok:true, validator "none" —
+* a worker's run is never blocked on a local tooling gap, only its
+* `reportValid` marker goes unset.
+*/
+function validateAg2(text) {
+	try {
+		const out = execFileSync("aibroker", [
+			"agentish",
+			"check",
+			"-",
+			"--json"
+		], {
+			input: text,
+			timeout: 5e3,
+			stdio: [
+				"pipe",
+				"pipe",
+				"ignore"
+			],
+			encoding: "utf8"
+		});
+		const parsed = JSON.parse(out);
+		const errors = (parsed.errors ?? []).map((e) => e.message ?? e.code ?? "unknown error");
+		return {
+			ok: parsed.ok !== false,
+			errors,
+			validator: "aibroker"
+		};
+	} catch (e) {
+		const out = e.stdout;
+		if (out) try {
+			const parsed = JSON.parse(out.toString());
+			const errors = (parsed.errors ?? []).map((er) => er.message ?? er.code ?? "unknown error");
+			return {
+				ok: parsed.ok !== false,
+				errors,
+				validator: "aibroker"
+			};
+		} catch {}
+		return {
+			ok: true,
+			errors: [],
+			validator: "none"
+		};
+	}
+}
+
 //#endregion
 //#region src/workers/report.ts
 /**
 * report.ts — the worker contract: terse, structured final reports.
 *
 * Headless workers run with an appended system prompt that fixes their output
-* shape: act, verify, then finish with ONE final message that is a JSON object
-* and nothing else. The runner parses it out of the result; the viewer renders
-* it as a compact block instead of a wall of text.
+* shape: act, verify, then finish with ONE final message — AG2 (see
+* agentish.ts) by default, JSON as the pre-AG2 fallback. The runner parses it
+* out of the result; the viewer renders it as a compact block instead of a
+* wall of text.
 */
 /** The marker the runner puts on operator messages the worker must answer. */
 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.",
-	"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 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.",
-	"",
-	`Operator messages: a user turn starting with ${OPERATOR_MARK} was typed by the operator while you`,
-	"run (the prompt of a resumed run is the operator's too). Answer it FIRST, in one or two plain lines —",
-	"a question gets its answer, an instruction gets one line naming what will change — then continue the",
-	"task you were on.",
-	"",
-	"Sub-workers: you may start your own workers with `pai worker run --class <class> -p '<prompt>'`",
-	"(Bash tool). Your children run on their own provider and report back to you automatically when",
-	"they finish. Send a handoff UP instead of doing work yourself when a cheaper provider would",
-	"suffice, the task is out of your scope, or a decision is needed:",
-	"`pai worker handoff '{\"kind\":\"proposal\",\"text\":\"…\",\"data\":{…}}'` (kinds: proposal,",
-	"question, blocker; results are sent for you when you finish). Sibling workers are not a",
-	"coordination path — there is no sideways channel; everything goes up to your parent."
-].join("\n");
-/**
-* Extract the JSON report from a worker's final message. Accepts a bare
-* object, a ```json fenced block, or an object embedded in surrounding text.
-* Only objects that look like the contract count (at least one of changed /
+/** Classes that get the short contract — cheap, bounded, single-answer tasks. */
+const SHORT_CONTRACT_CLASSES = new Set(["spotcheck", "simple"]);
+/**
+* The AG2 report block appended to a contract when format is "ag2" — field
+* set matches `aibroker agentish check`'s real R schema (verified 2026-09-20:
+* i/r/t/c are required, not optional as an early draft of this contract had
+* it; r=+ needs G=+ and non-empty p too, not just all-t-passing; R has no
+* `u`/out field at all — u is T-only — so the answer goes in z instead).
+*/
+function ag2ReportBlock() {
+	const spec = ag2Spec();
+	return [
+		spec.spec,
+		spec.extensions,
+		"Final message: one AG2 `R` message only — no prose, no code fence, no markdown.",
+		"R requires i (id), r (+ - ~ ? !), t (tests, Name+ Name-), c (path summary|path summary).",
+		"r=+ requires G=+ (gate) and p non-empty (proof command), and every t entry +. z= the answer/note,",
+		"one line, always present. x= what is left (omit if nothing). y= one line why when r is not +.",
+		"Example:",
+		"R",
+		"i=count-audit-ts",
+		"r=+",
+		"G=+",
+		"c=src/audit summary of files counted",
+		"t=Count+",
+		"p=wc -l src/audit/*.ts",
+		"z=19 files, 2523 lines"
+	];
+}
+/** The JSON report block appended to a contract when format is "json" (pre-AG2 fallback). */
+function jsonReportBlock(lead) {
+	return [lead, "{\"changed\":[{\"path\":\"…\",\"summary\":\"…\"}],\"commands\":[\"…\"],\"checks\":[{\"name\":\"…\",\"ok\":true,\"detail\":\"…\"}],\"open\":[\"…\"],\"notes\":\"one line\"}"];
+}
+/** The two sentences that stop a worker from breaking on shell quoting — kept in both contracts. */
+function fileNotInlineBlock() {
+	return [
+		"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."
+	];
+}
+/** The file-not-inline rule, condensed for the short contract's tight length budget. */
+function fileNotInlineBlockShort() {
+	return [
+		"NEVER put a multi-line or quoted payload inline in a shell command (no heredocs, no inline",
+		"scripts): write it to a file with the Write tool and pass it, e.g. -p \"$(cat spec.txt)\".",
+		"Never inline code (python3 -c and friends) — write a script file and run it, or use jq."
+	];
+}
+/** spotcheck/simple: headless, bounded, no delegation language — under 1500 chars in ag2 format. */
+function shortContractPrompt(format) {
+	const lines = [
+		"You are a headless implementation worker, run non-interactively.",
+		"This task is yours: answer the question or do the bounded task now. Run at most one command",
+		"to confirm a result and never re-derive a number you already have. No child workers, no handoff.",
+		...fileNotInlineBlockShort()
+	];
+	lines.push(...format === "ag2" ? ag2ReportBlock() : jsonReportBlock("Your ONE final message is a JSON object and nothing else — no prose before or after, no code fence:"));
+	return lines.join("\n");
+}
+/** Every other class (and no class): the full worker/orchestrator contract. */
+function fullContractPrompt(format) {
+	const lines = [
+		"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.",
+		...fileNotInlineBlock(),
+		"",
+		`Operator messages: a user turn starting with ${OPERATOR_MARK} was typed by the operator while you`,
+		"run (the prompt of a resumed run is the operator's too). Answer it FIRST, in one or two plain lines —",
+		"a question gets its answer, an instruction gets one line naming what will change — then continue the",
+		"task you were on.",
+		"",
+		"Sub-workers: you may start your own workers with `pai worker run --class <class> -p '<prompt>'`",
+		"(Bash tool). Your children run on their own provider and report back to you automatically when",
+		"they finish. Send a handoff UP instead of doing work yourself when a cheaper provider would",
+		"suffice, the task is out of your scope, or a decision is needed:",
+		"`pai worker handoff '{\"kind\":\"proposal\",\"text\":\"…\",\"data\":{…}}'` (kinds: proposal,",
+		"question, blocker; results are sent for you when you finish). Sibling workers are not a",
+		"coordination path — there is no sideways channel; everything goes up to your parent.",
+		""
+	];
+	lines.push(...format === "ag2" ? ag2ReportBlock() : jsonReportBlock("Your ONE final message is a JSON object and nothing else — no prose before or after, no code fence:"));
+	if (format === "json") lines.push("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.");
+	return lines.join("\n");
+}
+/**
+* The system prompt appended to every headless run, chosen by task class and
+* report format. `spotcheck`/`simple` get a short contract (no delegation
+* language, under 1200 chars in json format / 1500 in ag2); every other class (and no class) gets the
+* full contract. Both end with the AG2 report block unless `format` is
+* "json", the pre-AG2 fallback.
+*/
+function workerContractPrompt(cls, format) {
+	return SHORT_CONTRACT_CLASSES.has(cls ?? "") ? shortContractPrompt(format) : fullContractPrompt(format);
+}
+/**
+* The line appended to a headless prompt's own text (never the system
+* prompt): models weight an instruction at the end of the user turn more
+* than one buried in a long system-prompt paragraph, and this is the
+* difference between a worker that returns a valid AG2/JSON report and one
+* that answers in prose despite the contract (measured 2026-09-20 on both
+* Haiku and Sonnet with the AG2 contract alone).
+*/
+function promptTrailer(format) {
+	return format === "ag2" ? "\n\nFinal message: one AG2 R message only, no prose (format in system prompt)." : "\n\nFinal message: a JSON object only, no prose before or after, no code fence (format in system prompt).";
+}
+/** The exact text sent to resend a final message that failed AG2 validation. */
+const AG2_REASK_TEXT = "Your final message was not a valid AG2 R message. Resend it now as a single AG2 R message only: first line R, then i=id r=result G=+ (gate, if r=+) t=tests(Name+) c=path summary p=proof z=the answer/note. No prose.";
+/** The full-contract AG2 prompt — the keepalive path's identical-construction baseline. */
+const WORKER_CONTRACT_PROMPT = fullContractPrompt("ag2");
+/**
+* Extract the report from a worker's final message: AG2 first (an `R`
+* message, see agentish.ts), then the JSON contract as a fallback for
+* workers still on the pre-AG2 shape. Accepts a bare JSON object, a
+* ```json fenced block, or an object embedded in surrounding text — only
+* objects that look like the contract count (at least one of changed /
 * checks / notes) — any other JSON falls through to null so the raw text is
 * kept as-is.
 */
 function parseWorkerReport(text) {
 	const trimmed = (text ?? "").trim();
 	if (!trimmed) return null;
+	const ag2 = parseAg2Report(trimmed);
+	if (ag2 && ag2.kind === "R") return ag2ToWorkerReport(ag2);
 	const candidates = [];
 	const fence = trimmed.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
 	if (fence) candidates.push(fence[1]);
@@ -1670,7 +2161,10 @@ function parseWorkerReport(text) {
 	if (first >= 0 && last > first) candidates.push(trimmed.slice(first, last + 1));
 	for (const cand of candidates) try {
 		const v = JSON.parse(cand);
-		if (typeof v === "object" && v !== null && !Array.isArray(v) && looksLikeReport(v)) return v;
+		if (typeof v === "object" && v !== null && !Array.isArray(v) && looksLikeReport(v)) return {
+			...v,
+			format: "json"
+		};
 	} catch {}
 	return null;
 }
@@ -1717,104 +2211,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 +2301,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,11 +2460,24 @@ 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).
 */
+/**
+* ag2 unless the caller passed --report json or PAI_WORKER_REPORT=json is
+* set in the environment; an explicit flag always wins over the env default.
+*/
+function resolveReportFormat(flag, env = process.env) {
+	if (flag) return flag;
+	return env.PAI_WORKER_REPORT === "json" ? "json" : "ag2";
+}
 /** A stream-json user message for the child's stdin. */
 function stdinUserMessage(text) {
 	return JSON.stringify({
@@ -2077,6 +2536,81 @@ 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) : [];
+}
+/**
+* The prompt text actually sent to the worker and whether the trailer got
+* appended. An instruction at the END of the user turn outweighs one buried
+* in the system prompt (measured 2026-09-20: the AG2 contract alone was
+* ignored by both Haiku and Sonnet). Never applied to an interactive launch
+* (no -p) or when the caller brought its own --append-system-prompt — the
+* trailer's "format in system prompt" would then point at nothing.
+*/
+function headlessPromptText(prompt, headless, callerSystemPrompt, format) {
+	const applied = headless && prompt !== null && !callerSystemPrompt;
+	return {
+		text: applied ? prompt + promptTrailer(format) : prompt,
+		applied
+	};
+}
+/**
+* Whether an invalid final report earns the one bounded re-ask: only when a
+* real validator caught the problem (a missing/broken aibroker must never
+* block the run further), the caller did not opt out, and there is a session
+* to resume into. Cap of exactly one is enforced by the caller never calling
+* this twice for the same run.
+*/
+function shouldRetryReport(validation, noReportRetry, hasSession) {
+	return !validation.ok && validation.validator === "aibroker" && !noReportRetry && hasSession;
+}
 /** 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 +2628,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-BlKGgpWI.mjs");
 		return runPlanner(opts);
 	}
 	const parent = launchParent(opts.parent);
@@ -2106,9 +2640,8 @@ 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);
+	const reportFormat = resolveReportFormat(opts.reportFormatFlag);
 	try {
 		if (target.provider.engine === "codex") return await executeCodexRun({
 			config,
@@ -2120,13 +2653,15 @@ 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,
 			onWorkerStart: opts.onWorkerStart,
 			id: opts.id,
 			worktreeFlag: opts.worktreeFlag,
-			className: opts.className
+			className: opts.className,
+			reportFormat
 		});
 		return await executeRun({
 			config,
@@ -2139,6 +2674,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 +2682,10 @@ async function runWorker(opts) {
 			id: opts.id,
 			worktreeFlag: opts.worktreeFlag,
 			className: opts.className,
-			reroutes: opts._reroutes ?? 0
+			reroutes: opts._reroutes ?? 0,
+			printCmd: opts.printCmd,
+			reportFormat,
+			noReportRetry: opts.noReportRetry ?? false
 		});
 	} 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 +2705,92 @@ 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(",")] : [];
+}
+/**
+* A `--tools` value with no ToolSearch silently disables MCP tool deferral
+* (measured 2026-09-20: a run with `--tools "Bash,Read,Grep,Glob,Agent"` paid
+* 65,300 first-turn tokens with 5 MCP servers, 230,448 with 16, versus
+* 24,889 / 37,133 with ToolSearch present). Applied to the fully-assembled
+* argv so it catches a `--tools` from any source — the computed
+* `headlessToolsFlag`/project-pin flag, or one the caller put directly on
+* the command line.
+*/
+function ensureToolSearch(cmd) {
+	const flagIdx = cmd.findIndex((a) => a === "--tools");
+	if (flagIdx >= 0 && flagIdx + 1 < cmd.length) {
+		const value = cmd[flagIdx + 1];
+		if (value && !value.split(",").includes("ToolSearch")) {
+			const out = [...cmd];
+			out[flagIdx + 1] = `${value},ToolSearch`;
+			process.stderr.write("pai: added ToolSearch to --tools (keeps MCP tool deferral on)\n");
+			return out;
+		}
+		return cmd;
+	}
+	const eqIdx = cmd.findIndex((a) => a.startsWith("--tools="));
+	if (eqIdx >= 0) {
+		const value = cmd[eqIdx].slice(8);
+		if (value && !value.split(",").includes("ToolSearch")) {
+			const out = [...cmd];
+			out[eqIdx] = `--tools=${value},ToolSearch`;
+			process.stderr.write("pai: added ToolSearch to --tools (keeps MCP tool deferral on)\n");
+			return out;
+		}
+	}
+	return cmd;
+}
+/**
+* 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 +2803,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 +2818,61 @@ 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 { text: promptText, applied: trailerApplied } = headlessPromptText(parsed.prompt, headless, parsed.callerSystemPrompt, a.reportFormat);
+	let 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", workerContractPrompt(a.className, a.reportFormat));
+		if (worktree) cmd.push("--append-system-prompt", worktreeSystemPrompt(wid, worktree.branch, worktree.dir));
+	}
+	cmd = ensureToolSearch(cmd);
+	if (a.printCmd) {
+		console.log(JSON.stringify({
+			cmd,
+			cwd: worktree?.dir ?? cwd
+		}));
+		return 0;
+	}
 	const status = {
 		id: wid,
 		pid: process.pid,
@@ -2210,6 +2890,9 @@ async function executeRun(a) {
 		rc: null,
 		secs: null,
 		origin: headless ? "spawn" : "chat",
+		outputFormat: parsed.outputFormat,
+		...headless ? { reportFormat: a.reportFormat } : {},
+		...trailerApplied ? { promptTrailer: true } : {},
 		...session ? { session } : {},
 		...spawnerSession ? { spawnerSession } : {},
 		...a.parent ? {
@@ -2220,7 +2903,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 +2915,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,
@@ -2347,8 +3003,8 @@ async function executeRun(a) {
 		resultReport: null
 	};
 	if (headless) {
-		if (parsed.prompt !== null) try {
-			proc.stdin.write(stdinUserMessage(parsed.prompt) + "\n");
+		if (promptText !== null) try {
+			proc.stdin.write(stdinUserMessage(promptText) + "\n");
 		} catch {}
 		eventsFd = openSync(eventsPath(logDir, wid), "a");
 		createInterface({ input: proc.stdout }).on("line", (line) => {
@@ -2363,6 +3019,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);
@@ -2406,6 +3063,40 @@ async function executeRun(a) {
 	status.secs = secs;
 	if (resultEvent) status.last = shortText(resultEvent.result ?? "", 90);
 	if (ctx.resultReport?.notes) status.last = shortText(ctx.resultReport.notes, 90);
+	if (headless && a.reportFormat === "ag2" && resultEvent?.result) {
+		const v = validateAg2(resultEvent.result);
+		status.reportValid = v.ok;
+		status.reportErrors = v.errors;
+		if (shouldRetryReport(v, a.noReportRetry ?? false, Boolean(status.claudeSession))) {
+			status.reportRetried = true;
+			saveStatus(logDir, status);
+			appendLedger(ledger, "WORKER-REPORT-RETRY", {
+				id: wid,
+				reason: v.errors.join("; ") || "invalid AG2 message"
+			});
+			try {
+				const reaskText = await reaskAg2Report({
+					env,
+					cwd: worktree?.dir ?? cwd,
+					model,
+					callerPinnedModel: Boolean(parsed.callerModel),
+					chromeArgs,
+					mcpArgs,
+					toolArgs,
+					toolsFlag,
+					sessionId: status.claudeSession
+				});
+				const v2 = validateAg2(reaskText);
+				status.reportValid = v2.ok;
+				status.reportErrors = v2.errors;
+				if (v2.ok) {
+					resultEvent.result = reaskText;
+					ctx.resultReport = parseWorkerReport(reaskText);
+					if (ctx.resultReport?.notes) status.last = shortText(ctx.resultReport.notes, 90);
+				}
+			} catch {}
+		}
+	}
 	saveStatus(logDir, status);
 	appendLedger(ledger, "WORKER-END", {
 		id: wid,
@@ -2436,6 +3127,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,
@@ -2473,6 +3165,44 @@ function worktreeExtras(s) {
 		commits: s.commits ?? 0
 	} : void 0;
 }
+/**
+* The one bounded re-ask, cap exactly one: `claude --resume <session>` with
+* AG2_REASK_TEXT, single-shot `--output-format json` (one turn, no streaming
+* plumbing needed). Same env/model/mcp/tool flags as the original launch —
+* only --resume and the fixed re-ask prompt are new — so the resumed turn
+* sees the same grants the worker ran with.
+*/
+async function reaskAg2Report(a) {
+	let cmd = ["claude"];
+	cmd.push(...modelFlagArgs(true, a.model, a.callerPinnedModel));
+	cmd.push(...a.chromeArgs, ...a.mcpArgs, ...a.toolArgs, ...a.toolsFlag);
+	cmd.push("--resume", a.sessionId, "-p", AG2_REASK_TEXT, "--output-format", "json");
+	cmd = ensureToolSearch(cmd);
+	const proc = spawn(cmd[0], cmd.slice(1), {
+		env: a.env,
+		cwd: a.cwd,
+		stdio: [
+			"ignore",
+			"pipe",
+			"inherit"
+		]
+	});
+	const timer = setTimeout(() => {
+		try {
+			proc.kill("SIGKILL");
+		} catch {}
+	}, a.timeoutMs ?? 6e4);
+	let out = "";
+	proc.stdout.on("data", (chunk) => {
+		out += chunk.toString("utf8");
+	});
+	await new Promise((resolve) => {
+		proc.on("error", () => resolve());
+		proc.on("close", () => resolve());
+	});
+	clearTimeout(timer);
+	return resultFromOutput(out);
+}
 async function executeCodexRun(a) {
 	const { config, logDir, target, model, label, parsed, noPane } = a;
 	if (!parsed.headless || parsed.prompt === null) throw new Error(`provider "${target.providerName}" (engine codex) supports headless runs only: pass the task with -p '<prompt>'`);
@@ -2516,6 +3246,8 @@ async function executeCodexRun(a) {
 		rc: null,
 		secs: null,
 		origin: "spawn",
+		outputFormat: parsed.outputFormat,
+		reportFormat: "json",
 		...session ? { session } : {},
 		...spawnerSession ? { spawnerSession } : {},
 		...target.provider.contextWindow ? { contextWindow: target.provider.contextWindow } : {},
@@ -2527,7 +3259,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 +3526,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 { loadStatuses as A, expandMcpNames as B, UNLABELED as C, contextPercent as D, contextLabel as E, waitForTerminalStatus as F, longInlinePromptHint as I, parseRunnerArgs as L, nowStamp as M, saveStatus as N, isChatPane as O, setWorkerLabel as P, shortText as R, ledgerSummary as S, alive 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, usageContextTokens as i, newWorkerId as j, loadStatus 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, ageOf as w, appendLedger as x, sessionTag as y, describeMcp as z };
+//# sourceMappingURL=run-ByBKowN5.mjs.map