@tekmidian/pai 0.42.6 → 0.44.0

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

@@ -1825,70 +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.",
-	"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 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.",
-	"",
-	`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]);
@@ -1898,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;
 }
@@ -2204,6 +2470,14 @@ function codexInstalled() {
 * Auto-routed runs that die of a quota error before the first tool call are
 * restarted on the next provider in routing order (WORKER-REROUTE ledger line).
 */
+/**
+* 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({
@@ -2312,7 +2586,44 @@ function modelArgs(model, callerPinned) {
 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. */
+/**
+* Did the run end well? A headless run must have produced a stream-json
+* result event that is not an error; an interactive launch IS the chat pane
+* and never emits one, so its clean exit (rc 0) is the whole verdict —
+* without this every interactive session that ends normally was recorded
+* as `failed rc=0` and supervision pinged the spawner about a non-failure.
+*/
+function runSucceeded(headless, rc, resultEvent) {
+	if (rc !== 0) return false;
+	if (!headless) return true;
+	return resultEvent !== null && !resultEvent.is_error;
+}
 function initContextWindow(e) {
 	if (typeof e.context_window === "number" && e.context_window > 0) return e.context_window;
 	if (e.model_info && typeof e.model_info.context_window === "number" && e.model_info.context_window > 0) return e.model_info.context_window;
@@ -2329,7 +2640,7 @@ async function runWorker(opts) {
 	const logDir = workersLogDir(config);
 	mkdirSync(logDir, { recursive: true });
 	if (opts.className === "plan" && !opts._planner) {
-		const { runPlanner } = await import("./planner-pXRc-8yt.mjs");
+		const { runPlanner } = await import("./planner-B4DvNpXd.mjs");
 		return runPlanner(opts);
 	}
 	const parent = launchParent(opts.parent);
@@ -2342,6 +2653,7 @@ async function runWorker(opts) {
 	const parsed = parseRunnerArgs(opts.claudeArgs);
 	const label = opts.label ?? shortText(parsed.prompt ?? UNLABELED, 70);
 	const model = resolveRunModel(target, opts.className, opts.modelFlag);
+	const reportFormat = resolveReportFormat(opts.reportFormatFlag);
 	try {
 		if (target.provider.engine === "codex") return await executeCodexRun({
 			config,
@@ -2360,7 +2672,8 @@ async function runWorker(opts) {
 			onWorkerStart: opts.onWorkerStart,
 			id: opts.id,
 			worktreeFlag: opts.worktreeFlag,
-			className: opts.className
+			className: opts.className,
+			reportFormat
 		});
 		return await executeRun({
 			config,
@@ -2382,7 +2695,9 @@ async function runWorker(opts) {
 			worktreeFlag: opts.worktreeFlag,
 			className: opts.className,
 			reroutes: opts._reroutes ?? 0,
-			printCmd: opts.printCmd
+			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.`);
@@ -2430,6 +2745,39 @@ function headlessToolsFlag(allowedTools) {
 	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,
@@ -2520,14 +2868,16 @@ async function executeRun(a) {
 	}
 	const restArgs = headless ? stripPromptValues(parsed.rest) : parsed.rest;
 	const toolArgs = headless ? headlessToolGrants(parsed.allowedTools) : [];
-	const cmd = ["claude"];
+	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", WORKER_CONTRACT_PROMPT);
+		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,
@@ -2553,6 +2903,8 @@ async function executeRun(a) {
 		secs: null,
 		origin: headless ? "spawn" : "chat",
 		outputFormat: parsed.outputFormat,
+		...headless ? { reportFormat: a.reportFormat } : {},
+		...trailerApplied ? { promptTrailer: true } : {},
 		...session ? { session } : {},
 		...spawnerSession ? { spawnerSession } : {},
 		...a.parent ? {
@@ -2663,8 +3015,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) => {
@@ -2717,12 +3069,46 @@ async function executeRun(a) {
 	cleanup();
 	const secs = Math.floor((Date.now() - t0) / 1e3);
 	const resultEvent = ctx.resultEvent;
-	const ok = rc === 0 && resultEvent !== null && !resultEvent.is_error;
+	const ok = runSucceeded(headless, rc, resultEvent);
 	status.state = ok ? "done" : "failed";
 	status.rc = rc;
 	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,
@@ -2791,6 +3177,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>'`);
@@ -2835,6 +3259,7 @@ async function executeCodexRun(a) {
 		secs: null,
 		origin: "spawn",
 		outputFormat: parsed.outputFormat,
+		reportFormat: "json",
 		...session ? { session } : {},
 		...spawnerSession ? { spawnerSession } : {},
 		...target.provider.contextWindow ? { contextWindow: target.provider.contextWindow } : {},
@@ -3113,5 +3538,5 @@ function resultFromOutput(out) {
 }
 
 //#endregion
-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
+export { loadStatus as A, describeMcp as B, ledgerSummary as C, contextLabel as D, alive as E, setWorkerLabel as F, waitForTerminalStatus as I, longInlinePromptHint as L, newWorkerId as M, nowStamp as N, contextPercent as O, saveStatus as P, parseRunnerArgs as R, appendLedger as S, ageOf as T, expandMcpNames as V, currentTabKey as _, projectLaunchConfig as a, sessionTag as b, discardWorker as c, readInbox as d, sayToWorker as f, openPaneForWorker as g, openFollowPane as h, usageContextTokens as i, loadStatuses as j, isChatPane as k, mergeWorker as l, checkPaneForWorker as m, runWorker as n, parseWorkerReport as o, workerDepth as p, testProvider as r, renderReport as s, printResult as t, handoffFromInside as u, itermForClaudeSession as v, UNLABELED as w, workerInScope as x, resolveSession as y, shortText as z };
+//# sourceMappingURL=run-BgExF8Xg.mjs.map