@tekmidian/pai 0.37.0 → 0.39.0

package/dist/{providers-sXcK5bDZ.mjs → chain-CTtHligI.mjs}

@@ -1,7 +1,7 @@
 import { n as CONFIG_FILE } from "./config-B64vFg14.mjs";
-import { appendFileSync, chmodSync, closeSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
+import { appendFileSync, closeSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, renameSync, rmSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { basename, dirname, join, relative } from "node:path";
+import { dirname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import { connect, createServer } from "node:net";
 import { execFileSync, spawn } from "node:child_process";
@@ -104,6 +104,28 @@ function writeJsonAtomic(path, data, opts = {}) {
 * `engine: "codex"` providers run through the Codex CLI instead of Claude
 * Code.
 */
+const DEFAULT_COST_TIER = 3;
+/** Tags a provider may carry; classes filter auto-routing on them. */
+const PROVIDER_TAGS = [
+	"code",
+	"vision",
+	"image-gen",
+	"long-context",
+	"fast",
+	"reasoning"
+];
+/** The standard task classes; `workers.classes` maps each to a target. */
+const WORKER_CLASSES = [
+	"draft",
+	"plan",
+	"implement",
+	"review",
+	"research",
+	"spotcheck",
+	"simple",
+	"complex",
+	"image"
+];
 const DEFAULT_LOG_DIR = "~/.claude/logs/workers";
 const DEFAULT_PANE = {
 	enabled: true,
@@ -115,19 +137,32 @@ const DEFAULT_ROUTING = {
 	cooldownMinutes: 30,
 	retryOnQuota: true
 };
+const DEFAULT_TREE = {
+	maxDepth: 2,
+	maxChildren: 4
+};
+/**
+* The default MCP sets every config starts from. `desktop` names the clickr
+* server so `--mcp desktop` hands a worker the machine controls (read-only
+* tools always; actuating ones after the operator hands the controls over,
+* see `pai worker controls`). A user's mcpSets section is merged over this,
+* so `desktop: []` removes the set deliberately.
+*/
+const DEFAULT_MCP_SETS = { desktop: ["clickr"] };
 function defaultWorkersConfig() {
 	return {
 		enabled: false,
 		active: null,
 		providers: {},
-		roles: {},
-		mcpSets: {},
+		classes: {},
+		mcpSets: { ...DEFAULT_MCP_SETS },
 		pane: { ...DEFAULT_PANE },
 		logDir: DEFAULT_LOG_DIR,
 		routing: {
 			...DEFAULT_ROUTING,
 			order: []
-		}
+		},
+		tree: { ...DEFAULT_TREE }
 	};
 }
 var WorkersConfigError = class extends Error {};
@@ -171,6 +206,16 @@ function parseProvider(name, raw) {
 	}
 	const upstreamUrl = str(p.upstreamUrl);
 	if (protocol === "openai" && !upstreamUrl) bad(`.providers.${name}.upstreamUrl`, `is required for protocol "openai" (the Chat Completions base, e.g. "https://api.openai.com/v1")`);
+	const costTier = p.costTier === void 0 ? void 0 : p.costTier;
+	if (costTier !== void 0) {
+		if (typeof costTier !== "number" || !Number.isInteger(costTier) || costTier < 1 || costTier > 5) bad(`.providers.${name}.costTier`, "must be an integer 1 (cheapest) … 5 (most expensive)");
+	}
+	let tags;
+	if (p.tags !== void 0) {
+		if (!Array.isArray(p.tags) || p.tags.some((x) => typeof x !== "string")) bad(`.providers.${name}.tags`, `must be an array of tags from: ${PROVIDER_TAGS.join(", ")}`);
+		for (const t of p.tags) if (!PROVIDER_TAGS.includes(t)) bad(`.providers.${name}.tags`, `"${t}" is not a tag (from: ${PROVIDER_TAGS.join(", ")})`);
+		tags = p.tags;
+	}
 	return {
 		enabled: p.enabled === void 0 ? true : p.enabled === true,
 		protocol,
@@ -186,7 +231,9 @@ function parseProvider(name, raw) {
 		...engine !== "claude" ? { engine } : {},
 		...str(p.quotaProbe) ? { quotaProbe: str(p.quotaProbe) } : {},
 		...quotaSkipAt !== void 0 ? { quotaSkipAt } : {},
-		...contextWindow !== void 0 ? { contextWindow } : {}
+		...contextWindow !== void 0 ? { contextWindow } : {},
+		...costTier !== void 0 ? { costTier } : {},
+		...tags ? { tags } : {}
 	};
 }
 /**
@@ -203,29 +250,50 @@ function parseWorkersConfig(raw) {
 		if (typeof w.providers !== "object" || w.providers === null || Array.isArray(w.providers)) bad(".providers", "must be an object keyed by provider name");
 		for (const [name, p] of Object.entries(w.providers)) providers[name] = parseProvider(name, p);
 	}
-	const roles = {};
-	if (w.roles !== void 0) {
-		if (typeof w.roles !== "object" || w.roles === null || Array.isArray(w.roles)) bad(".roles", "must be an object of role → provider[/alias] or {provider, mcp}");
-		for (const [role, target] of Object.entries(w.roles)) if (typeof target === "object" && target !== null && !Array.isArray(target)) {
+	const classes = {};
+	const classesRaw = w.classes !== void 0 ? w.classes : w.roles;
+	if (classesRaw !== void 0) {
+		if (typeof classesRaw !== "object" || classesRaw === null || Array.isArray(classesRaw)) bad(w.classes !== void 0 ? ".classes" : ".roles", "must be an object of class → provider[/alias] or {provider, mcp, maxCostTier, requireTags, order}");
+		for (const [cls, target] of Object.entries(classesRaw)) if (typeof target === "object" && target !== null && !Array.isArray(target)) {
 			const o = target;
 			const provider = str(o.provider);
-			if (!provider || provider.includes(" ")) bad(`.roles.${role}.provider`, `invalid provider "${provider}"`);
+			if (o.provider !== void 0 && (!provider || provider.includes(" "))) bad(`.classes.${cls}.provider`, `invalid provider "${provider}"`);
 			let mcp;
 			if (o.mcp !== void 0) {
-				if (!Array.isArray(o.mcp) || o.mcp.some((x) => typeof x !== "string")) bad(`.roles.${role}.mcp`, "must be an array of MCP server or set names");
+				if (!Array.isArray(o.mcp) || o.mcp.some((x) => typeof x !== "string")) bad(`.classes.${cls}.mcp`, "must be an array of MCP server or set names");
 				mcp = o.mcp;
 			}
-			roles[role] = mcp ? {
-				provider,
-				mcp
-			} : { provider };
+			let maxCostTier;
+			if (o.maxCostTier !== void 0) {
+				if (typeof o.maxCostTier !== "number" || !Number.isInteger(o.maxCostTier) || o.maxCostTier < 1 || o.maxCostTier > 5) bad(`.classes.${cls}.maxCostTier`, "must be an integer 1 … 5");
+				maxCostTier = o.maxCostTier;
+			}
+			let requireTags;
+			if (o.requireTags !== void 0) {
+				if (!Array.isArray(o.requireTags) || o.requireTags.some((x) => typeof x !== "string")) bad(`.classes.${cls}.requireTags`, `must be an array of tags from: ${PROVIDER_TAGS.join(", ")}`);
+				for (const t of o.requireTags) if (!PROVIDER_TAGS.includes(t)) bad(`.classes.${cls}.requireTags`, `"${t}" is not a tag (from: ${PROVIDER_TAGS.join(", ")})`);
+				requireTags = o.requireTags;
+			}
+			let order;
+			if (o.order !== void 0) {
+				if (!Array.isArray(o.order) || o.order.some((x) => typeof x !== "string")) bad(`.classes.${cls}.order`, "must be an array of provider names");
+				order = o.order;
+			}
+			const obj = {
+				...provider ? { provider } : {},
+				...mcp ? { mcp } : {},
+				...maxCostTier !== void 0 ? { maxCostTier } : {},
+				...requireTags ? { requireTags } : {},
+				...order ? { order } : {}
+			};
+			classes[cls] = Object.keys(obj).length ? obj : {};
 		} else {
 			const t = str(target);
-			if (!t || t.includes(" ")) bad(`.roles.${role}`, `invalid target "${t}"`);
-			roles[role] = t;
+			if (!t || t.includes(" ")) bad(`.classes.${cls}`, `invalid target "${t}"`);
+			classes[cls] = t;
 		}
 	}
-	const mcpSets = {};
+	const mcpSets = { ...DEFAULT_MCP_SETS };
 	if (w.mcpSets !== void 0) {
 		if (typeof w.mcpSets !== "object" || w.mcpSets === null || Array.isArray(w.mcpSets)) bad(".mcpSets", "must be an object of set name → [server names]");
 		for (const [setName, servers] of Object.entries(w.mcpSets)) {
@@ -265,17 +333,33 @@ function parseWorkersConfig(raw) {
 			retryOnQuota: r.retryOnQuota === void 0 ? DEFAULT_ROUTING.retryOnQuota : r.retryOnQuota === true
 		};
 	}
+	let tree = { ...DEFAULT_TREE };
+	if (w.tree !== void 0) {
+		if (typeof w.tree !== "object" || w.tree === null || Array.isArray(w.tree)) bad(".tree", "must be an object");
+		const t = w.tree;
+		if (t.maxDepth !== void 0) {
+			if (typeof t.maxDepth !== "number" || !Number.isInteger(t.maxDepth) || t.maxDepth < 0) bad(".tree.maxDepth", "must be a non-negative integer");
+		}
+		if (t.maxChildren !== void 0) {
+			if (typeof t.maxChildren !== "number" || !Number.isInteger(t.maxChildren) || t.maxChildren < 1) bad(".tree.maxChildren", "must be a positive integer");
+		}
+		tree = {
+			maxDepth: t.maxDepth === void 0 ? DEFAULT_TREE.maxDepth : t.maxDepth,
+			maxChildren: t.maxChildren === void 0 ? DEFAULT_TREE.maxChildren : t.maxChildren
+		};
+	}
 	const active = w.active === void 0 || w.active === null ? null : str(w.active);
 	if (active !== null && active !== "auto" && !(active in providers)) {}
 	return {
 		enabled: w.enabled === void 0 ? d.enabled : w.enabled === true,
 		active,
 		providers,
-		roles,
+		classes,
 		mcpSets,
 		pane,
 		logDir: str(w.logDir) || d.logDir,
-		routing
+		routing,
+		tree
 	};
 }
 /**
@@ -308,6 +392,10 @@ function providerKeyPath(p) {
 	return p.keyFile ? expandHome(p.keyFile) : null;
 }
 const DEFAULT_CONTEXT_WINDOW = 2e5;
+/** Cost tier of a provider for class filtering (unset = 3, the middle). */
+function providerCostTier(p) {
+	return p.costTier ?? DEFAULT_COST_TIER;
+}
 /** Context window used by the meter when the init event carries none. */
 function providerContextWindow(p) {
 	return p.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
@@ -525,9 +613,18 @@ function nowStamp(d = /* @__PURE__ */ new Date()) {
 	const p = (n) => String(n).padStart(2, "0");
 	return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
 }
+let lastId = "";
+let idSeq = 0;
 function newWorkerId(d = /* @__PURE__ */ new Date(), pid = process.pid) {
 	const p = (n) => String(n).padStart(2, "0");
-	return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}-${pid}`;
+	const base = `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}-${pid}`;
+	if (base === lastId) {
+		idSeq += 1;
+		return `${base}-${String(idSeq).padStart(2, "0")}`;
+	}
+	lastId = base;
+	idSeq = 0;
+	return base;
 }
 /** Write status atomically (temp + rename) and stamp `updated`. */
 function saveStatus(logDir, status, d = /* @__PURE__ */ new Date()) {
@@ -676,16 +773,19 @@ function sessionTag(worker) {
 //#endregion
 //#region src/workers/routing.ts
 /**
-* routing.ts — provider selection: flag > role > active (possibly "auto").
+* routing.ts — provider selection: flag > class > active (possibly "auto").
 *
-* Auto-routing walks `workers.routing.order` and takes the first provider
-* that is enabled, out of cooldown, and (when it defines a quotaProbe) under
-* its quotaSkipAt threshold. A run that dies of a quota/rate error puts its
-* provider in cooldown for cooldownMinutes; when that happens before the
-* first tool call and retryOnQuota is set, the runner restarts the same task
-* on the next provider (ledger: WORKER-REROUTE).
+* Auto-routing walks `workers.routing.order` — or the class's own `order` —
+* and takes the first provider that is enabled, out of cooldown, (when it
+* defines a quotaProbe) under its quotaSkipAt threshold, and — when the class
+* constrains it — within `maxCostTier` and carrying all `requireTags`. A run
+* that dies of a quota/rate error puts its provider in cooldown for
+* cooldownMinutes; when that happens before the first tool call and
+* retryOnQuota is set, the runner restarts the same task on the next provider
+* (ledger: WORKER-REROUTE).
 *
-* An explicit --provider or --role always bypasses all of this.
+* An explicit --provider or a class mapping that pins a provider always
+* bypasses all of this.
 */
 const QUOTA_SKIP_DEFAULT = 95;
 const PROBE_TIMEOUT_MS = 1e4;
@@ -764,34 +864,61 @@ function mustBeRunnable(name, p) {
 	if (!p.enabled) throw new NoProviderError(`provider "${name}" is disabled. Enable it with: pai worker providers enable ${name}`);
 	return p;
 }
+/** Why one provider of a routing order did not qualify (message fragment). */
+function exclusionReason(config, state, name, cls) {
+	const p = config.providers[name];
+	if (!p) return "not configured";
+	if (!p.enabled) return "disabled";
+	if (cooldownRemaining(state, name) > 0) return "cooldown";
+	if (quotaExceeded(p)) return "quota";
+	const tier = providerCostTier(p);
+	if (cls?.maxCostTier !== void 0 && tier > cls.maxCostTier) return `cost tier ${tier} > max ${cls.maxCostTier}`;
+	if (cls?.requireTags?.length) {
+		const have = p.tags ?? [];
+		const missing = cls.requireTags.filter((t) => !have.includes(t));
+		if (missing.length) return `missing tags: ${missing.join(", ")}`;
+	}
+	return null;
+}
 /**
 * Resolve which provider (and model alias) a run uses.
 *
 * @param flagProvider --provider value, highest precedence
-* @param role         --role value, looked up in workers.roles
+* @param className    --class value (the old --role), looked up in workers.classes
 */
 function resolveTarget(config, logDir, opts = {}) {
 	if (opts.flagProvider) return {
 		providerName: opts.flagProvider,
 		provider: mustBeRunnable(opts.flagProvider, mustExist(config, opts.flagProvider)),
 		modelAlias: null,
-		roleMcp: null,
+		classMcp: null,
 		via: "flag"
 	};
-	if (opts.role) {
-		const target = config.roles[opts.role];
-		if (!target) throw new NoProviderError(`no role named "${opts.role}". Defined: ${Object.keys(config.roles).join(", ") || "(none)"}.\nSet one with: pai worker roles set ${opts.role}=<provider[/alias]>`);
-		const name = typeof target === "string" ? target.split("/")[0] : target.provider;
-		const alias = typeof target === "string" ? target.split("/")[1] : void 0;
-		const roleMcp = typeof target === "string" ? null : target.mcp ?? null;
+	const clsTarget = opts.className ? config.classes[opts.className] : void 0;
+	const cls = typeof clsTarget === "object" && clsTarget !== null ? clsTarget : void 0;
+	if (opts.className && clsTarget !== void 0 && typeof clsTarget !== "object") {
+		const [name, alias] = clsTarget.split("/");
 		return {
 			providerName: name,
 			provider: mustBeRunnable(name, mustExist(config, name)),
 			modelAlias: alias ?? null,
-			roleMcp,
-			via: "role"
+			classMcp: null,
+			via: "class"
+		};
+	}
+	if (opts.className && cls?.provider) {
+		const provider = mustBeRunnable(cls.provider, mustExist(config, cls.provider));
+		return {
+			providerName: cls.provider,
+			provider,
+			modelAlias: null,
+			classMcp: cls.mcp ?? null,
+			via: "class"
 		};
 	}
+	if (opts.className && clsTarget === void 0) {
+		if (!WORKER_CLASSES.includes(opts.className)) throw new NoProviderError(`no class named "${opts.className}". Standard classes: ${WORKER_CLASSES.join(", ")}.Defined: ${Object.keys(config.classes).join(", ") || "(none)"}.\nSet one with: pai worker classes set ${opts.className}=<provider[/alias]>`);
+	}
 	if (config.active !== "auto") {
 		const name = config.active;
 		if (!name) throw new NoProviderError("no active worker provider. Add one with: pai worker providers add <name> --base-url <url> --key-file <path> --model <model>\n(or point one that exists at it: pai worker providers use <name>)");
@@ -799,32 +926,29 @@ function resolveTarget(config, logDir, opts = {}) {
 			providerName: name,
 			provider: mustBeRunnable(name, mustExist(config, name)),
 			modelAlias: null,
-			roleMcp: null,
+			classMcp: null,
 			via: "active"
 		};
 	}
 	const state = readRoutingState(logDir);
-	const skipped = [];
-	for (const name of config.routing.order) {
+	const order = cls?.order ?? config.routing.order;
+	const excluded = [];
+	for (const name of order) {
 		const p = config.providers[name];
-		if (!p || !p.enabled) continue;
-		if (cooldownRemaining(state, name) > 0) {
-			skipped.push(`${name}(cooldown)`);
-			continue;
-		}
-		if (quotaExceeded(p)) {
-			skipped.push(`${name}(quota)`);
+		const why = exclusionReason(config, state, name, cls);
+		if (why) {
+			excluded.push(`${name}: ${why}`);
 			continue;
 		}
 		return {
 			providerName: name,
 			provider: p,
 			modelAlias: null,
-			roleMcp: null,
+			classMcp: cls?.mcp ?? null,
 			via: "auto"
 		};
 	}
-	throw new NoProviderError(`auto-routing found no usable provider (order: [${config.routing.order.join(", ")}]${skipped.length ? `; skipped: ${skipped.join(", ")}` : ""}).\nClear a cooldown with: pai worker providers enable <name>`);
+	throw new NoProviderError(`auto-routing found no usable provider${opts.className ? ` for class "${opts.className}"` : ""} (order: [${order.join(", ")}]).${excluded.length ? `\nExcluded: ${excluded.join("; ")}.` : ""}\nClear a cooldown with: pai worker providers enable <name>; widen the class with: pai worker classes set ${opts.className ?? "<class>"}=<target>`);
 }
 /**
 * Next provider after `from` in auto order, applying the same filters.
@@ -859,11 +983,13 @@ function isQuotaFailure(resultText) {
 * pane.ts — the per-worker follow pane in iTerm2.
 *
 * One small-font pane per worker, stacked in a right-hand column: the first
-* worker of a scope splits the launching session vertically (right, ~40% of
-* the columns), every further one splits the lowest live worker pane
-* horizontally, so panes stack top to bottom. Each pane runs
-* `pai worker follow <id> --auto-exit <n>` under the `pai-worker` dynamic
-* profile (Close Sessions On End), so panes disappear by themselves.
+* worker of a scope splits the launching session vertically, every further
+* one splits the lowest live worker pane horizontally, so panes stack top to
+* bottom. The split never sizes the new session — that would grow the whole
+* window; instead the window's bounds are read before the split and restored
+* right after, so the panes share the space the window already had. Each
+* pane runs `pai worker follow <id> --auto-exit <n>` under the `pai-worker`
+* dynamic profile (Close Sessions On End), so panes disappear by themselves.
 *
 * Panes are tracked per scope (AIBroker session id, else tab key) in
 * <logDir>/panes/<key>.json, keyed by iTerm session unique id, newest first —
@@ -893,10 +1019,14 @@ const WORKER_SPLIT_SCRIPT = `on run(argv)
             repeat with t in tabs of w
                 repeat with s in sessions of t
                     if id of s is targetID then
-                        set parentCols to missing value
-                        try
-                            set parentCols to columns of s
-                        end try
+                        -- sizing the new session would grow the whole window:
+                        -- pin the window's bounds now and restore them after
+                        -- the split, so the panes share the existing space.
+                        -- copy, never set: set stores the property
+                        -- reference lazily, so restoring it would re-read the
+                        -- post-split bounds instead of these — observed as the
+                        -- window jumping to the main display
+                        copy bounds of w to winBounds
                         set sessIDs to {}
                         repeat with other in sessions of t
                             set end of sessIDs to (id of other as text)
@@ -936,13 +1066,9 @@ const WORKER_SPLIT_SCRIPT = `on run(argv)
                         tell newS
                             write text followCmd
                         end tell
-                        if splitS is missing value and parentCols is not missing value then
-                            try
-                                tell newS
-                                    set columns to (round (parentCols * 0.4))
-                                end tell
-                            end try
-                        end if
+                        try
+                            set bounds of w to winBounds
+                        end try
                         set out to ""
                         repeat with lid in lived
                             set out to out & lid & ","
@@ -987,6 +1113,27 @@ const TAB_TTYS_SCRIPT = `on run(argv)
     end tell
     return "notfound"
 end run`;
+const WINDOW_BOUNDS_SCRIPT = `on run(argv)
+    set targetID to item 1 of argv
+    tell application id "com.googlecode.iterm2"
+        if not running then return "notrunning"
+        repeat with w in windows
+            repeat with t in tabs of w
+                repeat with s in sessions of t
+                    if id of s is targetID then
+                        copy bounds of w to winBounds
+                        set prevDels to AppleScript's text item delimiters
+                        set AppleScript's text item delimiters to ", "
+                        set out to winBounds as text
+                        set AppleScript's text item delimiters to prevDels
+                        return out
+                    end if
+                end repeat
+            end repeat
+        end repeat
+    end tell
+    return "notfound"
+end run`;
 const SPLIT_SCRIPT = `on run(argv)
     set targetID to item 1 of argv
     set followCmd to item 2 of argv
@@ -1031,7 +1178,7 @@ function osascript(script, args) {
 		proc.stdin.end();
 	});
 }
-function psOutput$1(format) {
+function psOutput(format) {
 	try {
 		return execFileSync("ps", ["-axo", format], { encoding: "utf8" });
 	} catch {
@@ -1041,7 +1188,7 @@ function psOutput$1(format) {
 /** TTys of running `worker follow` processes, normalised to /dev/ttysNNN. */
 function followTtys() {
 	const ttys = /* @__PURE__ */ new Set();
-	for (const line of psOutput$1("tty=,command=").split("\n")) {
+	for (const line of psOutput("tty=,command=").split("\n")) {
 		const parts = line.trim().split(/\s+/, 2);
 		if (parts.length < 2 || parts[0] === "ps") continue;
 		if (!/(^|\/)(worker-follow|pai worker follow|glm-ps follow)\b/.test(parts[1])) continue;
@@ -1052,7 +1199,7 @@ function followTtys() {
 /** True while a `follow <wid>` process runs (its pane shows that worker). */
 function workerPaneOpen(wid) {
 	const pat = new RegExp(`(?:worker follow|worker-follow|glm-ps follow) ${wid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`);
-	return psOutput$1("command=").split("\n").some((ln) => pat.test(ln));
+	return psOutput("command=").split("\n").some((ln) => pat.test(ln));
 }
 /** plutil's message for an ExecFileSync failure, else the exception text. */
 function toolErr(e) {
@@ -1257,12 +1404,31 @@ async function openPaneForWorker(logDir, config, wid, term) {
 	return `pane opened for ${wid}`;
 }
 /**
+* One `--check` line with the bounds of the window hosting `term`'s iTerm
+* session — the before/after pair that shows whether a split moved it.
+* Read-only; never touches the window.
+*/
+async function windowBoundsLine(term) {
+	const uid = itermUuid(term);
+	if (!uid) return "window bounds: (not in iTerm2)";
+	try {
+		const p = await osascript(WINDOW_BOUNDS_SCRIPT, [uid]);
+		const out = p.stdout.trim();
+		if (out && out !== "notfound" && out !== "notrunning") return `window bounds: ${out}`;
+		return `window bounds: (${out === "notfound" ? "iTerm2 session not found" : out === "notrunning" ? "iTerm2 not running" : (p.stderr.trim() || "no output").slice(0, 120)})`;
+	} catch (e) {
+		return `window bounds: (osascript: ${String(e.message ?? e).slice(0, 120)})`;
+	}
+}
+/**
 * Report-only variant used by `pai worker pane <id> --check`: whether a pane
-* runs for the worker, plus the dynamic profile's path, its existence, and
-* the font it contains (or, when missing, would write).
+* runs for the worker, the bounds of the window hosting the asking session,
+* plus the dynamic profile's path, its existence, and the font it contains
+* (or, when missing, would write).
 */
-async function checkPaneForWorker(wid, fontSize) {
+async function checkPaneForWorker(wid, fontSize, term) {
 	const lines = [workerPaneOpen(wid) ? `pane for ${wid} open` : `no pane for ${wid}`];
+	lines.push(await windowBoundsLine(term));
 	const path = dynamicProfilePath();
 	if (existsSync(path)) {
 		let font = "(unreadable)";
@@ -1297,6 +1463,483 @@ async function openFollowPane(logDir, _config, term, checkOnly) {
 	throw new Error(`pai worker pane: osascript failed: ${(s.stderr || sout).slice(0, 200)}`);
 }
 
+//#endregion
+//#region src/workers/tree.ts
+/** The env var the runner sets in every worker's environment. */
+const WORKER_ID_ENV = "PAI_WORKER_ID";
+/** The worker this process runs inside, when it runs inside one. */
+function parentFromEnv(env = process.env) {
+	const id = env[WORKER_ID_ENV];
+	return typeof id === "string" && id.trim() ? id.trim() : null;
+}
+/**
+* Depth of `id` in the worker forest: 0 for a top-level worker, 1 + the
+* parent's depth for a sub-worker. Parents without a status file (chain ids,
+* unknown ids) count as roots; a cycle reads as its own depth and is cut off
+* after the statuses it walked.
+*/
+function workerDepth(statuses, id) {
+	const byId = new Map(statuses.map((s) => [s.id, s]));
+	let depth = 0;
+	let cur = byId.get(id);
+	const seen = new Set([id]);
+	while (cur?.parent && !seen.has(cur.parent)) {
+		seen.add(cur.parent);
+		const next = byId.get(cur.parent);
+		if (!next) break;
+		depth += 1;
+		cur = next;
+	}
+	return depth;
+}
+/** Children of `parent` that are still running, oldest first. */
+function runningChildren(statuses, parent) {
+	return statuses.filter((s) => s.parent === parent && s.state === "running" && alive(s.pid));
+}
+/**
+* Would starting a child of `parent` stay within the caps? Throws with a
+* clear message when it would not; returns silently when `parent` has no
+* status file (a chain id or an unknown id — not a worker, not capped).
+*/
+function assertChildAllowed(logDir, parent, caps, statuses = loadStatuses(logDir)) {
+	if (!statuses.some((s) => s.id === parent)) return;
+	const depth = workerDepth(statuses, parent);
+	if (depth + 1 > caps.maxDepth) throw new Error(`worker tree: ${parent} sits at depth ${depth} and workers.tree.maxDepth is ${caps.maxDepth} — it cannot start another level of sub-workers. Hand the task up instead: pai worker handoff '{"kind":"proposal","text":"…"}'`);
+	const kids = runningChildren(statuses, parent);
+	if (kids.length >= caps.maxChildren) throw new Error(`worker tree: ${parent} already has ${kids.length} running sub-workers (${kids.map((k) => k.id).join(", ")}) and workers.tree.maxChildren is ${caps.maxChildren} — wait for one to finish, or raise the cap in the workers config`);
+}
+/**
+* The parent a launch should record: an explicit one (chain stage) wins, else
+* the worker this process runs inside. Returns null for top-level runs.
+*/
+function launchParent(explicit, env = process.env) {
+	return explicit ?? parentFromEnv(env);
+}
+/** Does a status file exist for `id` (i.e. is it a worker rather than a chain)? */
+function isWorkerId(logDir, id) {
+	return loadStatus(logDir, id) !== null;
+}
+
+//#endregion
+//#region src/workers/operator.ts
+/**
+* operator.ts — talking to a running worker.
+*
+* Headless workers run with `--input-format stream-json` and their stdin held
+* open, so a run is a conversation: every line sent to the per-worker Unix
+* socket `<logDir>/<id>.sock` is forwarded to the child as a user message and
+* mirrored into the transcript as an `operator` event (rendered with a »
+* marker). Once the worker has finished its turn, stdin closes 2 s later
+* unless a new message arrives — after that, `say` refuses and `resume`
+* continues the same Claude session with the worker's context intact.
+*/
+function operatorSocketPath(logDir, id) {
+	return join(logDir, `${id}.sock`);
+}
+/**
+* The runner's side: listen on the worker socket, hand every received line to
+* `onLine`. Returns the server (close it when the run ends; the socket file is
+* unlinked on close, best effort).
+*/
+function createOperatorServer(logDir, id, onLine) {
+	const path = operatorSocketPath(logDir, id);
+	try {
+		if (existsSync(path)) unlinkSync(path);
+	} catch {}
+	const server = createServer((socket) => {
+		let buf = "";
+		socket.on("data", (chunk) => {
+			buf += chunk.toString("utf8");
+			let nl;
+			while ((nl = buf.indexOf("\n")) >= 0) {
+				const line = buf.slice(0, nl).replace(/\r$/, "");
+				buf = buf.slice(nl + 1);
+				if (line.trim()) onLine(line);
+				socket.write("ok\n");
+			}
+		});
+	});
+	server.listen(path);
+	server.on("close", () => {
+		try {
+			if (existsSync(path)) unlinkSync(path);
+		} catch {}
+	});
+	return server;
+}
+/**
+* `pai worker say <id> "<text>"`: forward one line to a running worker.
+* Resolves "ok", rejects with a clear message when the worker is not running.
+*/
+function sayToWorker(logDir, id, text, timeoutMs = 4e3) {
+	const status = loadStatus(logDir, id);
+	if (!status) return Promise.reject(/* @__PURE__ */ new Error(`no worker named "${id}"`));
+	if (status.state !== "running" || !alive(status.pid)) return Promise.reject(/* @__PURE__ */ new Error(`worker ${id} is not running (state: ${status.state}) — continue it instead with: pai worker resume ${id} "<text>"`));
+	const path = operatorSocketPath(logDir, id);
+	if (!existsSync(path)) return Promise.reject(/* @__PURE__ */ new Error(`worker ${id} has no operator socket (${path}) — it may predate this PAI version`));
+	return new Promise((resolve, reject) => {
+		const sock = connect(path);
+		const fail = (e) => {
+			sock.destroy();
+			reject(/* @__PURE__ */ new Error(`cannot talk to worker ${id}: ${e.message}`));
+		};
+		sock.setTimeout(timeoutMs, () => fail(/* @__PURE__ */ new Error("timeout")));
+		sock.once("error", (e) => fail(e));
+		sock.once("connect", () => {
+			sock.write(text.replace(/\n/g, " ") + "\n");
+		});
+		sock.once("data", () => {
+			sock.end();
+			resolve("ok");
+		});
+	});
+}
+
+//#endregion
+//#region src/workers/handoff.ts
+/**
+* handoff.ts — upward messages between workers.
+*
+* Coordination in the worker tree is upward only: a child appends a handoff
+* to `<logDir>/<parent>.inbox.jsonl` and (when the parent is a running
+* worker) the same text is said to it, so it lands in the parent's
+* conversation as `[handoff from <child>] …`. The parent's pane renders the
+* inbox as `◆` lines, `ps`/`worker_status` show an inbox count, and a child
+* that finishes delivers its structured report automatically as a
+* `kind: "result"` handoff. There is no downward or sideways path — telling
+* a worker something is the operator's job (`pai worker say`).
+*/
+const HANDOFF_KINDS = [
+	"proposal",
+	"result",
+	"question",
+	"blocker"
+];
+/** Where a worker's handoffs land: <logDir>/<id>.inbox.jsonl. */
+function inboxPath(logDir, id) {
+	return join(logDir, `${id}.inbox.jsonl`);
+}
+function isHandoffKind(v) {
+	return typeof v === "string" && HANDOFF_KINDS.includes(v);
+}
+/**
+* Normalize a raw parsed value into a Handoff, or explain what is missing.
+* `from`/`to` may be preset by the caller (the CLI fills them from the
+* environment); everything else must be present and well-formed.
+*/
+function parseHandoff(v, preset = {}) {
+	if (typeof v !== "object" || v === null || Array.isArray(v)) throw new Error("handoff payload must be a JSON object");
+	const o = v;
+	const from = typeof o.from === "string" && o.from ? o.from : preset.from;
+	const to = typeof o.to === "string" && o.to ? o.to : preset.to;
+	if (!from) throw new Error(`handoff needs "from" (the sending worker id)`);
+	if (!to) throw new Error(`handoff needs "to" (the parent worker id)`);
+	if (!isHandoffKind(o.kind)) throw new Error(`handoff "kind" must be one of: ${HANDOFF_KINDS.join(", ")}`);
+	const text = typeof o.text === "string" ? o.text : "";
+	if (!text.trim()) throw new Error(`handoff needs a non-empty "text"`);
+	const data = typeof o.data === "object" && o.data !== null && !Array.isArray(o.data) ? o.data : void 0;
+	return {
+		from,
+		to,
+		kind: o.kind,
+		text,
+		...data ? { data } : {}
+	};
+}
+/** Append one handoff to its recipient's inbox, stamped now. */
+function appendHandoff(logDir, h, now = /* @__PURE__ */ new Date()) {
+	const path = inboxPath(logDir, h.to);
+	const dir = dirname(path);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	appendFileSync(path, JSON.stringify({
+		...h,
+		_ts: now.toISOString()
+	}) + "\n", "utf8");
+}
+/** Every handoff in a worker's inbox, oldest first; damaged lines skip. */
+function readInbox(logDir, id) {
+	const path = inboxPath(logDir, id);
+	if (!existsSync(path)) return [];
+	const out = [];
+	for (const line of readFileSync(path, "utf8").split("\n")) {
+		if (!line.trim()) continue;
+		try {
+			out.push(JSON.parse(line));
+		} catch {}
+	}
+	return out;
+}
+/** How the say path prefixes a handoff so the parent model knows its source. */
+function handoffMessage(h) {
+	return `[handoff from ${h.from}] (${h.kind}) ${h.text.replace(/\s+/g, " ").trim()}`;
+}
+/** True for the exact shape of handoffMessage() — the runner marks the mirror. */
+function isHandoffMessage(text) {
+	return new RegExp(`^\\[handoff from \\S+\\] \\((${HANDOFF_KINDS.join("|")})\\) `).test(text);
+}
+/**
+* Deliver one handoff: append it to the parent's inbox, then — when the
+* parent is a running worker with a live operator socket — say it so it
+* enters the parent's conversation. The say is best effort: a parent that is
+* busy, finished or gone still has the inbox line, and nothing here may make
+* a finishing child's exit path fail.
+*/
+async function deliverHandoff(logDir, h, deps = {}, now = /* @__PURE__ */ new Date()) {
+	appendHandoff(logDir, h, now);
+	const say = deps.say ?? ((id, text) => sayToWorker(logDir, id, text));
+	const parent = loadStatus(logDir, h.to);
+	if (parent && parent.state === "running" && alive(parent.pid)) try {
+		await say(h.to, handoffMessage(h));
+	} catch {}
+	return h;
+}
+/**
+* Send a handoff from inside a worker (the `pai worker handoff` CLI and the
+* MCP tool both land here): the sender comes from PAI_WORKER_ID, the
+* recipient from its status file's `parent`. Rejects with a clear message
+* outside a worker or under a parentless worker.
+*/
+async function handoffFromInside(logDir, env, payload, deps = {}) {
+	const mine = env.PAI_WORKER_ID;
+	if (!mine) throw new Error("not inside a worker — handoffs are sent by workers (PAI_WORKER_ID unset). Talk to a running worker with: pai worker say <id> \"<text>\"");
+	const st = loadStatus(logDir, mine);
+	if (!st) throw new Error(`no status for this worker (${mine}) — cannot find its parent`);
+	if (!st.parent || !loadStatus(logDir, st.parent)) throw new Error(`worker ${mine} has no worker parent to hand off to (parent: ${st.parent ?? "(none)"}) — handoffs go up the worker tree only`);
+	return deliverHandoff(logDir, parseHandoff(payload, {
+		from: mine,
+		to: st.parent
+	}), deps);
+}
+
+//#endregion
+//#region src/workers/worktree.ts
+/**
+* worktree.ts — one git worktree per writing worker.
+*
+* A run whose class edits files (implement, complex, plan) and whose cwd is a
+* git repository gets its own worktree by default: `git worktree add
+* <logDir>/worktrees/<id> -b worker/<id>` from the current HEAD. The worker
+* commits its own work on that branch — the no-commit rule applies to the
+* main branch only — and the parent (or the operator) merges the result back:
+*
+*   pai worker merge <id>     git merge --no-ff worker/<id> + remove worktree
+*   pai worker discard <id>   remove worktree and branch, keep nothing
+*
+* `ps` marks a worker with an unmerged branch `⎇`. Draft and review run in
+* place; `--no-worktree` opts out, `--worktree` forces one on.
+*/
+function worktreesDir(logDir) {
+	return join(logDir, "worktrees");
+}
+function worktreeBranch(id) {
+	return `worker/${id}`;
+}
+function worktreePath(logDir, id) {
+	return join(worktreesDir(logDir), id);
+}
+/** Run git in `cwd`, returning trimmed stdout; throws with stderr on failure. */
+function git(cwd, args) {
+	try {
+		return execFileSync("git", [
+			"-C",
+			cwd,
+			...args
+		], {
+			encoding: "utf8",
+			timeout: 3e4,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+	} catch (e) {
+		const err = e;
+		const why = (typeof err.stderr === "string" ? err.stderr : err.stderr?.toString("utf8")) || err.message || String(e);
+		throw new Error(`git ${args.join(" ")} in ${cwd}: ${why.trim()}`);
+	}
+}
+/** Is `cwd` inside a git repository (a .git dir — worktrees: a .git file)? */
+function isGitRepo(cwd) {
+	try {
+		return git(cwd, ["rev-parse", "--git-dir"]) !== "";
+	} catch {
+		return false;
+	}
+}
+/**
+* Does the prompt read as a read-only task? Writing classes default to a
+* worktree; a prompt that only asks to look at things should not pay for one.
+* First-word verbs plus the explicit markers people actually write.
+*/
+function promptLooksReadonly(prompt) {
+	const p = prompt.trim();
+	if (!p) return true;
+	if (/\b(read[- ]only|do not (modify|change|edit|write)|don'?t (modify|change|edit|write)|no changes)\b/i.test(p)) return true;
+	return /^(review|read|analy[sz]e|research|summar[iy]|inspect|investigate|spotcheck|report|find|list|check|verify|describe|explain|show)\b/i.test(p);
+}
+/** The classes whose runs write files and therefore default to a worktree. */
+const WORKTREE_CLASSES = [
+	"implement",
+	"complex",
+	"plan"
+];
+/** Should this run get a worktree? Explicit flag first, then the default rule. */
+function worktreeWanted(flag, opts) {
+	if (flag !== void 0) return flag;
+	if (!opts.className || !WORKTREE_CLASSES.includes(opts.className)) return false;
+	if (!isGitRepo(opts.cwd)) return false;
+	return !promptLooksReadonly(opts.prompt ?? "");
+}
+/**
+* Create the worktree and branch for `id` from `cwd`'s HEAD. Throws when git
+* refuses (no commits yet, branch exists, …) — the caller decides whether to
+* degrade to an in-place run.
+*/
+function addWorktree(logDir, id, cwd) {
+	const dir = worktreePath(logDir, id);
+	const branch = worktreeBranch(id);
+	const base = git(cwd, ["rev-parse", "HEAD"]);
+	git(cwd, [
+		"worktree",
+		"add",
+		dir,
+		"-b",
+		branch
+	]);
+	return {
+		dir,
+		branch,
+		base
+	};
+}
+/** Commits the branch collected on top of its base. */
+function commitsSince(dir, base) {
+	try {
+		return parseInt(git(dir, [
+			"rev-list",
+			"--count",
+			`${base}..HEAD`
+		]), 10) || 0;
+	} catch {
+		return 0;
+	}
+}
+/**
+* Record the worktree result in the status file: branch and commit count on
+* success, the worktree cleaned up on failure. Returns the updated status.
+*/
+function recordWorktree(logDir, status, info, ok) {
+	const s = { ...status };
+	if (ok) {
+		s.branch = info.branch;
+		s.commits = commitsSince(info.dir, info.base);
+		s.worktreeDir = info.dir;
+		s.worktreeBase = info.base;
+	} else {
+		removeWorktree(s.cwd, info.dir, true);
+		try {
+			git(s.cwd, [
+				"branch",
+				"-D",
+				info.branch
+			]);
+		} catch {}
+		s.branch = null;
+		s.worktreeDir = null;
+		s.worktreeBase = null;
+		s.commits = null;
+	}
+	saveStatus(logDir, s);
+	return s;
+}
+/** Remove a worktree directory from git's books and the filesystem. */
+function removeWorktree(cwd, dir, force) {
+	try {
+		git(cwd, [
+			"worktree",
+			"remove",
+			...force ? ["--force"] : [],
+			dir
+		]);
+		return;
+	} catch {}
+	if (existsSync(dir)) try {
+		rmSync(dir, {
+			recursive: true,
+			force: true
+		});
+		git(cwd, ["worktree", "prune"]);
+	} catch {}
+}
+/**
+* `pai worker merge <id>`: merge the worker's branch into the original
+* checkout with --no-ff (the merge commit names the worker), then remove the
+* worktree. The branch stays for the record; the status gains `merged: true`.
+*/
+function mergeWorker(logDir, id) {
+	const st = mustHaveBranch(logDir, id);
+	if (st.merged) return `worker ${id}: branch ${st.branch} already merged`;
+	git(st.cwd, [
+		"merge",
+		"--no-ff",
+		st.branch,
+		"-m",
+		`merge worker ${id} (${st.label})`
+	]);
+	removeWorktree(st.cwd, st.worktreeDir, false);
+	saveStatus(logDir, {
+		...st,
+		merged: true
+	});
+	return `merged ${st.branch} into ${st.cwd} (worktree removed)`;
+}
+/** `pai worker discard <id>`: drop worktree and branch, keep nothing. */
+function discardWorker(logDir, id) {
+	const st = mustHaveBranch(logDir, id);
+	removeWorktree(st.cwd, st.worktreeDir, true);
+	let branchGone = false;
+	try {
+		git(st.cwd, [
+			"branch",
+			"-D",
+			st.branch
+		]);
+		branchGone = true;
+	} catch {
+		branchGone = false;
+	}
+	saveStatus(logDir, {
+		...st,
+		branch: null,
+		worktreeDir: null,
+		worktreeBase: null,
+		commits: null,
+		merged: false
+	});
+	return `discarded worker ${id}: worktree removed${branchGone ? `, branch ${st.branch} deleted` : ""}`;
+}
+function mustHaveBranch(logDir, id) {
+	const st = loadStatus(logDir, id);
+	if (!st) throw new Error(`no worker named "${id}"`);
+	if (!st.branch || !st.worktreeDir) throw new Error(`worker ${id} has no worktree branch to ${st.branch ? "clean up" : "merge"} — it ran in place or its branch was already handled`);
+	return st;
+}
+/**
+* The paragraph a worktree run's system prompt gains: it may commit on its
+* own branch (the no-commit rule holds for the main branch only), it must not
+* merge or push itself, and the parent or operator merges.
+*/
+function worktreeSystemPrompt(id, branch, dir) {
+	return [
+		"You are running in your own git worktree:",
+		`  ${dir} on branch ${branch} (worker id ${id}).`,
+		"Commit your work on that branch as you go (git add / git commit) — committing here is expected;",
+		"the no-commit rule applies to the main branch only, and this is not it.",
+		"Do not merge, rebase or push; the operator merges your branch back with `pai worker merge`."
+	].join("\n");
+}
+
 //#endregion
 //#region src/workers/report.ts
 /**
@@ -1307,6 +1950,8 @@ async function openFollowPane(logDir, _config, term, checkOnly) {
 * 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.
 */
+/** 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.",
@@ -1315,7 +1960,20 @@ const WORKER_CONTRACT_PROMPT = [
 	"{\"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."
+	"notes: one line, the headline a reviewer reads first.",
+	"",
+	`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
@@ -1465,81 +2123,6 @@ function describeMcp(config, claudeJson = CLAUDE_JSON) {
 	return lines;
 }
 
-//#endregion
-//#region src/workers/operator.ts
-/**
-* operator.ts — talking to a running worker.
-*
-* Headless workers run with `--input-format stream-json` and their stdin held
-* open, so a run is a conversation: every line sent to the per-worker Unix
-* socket `<logDir>/<id>.sock` is forwarded to the child as a user message and
-* mirrored into the transcript as an `operator` event (rendered with a »
-* marker). Once the worker has finished its turn, stdin closes 2 s later
-* unless a new message arrives — after that, `say` refuses and `resume`
-* continues the same Claude session with the worker's context intact.
-*/
-function operatorSocketPath(logDir, id) {
-	return join(logDir, `${id}.sock`);
-}
-/**
-* The runner's side: listen on the worker socket, hand every received line to
-* `onLine`. Returns the server (close it when the run ends; the socket file is
-* unlinked on close, best effort).
-*/
-function createOperatorServer(logDir, id, onLine) {
-	const path = operatorSocketPath(logDir, id);
-	try {
-		if (existsSync(path)) unlinkSync(path);
-	} catch {}
-	const server = createServer((socket) => {
-		let buf = "";
-		socket.on("data", (chunk) => {
-			buf += chunk.toString("utf8");
-			let nl;
-			while ((nl = buf.indexOf("\n")) >= 0) {
-				const line = buf.slice(0, nl).replace(/\r$/, "");
-				buf = buf.slice(nl + 1);
-				if (line.trim()) onLine(line);
-				socket.write("ok\n");
-			}
-		});
-	});
-	server.listen(path);
-	server.on("close", () => {
-		try {
-			if (existsSync(path)) unlinkSync(path);
-		} catch {}
-	});
-	return server;
-}
-/**
-* `pai worker say <id> "<text>"`: forward one line to a running worker.
-* Resolves "ok", rejects with a clear message when the worker is not running.
-*/
-function sayToWorker(logDir, id, text, timeoutMs = 4e3) {
-	const status = loadStatus(logDir, id);
-	if (!status) return Promise.reject(/* @__PURE__ */ new Error(`no worker named "${id}"`));
-	if (status.state !== "running" || !alive(status.pid)) return Promise.reject(/* @__PURE__ */ new Error(`worker ${id} is not running (state: ${status.state}) — continue it instead with: pai worker resume ${id} "<text>"`));
-	const path = operatorSocketPath(logDir, id);
-	if (!existsSync(path)) return Promise.reject(/* @__PURE__ */ new Error(`worker ${id} has no operator socket (${path}) — it may predate this PAI version`));
-	return new Promise((resolve, reject) => {
-		const sock = connect(path);
-		const fail = (e) => {
-			sock.destroy();
-			reject(/* @__PURE__ */ new Error(`cannot talk to worker ${id}: ${e.message}`));
-		};
-		sock.setTimeout(timeoutMs, () => fail(/* @__PURE__ */ new Error("timeout")));
-		sock.once("error", (e) => fail(e));
-		sock.once("connect", () => {
-			sock.write(text.replace(/\n/g, " ") + "\n");
-		});
-		sock.once("data", () => {
-			sock.end();
-			resolve("ok");
-		});
-	});
-}
-
 //#endregion
 //#region src/workers/proxy/server.ts
 /**
@@ -1877,9 +2460,23 @@ function stdinUserMessage(text) {
 		}
 	});
 }
-/** ISO stamp with seconds, attached to every mirrored event (2g). */
-function isoStamp(d = /* @__PURE__ */ new Date()) {
-	return d.toISOString().replace(/\.\d{3}Z$/, "Z");
+/** An operator line as the worker sees it: carrying the contract's marker. */
+function operatorUserText(text) {
+	return `${OPERATOR_MARK} ${text}`;
+}
+/**
+* ISO stamp with seconds, attached to every mirrored event (2g): local time
+* with its offset (`2026-09-17T14:19:23+02:00`), so the viewer can render the
+* wall clock the operator lives in. `offMin` is east-positive minutes —
+* injectable so tests do not depend on the machine's zone.
+*/
+function isoStamp(d = /* @__PURE__ */ new Date(), offMin = -d.getTimezoneOffset()) {
+	const t = new Date(d.getTime() + offMin * 6e4);
+	const sign = offMin < 0 ? "-" : "+";
+	const abs = Math.abs(offMin);
+	const hh = String(Math.floor(abs / 60)).padStart(2, "0");
+	const mm = String(abs % 60).padStart(2, "0");
+	return `${t.toISOString().slice(0, 19)}${sign}${hh}:${mm}`;
 }
 /** Context tokens of an assistant/result usage block (input+cache+output). */
 function usageContextTokens(u) {
@@ -1902,9 +2499,15 @@ async function runWorker(opts) {
 	if (!config.enabled) throw new Error("workers are off. Turn them on with: pai worker on\n(then the Agent-tool hook stops denying Anthropic subagents only when you do)");
 	const logDir = workersLogDir(config);
 	mkdirSync(logDir, { recursive: true });
+	if (opts.className === "plan" && !opts._planner) {
+		const { runPlanner } = await import("./planner-BDI7bE9B.mjs");
+		return runPlanner(opts);
+	}
+	const parent = launchParent(opts.parent);
+	if (parent) assertChildAllowed(logDir, parent, config.tree);
 	const target = resolveTarget(config, logDir, {
 		flagProvider: opts.providerFlag,
-		role: opts.role
+		className: opts.className
 	});
 	assertProviderRunnable(target.providerName, target.provider);
 	const parsed = parseRunnerArgs(opts.claudeArgs);
@@ -1920,7 +2523,14 @@ async function runWorker(opts) {
 			parsed,
 			claudeArgs: opts.claudeArgs,
 			noPane: opts.noPane ?? false,
-			onWorkerStart: opts.onWorkerStart
+			cwd: opts.cwd,
+			parent: parent ?? void 0,
+			stage: opts.stage,
+			quiet: opts.quiet,
+			onWorkerStart: opts.onWorkerStart,
+			id: opts.id,
+			worktreeFlag: opts.worktreeFlag,
+			className: opts.className
 		});
 		return await executeRun({
 			config,
@@ -1932,7 +2542,14 @@ async function runWorker(opts) {
 			claudeArgs: opts.claudeArgs,
 			noPane: opts.noPane ?? false,
 			mcpFlag: opts.mcpFlag,
+			cwd: opts.cwd,
+			parent: parent ?? void 0,
+			stage: opts.stage,
+			quiet: opts.quiet,
 			onWorkerStart: opts.onWorkerStart,
+			id: opts.id,
+			worktreeFlag: opts.worktreeFlag,
+			className: opts.className,
 			reroutes: opts._reroutes ?? 0
 		});
 	} catch (e) {
@@ -1946,10 +2563,26 @@ async function executeRun(a) {
 	let proxyUrl;
 	if (target.provider.protocol === "openai") proxyUrl = `${await ensureProxyRunning(DEFAULT_PROXY_PORT, logDir)}/${target.providerName}`;
 	const env = buildRunEnv(target.provider, headless, proxyUrl);
-	const wid = newWorkerId();
-	const cwd = process.cwd();
+	const wid = a.id ?? newWorkerId();
+	const cwd = a.cwd ?? process.cwd();
 	const term = process.env.ITERM_SESSION_ID ?? "";
 	const session = resolveSession(term);
+	let worktree = null;
+	if (headless && worktreeWanted(a.worktreeFlag, {
+		cwd,
+		className: a.className,
+		prompt: parsed.prompt
+	})) try {
+		worktree = addWorktree(logDir, wid, cwd);
+	} catch (e) {
+		const why = e.message;
+		process.stderr.write(`pai worker: no worktree (${why}) — running in place\n`);
+		appendLedger(ledgerPath(logDir), "WORKER-NOTE", {
+			id: wid,
+			note: `no worktree: ${why}`
+		});
+	}
+	env.PAI_WORKER_ID = wid;
 	const status = {
 		id: wid,
 		pid: process.pid,
@@ -1967,7 +2600,16 @@ async function executeRun(a) {
 		rc: null,
 		secs: null,
 		...session ? { session } : {},
-		contextWindow: providerContextWindow(target.provider)
+		contextWindow: providerContextWindow(target.provider),
+		...a.parent ? {
+			parent: a.parent,
+			stage: a.stage
+		} : {},
+		...worktree ? {
+			worktreeDir: worktree.dir,
+			branch: worktree.branch,
+			worktreeBase: worktree.base
+		} : {}
 	};
 	saveStatus(logDir, status);
 	a.onWorkerStart?.(wid);
@@ -1986,7 +2628,7 @@ async function executeRun(a) {
 		const wanted = [
 			...a.mcpFlag ? [a.mcpFlag] : [],
 			...parsed.mcp,
-			...target.roleMcp ?? []
+			...target.classMcp ?? []
 		];
 		if (wanted.length) mcpArgs = [
 			"--strict-mcp-config",
@@ -2006,11 +2648,12 @@ async function executeRun(a) {
 	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,
-		cwd,
+		cwd: worktree?.dir ?? cwd,
 		stdio: headless ? [
 			"pipe",
 			"pipe",
@@ -2045,10 +2688,11 @@ async function executeRun(a) {
 		}
 		writeEvent({
 			type: "operator",
-			text
+			text,
+			handoff: isHandoffMessage(text)
 		});
 		try {
-			proc.stdin?.write(stdinUserMessage(text) + "\n");
+			proc.stdin?.write(stdinUserMessage(operatorUserText(text)) + "\n");
 		} catch {}
 	}) : null;
 	let killed = false;
@@ -2154,7 +2798,8 @@ async function executeRun(a) {
 		tools: status.tools,
 		label
 	});
-	if (headless) printResult(parsed.outputFormat, resultEvent, rc, logDir, wid, ctx.resultReport);
+	if (worktree) recordWorktree(logDir, status, worktree, ok);
+	if (headless && !a.quiet) printResult(parsed.outputFormat, resultEvent, rc, logDir, wid, ctx.resultReport, worktreeExtras(status));
 	const resultText = resultEvent?.result ?? "";
 	if (!ok && headless && a.target.via === "auto" && config.routing.retryOnQuota && status.turns <= 1 && status.tools === 0 && isQuotaFailure(resultText)) {
 		setCooldown(logDir, target.providerName, config.routing.cooldownMinutes);
@@ -2170,22 +2815,69 @@ async function executeRun(a) {
 				label,
 				noPane: a.noPane,
 				mcpFlag: a.mcpFlag,
+				cwd: a.cwd,
+				parent: a.parent,
+				stage: a.stage,
 				claudeArgs: a.claudeArgs,
 				onWorkerStart: a.onWorkerStart,
+				worktreeFlag: a.worktreeFlag,
+				className: a.className,
 				_reroutes: a.reroutes + 1
 			});
 		}
 	}
-	return rc !== 0 ? rc : ok ? 0 : 1;
+	const finalRc = rc !== 0 ? rc : ok ? 0 : 1;
+	if (status.parent && isWorkerId(logDir, status.parent)) try {
+		await deliverHandoff(logDir, {
+			from: wid,
+			to: status.parent,
+			kind: "result",
+			text: shortText(ctx.resultReport?.notes ?? resultEvent?.result ?? (ok ? "done" : "failed"), 400),
+			data: {
+				rc: finalRc,
+				ok,
+				...status.branch ? {
+					branch: status.branch,
+					commits: status.commits ?? 0
+				} : {},
+				...ctx.resultReport ? { report: ctx.resultReport } : {}
+			}
+		});
+	} catch {}
+	return finalRc;
+}
+/** The worktree fields printResult adds to a json payload, when there is one. */
+function worktreeExtras(s) {
+	return s.branch ? {
+		branch: s.branch,
+		commits: s.commits ?? 0
+	} : void 0;
 }
 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>'`);
 	const env = buildCodexEnv(target.provider);
-	const wid = newWorkerId();
-	const cwd = process.cwd();
+	const wid = a.id ?? newWorkerId();
+	const cwd = a.cwd ?? process.cwd();
 	const term = process.env.ITERM_SESSION_ID ?? "";
 	const session = resolveSession(term);
+	let worktree = null;
+	if (worktreeWanted(a.worktreeFlag, {
+		cwd,
+		className: a.className,
+		prompt: parsed.prompt
+	})) try {
+		worktree = addWorktree(logDir, wid, cwd);
+	} catch (e) {
+		const why = e.message;
+		process.stderr.write(`pai worker: no worktree (${why}) — running in place\n`);
+		appendLedger(ledgerPath(logDir), "WORKER-NOTE", {
+			id: wid,
+			note: `no worktree: ${why}`
+		});
+	}
+	env.PAI_WORKER_ID = wid;
+	const prompt = (worktree ? worktreeSystemPrompt(wid, worktree.branch, worktree.dir) + "\n\n" : "") + parsed.prompt;
 	const status = {
 		id: wid,
 		pid: process.pid,
@@ -2203,7 +2895,16 @@ async function executeCodexRun(a) {
 		rc: null,
 		secs: null,
 		...session ? { session } : {},
-		contextWindow: providerContextWindow(target.provider)
+		contextWindow: providerContextWindow(target.provider),
+		...a.parent ? {
+			parent: a.parent,
+			stage: a.stage
+		} : {},
+		...worktree ? {
+			worktreeDir: worktree.dir,
+			branch: worktree.branch,
+			worktreeBase: worktree.base
+		} : {}
 	};
 	saveStatus(logDir, status);
 	a.onWorkerStart?.(wid);
@@ -2224,9 +2925,9 @@ async function executeCodexRun(a) {
 	});
 	if (!noPane && config.pane.enabled && term && process.env.PAI_WORKER_AUTOPANE !== "0") openPaneForWorker(logDir, config, wid, term).catch(() => {});
 	const t0 = Date.now();
-	const proc = spawn("codex", buildCodexArgs(parsed.prompt, parsed.callerModel ? void 0 : model), {
+	const proc = spawn("codex", buildCodexArgs(prompt, parsed.callerModel ? void 0 : model), {
 		env,
-		cwd,
+		cwd: worktree?.dir ?? cwd,
 		stdio: [
 			"ignore",
 			"pipe",
@@ -2313,10 +3014,29 @@ async function executeCodexRun(a) {
 		tools: status.tools,
 		label
 	});
-	printResult(parsed.outputFormat, resultEvent, rc, logDir, wid, report);
-	return rc !== 0 ? rc : ok ? 0 : 1;
+	if (worktree) recordWorktree(logDir, status, worktree, ok);
+	if (!a.quiet) printResult(parsed.outputFormat, resultEvent, rc, logDir, wid, report, worktreeExtras(status));
+	const finalRc = rc !== 0 ? rc : ok ? 0 : 1;
+	if (status.parent && isWorkerId(logDir, status.parent)) try {
+		await deliverHandoff(logDir, {
+			from: wid,
+			to: status.parent,
+			kind: "result",
+			text: shortText(report?.notes ?? finalText ?? (ok ? "done" : "failed"), 400),
+			data: {
+				rc: finalRc,
+				ok,
+				...status.branch ? {
+					branch: status.branch,
+					commits: status.commits ?? 0
+				} : {},
+				...report ? { report } : {}
+			}
+		});
+	} catch {}
+	return finalRc;
 }
-function printResult(fmt, resultEvent, rc, logDir, wid, report) {
+function printResult(fmt, resultEvent, rc, logDir, wid, report, extras) {
 	if (fmt === "stream-json") return;
 	if (fmt === "json") {
 		const payload = report ? {
@@ -2325,11 +3045,15 @@ function printResult(fmt, resultEvent, rc, logDir, wid, report) {
 				result: "no result event",
 				rc
 			},
-			report
-		} : resultEvent ?? {
-			is_error: true,
-			result: "no result event",
-			rc
+			report,
+			...extras
+		} : {
+			...resultEvent ?? {
+				is_error: true,
+				result: "no result event",
+				rc
+			},
+			...extras
 		};
 		console.log(JSON.stringify(payload));
 		return;
@@ -2441,627 +3165,161 @@ function resultFromOutput(out) {
 }
 
 //#endregion
-//#region src/workers/render.ts
+//#region src/workers/chain.ts
 /**
-* render.ts — turn worker events into the lines a human reads.
+* chain.ts — draft-then-implement chains: `--chain draft,implement[,review]`.
 *
-* Ports the glm-ps transcript rendering: the gutter rules (dim `>` for reads
-* and searches, `$` for shell, magenta `~` + red/green diff for edits, green
-* `+` for writes), Read-result trimming (first 3 lines then a count), and the
-* result footer. Colors are applied only when the output is a TTY, so MCP
-* tool output stays plain text.
-*/
-const CODES = {
-	dim: "2",
-	bold: "1",
-	red: "31",
-	green: "32",
-	yellow: "33",
-	blue: "34",
-	mag: "35",
-	cyan: "36"
-};
-function makeColor(enabled) {
-	return (name, s) => enabled ? `\x1b[${CODES[name]}m${s}\x1b[0m` : s;
-}
-/** Path relative to cwd when it lies inside it, otherwise unchanged. */
-function relPath(path, cwd) {
-	if (!path || !cwd) return path;
-	let r;
-	try {
-		r = relative(cwd, path);
-	} catch {
-		return path;
-	}
-	return r.startsWith("..") ? path : r;
-}
-/** Minimal line diff for Edit previews: common prefix/suffix, one hunk. */
-function unifiedDiffLines(oldStr, newStr) {
-	const oldL = oldStr.split("\n");
-	const newL = newStr.split("\n");
-	let start = 0;
-	while (start < oldL.length && start < newL.length && oldL[start] === newL[start]) start++;
-	let endOld = oldL.length;
-	let endNew = newL.length;
-	while (endOld > start && endNew > start && oldL[endOld - 1] === newL[endNew - 1]) {
-		endOld--;
-		endNew--;
-	}
-	const out = [];
-	for (let i = start; i < endOld; i++) out.push("-" + oldL[i]);
-	for (let i = start; i < endNew; i++) out.push("+" + newL[i]);
-	return out;
-}
-/**
-* The transcript gutter (2g): `HH:MM:SS │ ` from the event's `_ts`, dim, with
-* the worker tag in front when several run at once. Continuation lines get
-* blanks of the same width so wrapped text stays aligned. null when the event
-* carries no stamp (logs from before 2g render with the plain prefix).
+* The chain runs each stage as its own worker (own id, own pane, `parent` set
+* to the chain id), so `ps` shows the chain as a tree and every stage can be
+* followed, replayed and said to like any other worker:
+*
+*   - draft    turns the operator's brief into a full spec file under
+*              <logDir>/specs/<chain id>.md (goal, constraints, files likely
+*              touched, acceptance checks, verification commands);
+*   - any other stage (implement, plan, …) runs with that spec as its prompt
+*              and the original brief attached;
+*   - review   reads the spec and the working-tree diff and produces the
+*              structured report.
+*
+* A stage that fails (or a draft that produces no spec file) stops the chain;
+* the caller then writes the spec itself and re-runs without the draft stage.
 */
-function gutterFor(c, e, tag) {
-	if (!e._ts) return null;
-	const time = e._ts.length >= 19 ? e._ts.slice(11, 19) : e._ts;
-	const head = tag ? `${tag} ${time}` : time;
-	const width = head.length + 3;
-	return {
-		first: c("dim", `${head} │ `),
-		cont: " ".repeat(width)
-	};
-}
-/** Compact token count: 84k, 200k, 900. */
-function fmtK(n) {
-	return n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n);
+/** Where a chain's spec file lives: <logDir>/specs/<chain id>.md. */
+function specPathFor(logDir, chainId) {
+	return join(logDir, "specs", `${chainId}.md`);
 }
 /**
-* The context meter `ctx 84k/200k (42%)`, yellow from 70 %, red from 85 %.
-* null when the numbers are missing or below `minPct` (the table only shows
-* it past 60; the pane liveness line always shows it).
+* Replace the caller's -p value with `prompt`, dropping every existing
+* -p/--print pair first (two -p flags on one claude command line are an error,
+* so the chain must never leave the brief in place when swapping prompts).
 */
-function contextMeter(c, s, minPct = 0) {
-	const pct = contextPercent(s);
-	if (pct === null || pct <= minPct) return null;
-	const label = `ctx ${fmtK(s.contextTokens ?? 0)}/${fmtK(s.contextWindow ?? 0)} (${pct}%)`;
-	if (pct > 85) return c("red", label);
-	if (pct > 70) return c("yellow", label);
-	return label;
-}
-function renderToolUse(c, prefix, name, inp, cwd) {
-	const i = typeof inp === "object" && inp !== null ? inp : {};
-	const get = (k) => typeof i[k] === "string" ? i[k] : "";
-	if (name === "Read") return [`${prefix}${c("dim", ">")} Reading ${relPath(get("file_path"), cwd)}`];
-	if (name === "Grep" || name === "Glob") return [`${prefix}${c("dim", ">")} Searching ${c("cyan", get("pattern"))} in ${relPath(get("path") || ".", cwd)}`];
-	if (name === "Bash") return [`${prefix}${c("dim", "$")} ${shortText(get("command"), 160)}`];
-	if (name === "Edit") {
-		const out = [`${prefix}${c("mag", "~")} Editing ${relPath(get("file_path"), cwd)}`];
-		for (const line of unifiedDiffLines(get("old_string"), get("new_string"))) if (line.startsWith("-")) out.push(`${prefix}    ${c("red", line)}`);
-		else if (line.startsWith("+")) out.push(`${prefix}    ${c("green", line)}`);
-		else out.push(`${prefix}    ${c("dim", line)}`);
-		return out;
-	}
-	if (name === "Write") {
-		const n = get("content").split("\n").length;
-		return [`${prefix}${c("green", "+")} Writing ${relPath(get("file_path"), cwd)} (${n} lines)`];
-	}
-	if (name === "WebSearch" || name === "WebFetch") return [`${prefix}${c("dim", ">")} ${name} ${shortText(get("query") || get("url"), 100)}`];
-	return [`${prefix}${c("dim", ">")} ${name} ${shortText(JSON.stringify(i), 120)}`];
-}
-/** Render one stream-json event; `tools` maps tool_use_id → tool name. */
-function renderEvent(c, prefix, e, cwd, tools, gutter) {
+function swapPromptArg(claudeArgs, prompt) {
 	const out = [];
-	if (e.type === "system" && e.subtype === "init") out.push(`${prefix}${c("dim", `worker started · model ${e.model ?? "?"} · cwd ${basename(e.cwd || cwd || "")}`)}`);
-	else if (e.type === "operator") for (const ln of String(e.text ?? "").split("\n")) out.push(`${prefix}${c("cyan", "» " + ln)}`);
-	else if (e.type === "assistant") {
-		for (const b of e.message?.content ?? []) if (b.type === "text" && (b.text ?? "").trim()) for (const ln of (b.text ?? "").trim().split("\n")) out.push(`${prefix}${ln}`);
-		else if (b.type === "tool_use") out.push(...renderToolUse(c, prefix, b.name ?? "?", b.input, cwd));
-	} else if (e.type === "user") for (const b of e.message?.content ?? []) {
-		if (b.type !== "tool_result") continue;
-		let content = b.content ?? "";
-		if (Array.isArray(content)) content = content.map((x) => typeof x === "object" && x !== null && "text" in x ? String(x.text ?? "") : "").join("\n");
-		const text = String(content);
-		const isError = b.is_error === true;
-		if (!isError && tools[b.tool_use_id ?? ""] === "Read") {
-			const lines = text.split("\n");
-			for (const ln of lines.slice(0, 3)) out.push(`${prefix}${c("dim", ln)}`);
-			if (lines.length > 3) out.push(`${prefix}${c("dim", `    … ${lines.length} lines`)}`);
-		} else if (isError) out.push(`${prefix}    ${c("red", "! " + shortText(text, 200))}`);
-		else if (text.trim()) out.push(`${prefix}    ${c("dim", shortText(text, 120))}`);
-	}
-	else if (e.type === "result") {
-		const mark = !e.is_error ? c("green", "✓ done") : c("red", "✗ failed");
-		out.push(`${prefix}${mark} · ${e.num_turns ?? "?"} turns · ${Math.floor((e.duration_ms ?? 0) / 1e3)}s`);
-		const report = parseWorkerReport(String(e.result ?? ""));
-		if (report) out.push(...renderReport(c, prefix, report, cwd));
-		else for (const ln of String(e.result ?? "").trim().split("\n")) out.push(`${prefix}  ${ln}`);
-	}
-	if (!gutter) return out;
-	return out.map((ln, i) => (i === 0 ? gutter.first : gutter.cont) + ln);
-}
-/** Transcript header: id, provider, label, session name, project dir. */
-function headerLine(c, s) {
-	const bits = [s.provider ? `[${s.provider}]` : "", sessionTag(s)].filter(Boolean).join(" ");
-	const sep = bits ? `  ${bits}` : "";
-	return c("bold", `━━ ${s.id}${sep}  ${s.label}  (${basename(s.cwd)})`);
-}
-/** The ps table (RUNNING + FINISHED last 8). */
-function renderTable(c, statuses, scopeLabel, now = /* @__PURE__ */ new Date()) {
-	const running = [];
-	const done = [];
-	for (const s of statuses) if (s.state === "running" && alive(s.pid)) running.push(s);
-	else {
-		if (s.state === "running") s.state = "lost";
-		done.push(s);
-	}
-	const lines = [c("bold", `Workers  ${`${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}`}`), ""];
-	lines.push(c("bold", `RUNNING (${running.length})`));
-	if (!running.length) lines.push("  none");
-	for (const s of running) {
-		const meter = contextMeter(c, s, 60);
-		lines.push(`  ${c("cyan", s.id)} [${s.provider}]  ${ageOf(s.started, now).padStart(4)} old  turns ${String(s.turns).padStart(2)}  tools ${String(s.tools).padStart(2)}  ${basename(s.cwd)}${meter ? "  " + meter : ""}`);
-		lines.push(`      task: ${s.label}`);
-		lines.push(`      now:  ${c("yellow", s.last)}  (${ageOf(s.updated, now)} ago)`);
-	}
-	lines.push("");
-	lines.push(c("bold", "FINISHED (last 8)"));
-	for (const s of done.slice(-8)) {
-		const col = s.state === "done" ? "green" : "red";
-		const tag = sessionTag(s);
-		lines.push(`  ${s.id} [${s.provider}]${tag ? " " + tag : ""}  ${c(col, s.state.padEnd(6))} rc=${s.rc}  ${String(s.secs ?? "?").padStart(4)}s  turns ${String(s.turns).padStart(2)}  tools ${String(s.tools).padStart(2)}  ${basename(s.cwd)}  ${s.label}`);
-	}
-	lines.push("");
-	lines.push(c("dim", "worker follow        live transcript of running workers"));
-	lines.push(c("dim", "worker <id>          replay one worker"));
-	lines.push(c("dim", scopeLabel));
-	return lines.join("\n");
-}
-/** One-line status-bar summary (same shape glm-ps --status printed). */
-function renderStatusLine(mine, now = /* @__PURE__ */ new Date(), c = makeColor(true)) {
-	if (!mine.length) return "";
-	const running = mine.filter((s) => s.state === "running" && alive(s.pid));
-	const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
-	const doneToday = mine.filter((s) => s.state !== "running" && s.started.startsWith(today));
-	const ok = doneToday.filter((s) => s.state === "done").length;
-	const bad = doneToday.length - ok;
-	const providers = new Set(running.map((s) => s.provider));
-	let head = `${providers.size === 1 ? [...providers][0] : "workers"} ▶${running.length}`;
-	const parts = running.slice(0, 3).map((s) => {
-		const meter = contextMeter(c, s, 60);
-		return `${s.id.slice(-4)} ${s.label.slice(0, 26)} ${ageOf(s.started, now)} · ${s.last.slice(0, 30)}` + (meter ? ` ${meter}` : "");
-	});
-	if (parts.length) head += "  " + parts.join(" | ");
-	if (doneToday.length) head += `   ✓${ok} ✗${bad} today`;
-	return head;
-}
-
-//#endregion
-//#region src/workers/viewer.ts
-/**
-* viewer.ts — ps / follow / replay / status line over the worker logDir.
-*
-* Scoping: workers launched from this terminal's AIBroker session (or, as the
-* fallback, its iTerm tab) unless --all or an explicit worker id is given.
-* Outside iTerm, everything degrades to "all workers" — the Python behaviour.
-*
-* Transcripts render with a `HH:MM:SS │ ` gutter (2g): dim, taken from the
-* `_ts` stamp on every mirrored event, the worker tag in front when several
-* run at once, a date separator when the day changes, and — on a TTY — a
-* liveness line (`⋯ 12s since last event · Bash: npm test · ctx 84k/200k (42%)`)
-* that is rewritten in place between events. Following one worker also wires
-* this pane's stdin: every typed line is said to the worker while it runs and
-* resumes it (same Claude session) once it has finished.
-*/
-function psOutput(logDir, showAll, env = process.env, color = process.stdout.isTTY === true) {
-	const c = makeColor(color);
-	const term = env.ITERM_SESSION_ID ?? "";
-	const statuses = loadStatuses(logDir);
-	return renderTable(c, showAll || !term ? statuses : statuses.filter((s) => workerInScope(s, term)), showAll || !term ? "scope: all workers" : resolveSession(term) ? `scope: session ${resolveSession(term).name}` : `scope: tab ${currentTabKey(env)} (this iTerm tab)`);
-}
-/** The rendered transcript of one worker, from the start, as one string. */
-function replayOutput(logDir, wid, color = process.stdout.isTTY === true, tailLines) {
-	const path = eventsPath(logDir, wid);
-	if (!existsSync(path)) throw new Error(`no event log for ${wid}`);
-	const c = makeColor(color);
-	const st = loadStatuses(logDir).find((s) => s.id === wid) ?? {
-		id: wid,
-		label: "",
-		cwd: "",
-		provider: ""
-	};
-	const tools = {};
-	const out = [headerLine(c, st)];
-	const lines = readFileSync(path, "utf8").split("\n");
-	let lastDay = "";
-	for (const line of tailLines !== void 0 ? lines.slice(-tailLines) : lines) {
-		if (!line.trim()) continue;
-		let e;
-		try {
-			e = JSON.parse(line);
-		} catch {
+	for (let i = 0; i < claudeArgs.length; i++) {
+		const a = claudeArgs[i];
+		if (a === "-p" || a === "--print") {
+			if (i + 1 < claudeArgs.length && !claudeArgs[i + 1].startsWith("-")) i += 1;
 			continue;
 		}
-		if (typeof e._ts === "string" && e._ts.slice(0, 10) !== lastDay) {
-			lastDay = e._ts.slice(0, 10);
-			out.push(c("dim", `── ${lastDay} ──`));
-		}
-		const g = gutterFor(c, e);
-		collectTools(e, tools);
-		out.push(...renderEvent(c, g ? "" : "  ", e, st.cwd ?? "", tools, g));
+		out.push(a);
 	}
-	return out.join("\n");
-}
-function collectTools(e, tools) {
-	if (e.type !== "assistant") return;
-	for (const b of e.message?.content ?? []) if (b.type === "tool_use" && b.id) tools[b.id] = b.name ?? "?";
-}
-/**
-* The follow exit decision for one worker: it is over once its result event
-* was rendered, or once its status left "running" while its pid is gone — a
-* worker killed without writing a result still ends. A status never read
-* (undefined) means "not over": follow keeps waiting for the first event.
-*/
-function workerEnded(resultRendered, state, pidAlive) {
-	return resultRendered || state !== void 0 && state !== "running" && !pidAlive;
+	out.push("-p", prompt);
+	return out;
 }
-/**
-* Tail one worker (target) or the running workers of this scope, live.
-* Auto-exit: with a target, wait `autoExit` seconds after its end; without
-* one, exit once no worker in scope has run for that many seconds in a row,
-* never within the first 30 s. With a target on a TTY, typed stdin lines are
-* said to the worker (or resume it after it finished).
-*/
-async function followWorkers(logDir, target, showAll, autoExit, env = process.env, color = process.stdout.isTTY === true) {
-	const c = makeColor(color);
-	const tty = process.stdout.isTTY === true;
-	const term = env.ITERM_SESSION_ID ?? "";
-	const scopeTab = target || showAll ? "" : currentTabKey(env);
-	const tools = {};
-	const handles = /* @__PURE__ */ new Map();
-	const seenHeader = /* @__PURE__ */ new Set();
-	const finished = /* @__PURE__ */ new Set();
-	const lastDayBy = /* @__PURE__ */ new Map();
-	const started = Date.now();
-	let idleSince = null;
-	let aborted = false;
-	let lastEventAt = Date.now();
-	let lastAction = "waiting for first event";
-	let meterStatus = null;
-	let livenessLen = 0;
-	const onInt = () => {
-		aborted = true;
-	};
-	process.once("SIGINT", onInt);
-	const plainOf = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
-	const eraseLiveness = () => {
-		if (livenessLen > 0) {
-			process.stdout.write("\r" + " ".repeat(livenessLen) + "\r");
-			livenessLen = 0;
-		}
-	};
-	const writeLiveness = () => {
-		if (!tty) return;
-		eraseLiveness();
-		const secs = Math.max(0, Math.floor((Date.now() - lastEventAt) / 1e3));
-		const meter = meterStatus ? contextMeter(c, meterStatus) : null;
-		const plain = `⋯ ${secs}s since last event · ${lastAction}${meter ? ` · ${plainOf(meter)}` : ""}`;
-		process.stdout.write(`
-		livenessLen = plain.length;
-	};
-	const runningIds = () => loadStatuses(logDir).filter((s) => s.state === "running" && alive(s.pid) && (target !== null || showAll || (scopeTab ? workerInScope(s, term) : true))).map((s) => s.id);
-	const noteLine = (s) => {
-		eraseLiveness();
-		process.stdout.write(s + "\n");
-	};
-	const resumeTarget = (text, id) => {
-		noteLine(c("dim", `» resuming ${id} …`));
-		const child = spawn("pai", [
-			"worker",
-			"resume",
-			id,
-			text,
-			"--print-id",
-			"--no-pane"
-		], { stdio: [
-			"ignore",
-			"pipe",
-			"inherit"
-		] });
-		let idOut = "";
-		child.stdout?.on("data", (chunk) => {
-			idOut += chunk.toString("utf8");
-		});
-		child.on("close", (rc) => {
-			const newId = idOut.trim().split("\n").pop() ?? "";
-			if (rc === 0 && /^[0-9]{8}-[0-9]{6}-[0-9]+$/.test(newId)) {
-				noteLine(c("dim", `» resumed as ${newId}`));
-				target = newId;
-				finished.delete(newId);
-				seenHeader.delete(newId);
-				lastEventAt = Date.now();
-				lastAction = "resumed";
-			} else noteLine(c("red", `» resume failed (rc=${rc})`));
-		});
-	};
-	const handleOperatorLine = (raw) => {
-		const text = raw.trim();
-		if (!text || target === null) return;
-		const id = target;
-		sayToWorker(logDir, id, text).then(() => noteLine(c("dim", `» sent to ${id}`)), (e) => {
-			if (loadStatuses(logDir).some((s) => s.id === id)) resumeTarget(text, id);
-			else noteLine(c("red", `» ${e.message}`));
+function draftPrompt(brief, specPath) {
+	return [
+		"You are the DRAFT stage of a worker chain. Turn the operator's brief below into a full implementation spec and write it to",
+		specPath,
+		"with the Write tool.",
+		"",
+		"Use exactly these five sections as Markdown headings:",
+		"# Goal",
+		"# Constraints",
+		"# Files likely touched",
+		"# Acceptance checks",
+		"# Verification commands",
+		"",
+		"Read the repository first (Glob/Grep/Read) so the spec names real files and real commands. Do not implement anything.",
+		"",
+		"## Operator brief",
+		"",
+		brief
+	].join("\n");
+}
+function implementPrompt(brief, specPath, spec) {
+	return [
+		...spec ? [
+			"You are the IMPLEMENT stage of a worker chain. The draft stage wrote the spec below (also at " + specPath + "). Implement it exactly, then run the spec's verification commands before finishing.",
+			"",
+			"## Spec",
+			"",
+			spec
+		] : ["Implement the operator's brief below."],
+		"",
+		"## Operator brief",
+		"",
+		brief
+	].join("\n");
+}
+function reviewPrompt(brief, specPath, spec) {
+	return [
+		"You are the REVIEW stage of a worker chain. The implement stage just ran. Read the repository's diff (run `git diff` and `git status`; use `git diff --stat` for the overview) and check it against the spec's acceptance checks and verification commands — run the checks when they are cheap. Do not fix anything you find; report it.",
+		...spec ? [
+			"",
+			"## Spec (also at " + specPath + ")",
+			"",
+			spec
+		] : [],
+		"",
+		"## Operator brief",
+		"",
+		brief
+	].join("\n");
+}
+/** Run a chain of stages; returns the exit code of the first failed stage, 0 when all pass. */
+async function runChain(opts, deps = {}) {
+	const stages = opts.stages.map((s) => s.trim()).filter(Boolean);
+	if (!stages.length) throw new Error("--chain needs at least one class, e.g. --chain draft,implement");
+	const runStage = deps.runStage ?? runWorker;
+	const logDir = deps.logDir ?? workersLogDir(readWorkersSection().workers);
+	const chainId = newWorkerId();
+	const specPath = specPathFor(logDir, chainId);
+	mkdirSync(join(logDir, "specs"), { recursive: true });
+	const baseLabel = opts.label ?? shortText(opts.brief, 40);
+	appendLedger(ledgerPath(logDir), "WORKER-CHAIN", {
+		chain: chainId,
+		stages: stages.join(","),
+		label: baseLabel
+	});
+	opts.onChainStart?.(chainId);
+	let spec = null;
+	for (let i = 0; i < stages.length; i++) {
+		const stage = stages[i];
+		if (stage === "draft") spec = null;
+		else if (spec === null && existsSync(specPath)) spec = readFileSync(specPath, "utf8");
+		const prompt = stage === "draft" ? draftPrompt(opts.brief, specPath) : stage === "review" ? reviewPrompt(opts.brief, spec ? specPath : null, spec) : implementPrompt(opts.brief, spec ? specPath : null, spec);
+		process.stderr.write(`chain ${chainId}: stage ${i + 1}/${stages.length} ${stage} (spec: ${specPath})\n`);
+		const rc = await runStage({
+			className: opts.className ?? stage,
+			providerFlag: opts.providerFlag,
+			modelFlag: opts.modelFlag,
+			label: `${baseLabel} · ${stage}`,
+			noPane: opts.noPane,
+			mcpFlag: opts.mcpFlag,
+			claudeArgs: swapPromptArg(opts.claudeArgs, prompt),
+			cwd: opts.cwd,
+			parent: chainId,
+			stage,
+			quiet: opts.quiet
 		});
-	};
-	let rlIn = null;
-	if (target !== null && process.stdin.isTTY) {
-		rlIn = createInterface({ input: process.stdin });
-		rlIn.on("line", handleOperatorLine);
-	}
-	try {
-		for (;;) {
-			if (aborted) return;
-			for (const wid of target ? [target] : runningIds()) {
-				if (handles.has(wid) || finished.has(wid)) continue;
-				const path = eventsPath(logDir, wid);
-				if (existsSync(path)) handles.set(wid, {
-					fd: openSync(path, "r"),
-					buf: ""
+		if (stage === "draft") {
+			if (!existsSync(specPath)) {
+				process.stderr.write(`chain ${chainId}: draft stage produced no spec at ${specPath} — stopping. Write the spec yourself and re-run without the draft stage.\n`);
+				appendLedger(ledgerPath(logDir), "WORKER-CHAIN-END", {
+					chain: chainId,
+					rc: rc !== 0 ? rc : 1,
+					failed: "draft"
 				});
+				return rc !== 0 ? rc : 1;
 			}
-			const statuses = new Map(loadStatuses(logDir).map((s) => [s.id, s]));
-			const multi = handles.size > 1 || target === null;
-			let progressed = false;
-			for (const [wid, h] of [...handles.entries()]) {
-				const st = statuses.get(wid) ?? {
-					id: wid,
-					label: "",
-					cwd: "",
-					provider: ""
-				};
-				const prefix = multi ? c("cyan", wid.slice(-4)) + c("dim", " ┃ ") : "  ";
-				const buffer = Buffer.alloc(65536);
-				for (;;) {
-					let n;
-					try {
-						n = readSync(h.fd, buffer, 0, buffer.length, null);
-					} catch {
-						n = 0;
-					}
-					if (n <= 0) break;
-					h.buf += buffer.toString("utf8", 0, n);
-				}
-				const lines = h.buf.split("\n");
-				h.buf = lines.pop() ?? "";
-				for (const line of lines) {
-					progressed = true;
-					if (!seenHeader.has(wid)) {
-						eraseLiveness();
-						process.stdout.write(headerLine(c, st) + "\n");
-						seenHeader.add(wid);
-					}
-					if (!line.trim()) continue;
-					let e;
-					try {
-						e = JSON.parse(line);
-					} catch {
-						continue;
-					}
-					const day = typeof e._ts === "string" ? e._ts.slice(0, 10) : "";
-					if (day && day !== lastDayBy.get(wid)) {
-						eraseLiveness();
-						process.stdout.write(`${multi ? prefix : ""}${c("dim", `── ${day} ──`)}\n`);
-						lastDayBy.set(wid, day);
-					}
-					collectTools(e, tools);
-					const g = gutterFor(c, e, multi ? c("cyan", wid.slice(-4)) : void 0);
-					eraseLiveness();
-					for (const ln of renderEvent(c, g ? "" : prefix, e, st.cwd ?? "", tools, g)) process.stdout.write(ln + "\n");
-					lastEventAt = Date.now();
-					if (e.type === "operator") lastAction = "operator message";
-					else if (e.type === "assistant") {
-						const tool = (e.message?.content ?? []).find((b) => b.type === "tool_use");
-						lastAction = tool ? `${tool.name ?? "?"} running` : "thinking";
-					} else if (e.type === "result") lastAction = "finished";
-					meterStatus = st;
-					if (e.type === "result") finished.add(wid);
-				}
-				if (workerEnded(finished.has(wid), st.state, alive(st.pid))) {
-					if (!finished.has(wid)) {
-						eraseLiveness();
-						process.stdout.write(`${prefix}${c("red", "✗ " + (st.state || "ended"))} · ${st.last ?? ""}\n`);
-						finished.add(wid);
-					}
-					closeSync(h.fd);
-					handles.delete(wid);
-				}
-			}
-			const lingerOn = target;
-			if (lingerOn !== null && finished.has(lingerOn)) {
-				if (autoExit) {
-					const until = Date.now() + autoExit * 1e3;
-					while (Date.now() < until && !aborted && target === lingerOn) {
-						writeLiveness();
-						await sleep(250);
-					}
-					if (aborted || target !== lingerOn) continue;
-					eraseLiveness();
-					process.stdout.write(c("dim", "closing") + "\n");
-					return;
-				}
-				if (rlIn === null) return;
-			}
-			if (autoExit && !target) {
-				if (runningIds().length) idleSince = null;
-				else if (idleSince === null) idleSince = Date.now();
-				else if (Date.now() - started >= 3e4 && Date.now() - idleSince >= autoExit * 1e3) {
-					eraseLiveness();
-					process.stdout.write(c("dim", "closing") + "\n");
-					return;
-				}
-			}
-			if (!progressed) {
-				writeLiveness();
-				await sleep(500);
-			}
+			spec = readFileSync(specPath, "utf8");
+		}
+		if (rc !== 0) {
+			appendLedger(ledgerPath(logDir), "WORKER-CHAIN-END", {
+				chain: chainId,
+				rc,
+				failed: stage
+			});
+			return rc;
 		}
-	} finally {
-		rlIn?.close();
-		process.removeListener("SIGINT", onInt);
-		for (const h of handles.values()) try {
-			closeSync(h.fd);
-		} catch {}
-	}
-}
-function sleep(ms) {
-	return new Promise((r) => setTimeout(r, ms));
-}
-/** Workers of this terminal for the status bar; "" when there are none. */
-function statusLineOutput(logDir, term, cwd, now = /* @__PURE__ */ new Date()) {
-	return renderStatusLine(loadStatuses(logDir).filter((s) => {
-		const sameScope = term && workerInScope(s, term);
-		const sameDir = cwd && s.cwd.startsWith(cwd);
-		return sameScope || !term && sameDir;
-	}), now);
-}
-
-//#endregion
-//#region src/workers/providers.ts
-/**
-* providers.ts — provider, role and switch management over the workers config.
-*
-* One layer under both `pai worker providers …` and the MCP worker_providers
-* tool. Every mutation re-reads the config file, changes only the workers
-* section, and writes it back atomically — the file is shared with everything
-* else PAI runs, so a torn write is not an option.
-*
-* Keys are never stored in the config and never accepted inline from the CLI:
-* only file paths. (The MCP `add` tool additionally accepts a raw `key`, which
-* it immediately parks in ~/.config/pai/keys/<name>, mode 0600, storing only
-* the path — a chat is not a place to leave a credential lying around.)
-*/
-function addProvider(input) {
-	if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(input.name)) throw new WorkersConfigError(`provider name "${input.name}" may only contain letters, digits, - and _`);
-	if (input.protocol === "openai" && !input.upstreamUrl) throw new WorkersConfigError("protocol \"openai\" needs the upstreamUrl (the Chat Completions base, e.g. \"https://api.openai.com/v1\") — the PAI proxy translates to it.");
-	if (!input.baseUrl && input.protocol !== "openai") throw new WorkersConfigError("baseUrl is required");
-	let keyFile = input.keyFile ?? null;
-	if (input.key !== void 0) {
-		const dir = keysDir();
-		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-		const path = `${dir}/${input.name}`;
-		writeFileSync(path, input.key.trim() + "\n", {
-			encoding: "utf8",
-			mode: 384
-		});
-		try {
-			chmodSync(path, 384);
-		} catch {}
-		keyFile = path;
-	}
-	const { raw, workers } = readWorkersSection();
-	const provider = {
-		enabled: true,
-		protocol: input.protocol ?? "anthropic",
-		baseUrl: input.baseUrl,
-		keyFile,
-		models: input.fastModel ? {
-			default: input.model,
-			fast: input.fastModel
-		} : { default: input.model },
-		env: input.env ?? {},
-		...input.note ? { note: input.note } : {},
-		...input.upstreamUrl ? { upstreamUrl: input.upstreamUrl } : {},
-		...input.engine && input.engine !== "claude" ? { engine: input.engine } : {},
-		...input.quotaProbe ? { quotaProbe: input.quotaProbe } : {},
-		...input.contextWindow ? { contextWindow: input.contextWindow } : {}
-	};
-	workers.providers[input.name] = provider;
-	if (Object.keys(workers.providers).length === 1) {
-		workers.enabled = true;
-		workers.active = input.name;
-		workers.logDir = workers.logDir || DEFAULT_LOG_DIR;
-		workers.roles = {
-			implement: input.name,
-			research: input.name,
-			spotcheck: input.fastModel ? `${input.name}/fast` : input.name
-		};
 	}
-	writeWorkersSection(raw, workers);
-	return workers;
-}
-function removeProvider(name) {
-	const { raw, workers } = readWorkersSection();
-	if (!workers.providers[name]) throw new WorkersConfigError(`no provider named "${name}"`);
-	delete workers.providers[name];
-	for (const [role, target] of Object.entries(workers.roles)) if ((typeof target === "string" ? target.split("/")[0] : target.provider) === name) delete workers.roles[role];
-	if (workers.active === name) workers.active = null;
-	writeWorkersSection(raw, workers);
-	return workers;
-}
-function useProvider(name) {
-	const { raw, workers } = readWorkersSection();
-	if (!workers.providers[name]) throw new WorkersConfigError(`no provider named "${name}". Configured: ${Object.keys(workers.providers).join(", ") || "(none)"}`);
-	workers.active = name;
-	writeWorkersSection(raw, workers);
-	return workers;
-}
-function setProviderEnabled(name, enabled) {
-	const { raw, workers } = readWorkersSection();
-	const p = workers.providers[name];
-	if (!p) throw new WorkersConfigError(`no provider named "${name}"`);
-	p.enabled = enabled;
-	writeWorkersSection(raw, workers);
-	if (enabled) clearCooldown(workersLogDir(parseWorkersConfig(raw.workers)), name);
-	return workers;
-}
-function setRole(role, target) {
-	const { raw, workers } = readWorkersSection();
-	const [name, alias] = target.split("/");
-	const p = workers.providers[name];
-	if (!p) throw new WorkersConfigError(`no provider named "${name}" in "${target}". Configured: ${Object.keys(workers.providers).join(", ") || "(none)"}`);
-	if (alias && alias !== "default" && alias !== "fast") throw new WorkersConfigError(`unknown model alias "${alias}" — providers expose "default" and "fast"`);
-	if (alias === "fast" && !p.models.fast) throw new WorkersConfigError(`provider "${name}" has no fast model configured`);
-	workers.roles[role] = target;
-	writeWorkersSection(raw, workers);
-	return workers;
-}
-function unsetRole(role) {
-	const { raw, workers } = readWorkersSection();
-	if (!(role in workers.roles)) throw new WorkersConfigError(`no role named "${role}"`);
-	delete workers.roles[role];
-	writeWorkersSection(raw, workers);
-	return workers;
-}
-function setWorkersEnabled(enabled) {
-	const { raw, workers } = readWorkersSection();
-	workers.enabled = enabled;
-	writeWorkersSection(raw, workers);
-	return workers;
-}
-/** Human-readable provider listing (quota probe included when configured). */
-function describeProviders(workers) {
-	const lines = [];
-	const names = Object.keys(workers.providers);
-	if (!names.length) {
-		lines.push(`no providers configured. Add one with:`);
-		lines.push(`  pai worker providers add <name> --base-url <url> --key-file <path> --model <model>`);
-		return lines;
-	}
-	for (const name of names) {
-		const p = workers.providers[name];
-		const flags = [p.enabled ? "enabled" : "disabled", workers.active === name ? "active" : null].filter(Boolean);
-		const quota = p.quotaProbe ? probeQuota(p) : null;
-		const quotaNote = quota === null ? "" : `  quota ${quota}% (skip at ${quotaSkipThreshold(p)})`;
-		lines.push(`${name}  [${flags.join(", ")}]  ${p.baseUrl}`);
-		lines.push(`    model ${p.models.default}${p.models.fast ? ` (fast: ${p.models.fast})` : ""}${quotaNote}`);
-		if (p.keyFile) lines.push(`    key file ${expandHome(p.keyFile)}`);
-		else lines.push(`    no key file (token "local")`);
-		if (p.note) lines.push(`    ${p.note}`);
-		if (p.protocol === "openai") lines.push(`    via PAI proxy ← ${p.upstreamUrl ?? "(upstreamUrl missing)"}`);
-		if (p.engine === "codex") lines.push(`    engine codex (runs through the Codex CLI)`);
-	}
-	const setNames = Object.keys(workers.mcpSets);
-	if (setNames.length) lines.push(`mcp sets: ${setNames.map((s) => `${s}=[${workers.mcpSets[s].join(",")}]`).join("  ")}`);
-	if (workers.active === "auto") lines.push(`routing: auto — order [${workers.routing.order.join(", ")}], cooldown ${workers.routing.cooldownMinutes}m`);
-	return lines;
+	appendLedger(ledgerPath(logDir), "WORKER-CHAIN-END", {
+		chain: chainId,
+		rc: 0
+	});
+	return 0;
 }
 
 //#endregion
-export { readJsonStrict as A, loadStatus as C, workersLogDir as D, ledgerPath as E, WorkersConfigError as O, openPaneForWorker as S, eventsPath as T, stopProxy as _, setRole as a, checkPaneForWorker as b, useProvider as c, replayOutput as d, statusLineOutput as f, ensureProxyRunning as g, DEFAULT_PROXY_PORT as h, setProviderEnabled as i, writeJsonAtomic as j, readWorkersSection as k, followWorkers as l, testProvider as m, describeProviders as n, setWorkersEnabled as o, runWorker as p, removeProvider as r, unsetRole as s, addProvider as t, psOutput as u, sayToWorker as v, ledgerSummary as w, openFollowPane as x, describeMcp as y };
-//# sourceMappingURL=providers-sXcK5bDZ.mjs.map
+export { contextPercent as A, workersLogDir as B, quotaSkipThreshold as C, workerInScope as D, sessionTag as E, ledgerSummary as F, keysDir as G, PROVIDER_TAGS as H, parseRunnerArgs as I, readWorkersSection as J, parseWorkersConfig as K, shortText as L, loadStatuses as M, newWorkerId as N, ageOf as O, appendLedger as P, eventsPath as R, probeQuota as S, resolveSession as T, WorkersConfigError as U, DEFAULT_LOG_DIR as V, expandHome as W, readJsonStrict as X, writeWorkersSection as Y, writeJsonAtomic as Z, workerDepth as _, testProvider as a, openPaneForWorker as b, stopProxy as c, renderReport as d, discardWorker as f, sayToWorker as g, readInbox as h, runWorker as i, loadStatus as j, alive as k, describeMcp as l, handoffFromInside as m, swapPromptArg as n, DEFAULT_PROXY_PORT as o, mergeWorker as p, providerCostTier as q, printResult as r, ensureProxyRunning as s, runChain as t, parseWorkerReport as u, checkPaneForWorker as v, currentTabKey as w, clearCooldown as x, openFollowPane as y, ledgerPath as z };
+//# sourceMappingURL=chain-CTtHligI.mjs.map