@tekmidian/pai 0.48.0 → 0.50.0

package/dist/{run-Cls0YGgV.mjs → run-TChOnMO_.mjs}

@@ -1,6 +1,6 @@
 import { n as openRegistry, r as registryDbPath } from "./db-Ddns80yf.mjs";
-import { _ as providerKeyPath, b as resolveProviderKey, c as classModelCapability, f as isModelCapability, o as WorkersConfigError, s as assertProviderRunnable, v as readWorkersSection, y as resolveModelCapability } from "./config-DxMZjpvY.mjs";
-import { _ as workersLogDir, d as setCooldown, f as ensureNoMcpConfig, g as statusPath, h as panesDir, i as buildRunEnv, m as ledgerPath, n as ensureProxyRunning, o as isQuotaFailure, p as eventsPath, s as nextAutoProvider, t as DEFAULT_PROXY_PORT, u as resolveTarget } from "./server-Ch99xt5K.mjs";
+import { C as readWorkersSection, E as resolveProviderKey, S as providerKeyPath, T as resolveModelCapability, _ as isModelCapability, d as WorkersConfigError, f as assertProviderRunnable, p as classModelCapability } from "./config-DYXARgk8.mjs";
+import { _ as panesDir, a as capabilityForRun, c as nextAutoProvider, d as resolveCapabilityRun, f as resolveTarget, g as ledgerPath, h as eventsPath, i as buildRunEnv, m as ensureNoMcpConfig, n as ensureProxyRunning, p as setCooldown, s as isQuotaFailure, t as DEFAULT_PROXY_PORT, v as statusPath, y as workersLogDir } from "./server-R9UkCn3v.mjs";
 import { appendFileSync, closeSync, existsSync, mkdirSync, mkdtempSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
@@ -538,1328 +538,1401 @@ function ledgerSummary(path, scope, lastN = 15, now = /* @__PURE__ */ new Date()
 }
 
 //#endregion
-//#region src/workers/scope.ts
+//#region src/workers/worktree.ts
 /**
-* scope.ts — which workers "belong" to the terminal asking about them.
-*
-* Two identities, in priority order:
+* worktree.ts — one git worktree per writing worker.
 *
-*   1. AIBroker's session registry (~/.aibroker/session-names.json): iTerm
-*      session UUID → session name. The launching session's UUID is stored in
-*      each worker's status file as `session.id`, so every pane of a named
-*      session sees its workers — regardless of tab layout.
-*   2. The iTerm tab key (`w<window>t<tab>` prefix of ITERM_SESSION_ID): the
-*      original heuristic, kept as the fallback when no registry entry
-*      matches (AIBroker absent, unnamed session, non-iTerm terminal).
+* 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:
 *
-* If neither is available, viewers fall back to "all workers".
+*   pai worker merge <id>     git merge --no-ff worker/<id> + remove worktree + delete branch
+*   pai worker discard <id>   remove worktree and branch, keep nothing
 *
-* A third case: workers spawned from a Claude Code Bash tool (the
-* orchestrator pattern) have neither — Claude Code exports no terminal or
-* session identity to its Bash children. Those record `spawnerSession`, the
-* orchestrator's claude session id bridged through the status line's
-* session map (see below), so their tab still claims them.
-*/
-const AIBROKER_REGISTRY = join(homedir(), ".aibroker", "session-names.json");
-/**
-* `w<window>t<tab>` prefix of an iTerm session id, "" if empty or malformed.
-* Panes split from the same tab share this prefix and differ only in `p<n>`.
+* `ps` marks a worker with an unmerged branch `⎇`. Draft and review run in
+* place; `--no-worktree` opts out, `--worktree` forces one on.
 */
-function tabKey(term) {
-	if (!term) return "";
-	const head = term.split("p", 1)[0];
-	const parts = head.slice(1).split("t");
-	if (head.startsWith("w") && parts.length === 2 && parts.every((p) => /^\d+$/.test(p))) return head;
-	return "";
+function worktreesDir(logDir) {
+	return join(logDir, "worktrees");
 }
-/** Tab key of the iTerm tab this process runs in, "" if not inside iTerm2. */
-function currentTabKey(env = process.env) {
-	return tabKey(env.ITERM_SESSION_ID ?? "");
+function worktreeBranch(id) {
+	return `worker/${id}`;
 }
-/** The iTerm UUID part of an ITERM_SESSION_ID (after the last colon). */
-function itermUuid(term) {
-	if (!term) return "";
-	return term.split(":").pop() ?? "";
+function worktreePath(logDir, id) {
+	return join(worktreesDir(logDir), id);
 }
-/**
-* Resolve the AIBroker session for an ITERM_SESSION_ID. Reads the persistent
-* name registry (the same store `aibroker_rename` writes); returns null when
-* AIBroker is absent or the session is not in it — callers then use the tab
-* key, which is the pre-AIBroker behaviour.
-*/
-function resolveSession(term, registryPath = AIBROKER_REGISTRY) {
-	const uuid = itermUuid(term);
-	if (!uuid) return null;
-	let names;
+/** Run git in `cwd`, returning trimmed stdout; throws with stderr on failure. */
+function git(cwd, args) {
 	try {
-		if (!existsSync(registryPath)) return null;
-		names = JSON.parse(readFileSync(registryPath, "utf8"));
+		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 null;
+		return false;
 	}
-	const name = names[uuid];
-	if (typeof name !== "string" || !name) return null;
-	return {
-		id: uuid,
-		name
-	};
 }
 /**
-* True when `worker` was launched from `term` (the terminal asking about it).
-* Session-id match first; the tab key only when no registry entry matched —
-* a session without a name keeps the tab-scoped behaviour it always had.
+* 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 workerInScope(worker, term) {
-	if (!term) return false;
-	const uuid = itermUuid(term);
-	if (worker.session?.id && uuid) return worker.session.id === uuid;
-	return tabKey(worker.term) === tabKey(term) && tabKey(term) !== "";
+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 ?? "");
 }
 /**
-* Registry key for pane files: the session id when AIBroker knows this
-* terminal, else the tab key, else the raw iTerm UUID.
+* 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 scopeKey(term) {
-	const session = resolveSession(term);
-	if (session) return session.id;
-	return currentTabKey() || itermUuid(term);
-}
-/** `[Name]` when the worker has an AIBroker session name, else "". */
-function sessionTag(worker) {
-	return worker.session?.name ? `[${worker.session.name}]` : "";
-}
-/** How old a map entry may be for a spawn to adopt it (status lines refresh constantly while a session lives). */
-const SPAWNER_SESSION_TTL_MS = 10 * 6e4;
-/** Map entries not refreshed within this window are pruned on write. */
-const SESSION_MAP_PRUNE_MS = 60 * 6e4;
-function sessionMapPath(logDir) {
-	return join(logDir, "claude-session-map.json");
+function addWorktree(logDir, id, cwd) {
+	const swept = sweepOrphanWorktrees(logDir);
+	if (swept.length) appendLedger(ledgerPath(logDir), "WORKER-NOTE", {
+		id,
+		note: `swept orphan worktree(s): ${swept.join(", ")}`
+	});
+	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
+	};
 }
 /**
-* The claude session a new run was spawned by, when it can be known: a run
-* inside another worker inherits its spawner (chain stages keep the
-* orchestrator's tab that way); otherwise a fresh map entry for `cwd`.
+* Remove worktrees (and their `worker/<id>` branches) whose worker no longer
+* exists — no status file left in the log dir. Killed and failed runs clean
+* up after themselves, but a `kill -9` or a crash strands a directory and a
+* branch; every worktree creation sweeps first so they cannot accumulate.
+* Directories younger than `minAgeMin` minutes are left alone: a run that is
+* just starting owns its worktree a moment before its status file exists.
 */
-function resolveSpawnerSession(logDir, cwd, env = process.env, now = Date.now()) {
-	const parentId = env.PAI_WORKER_ID;
-	if (parentId) {
-		const inherited = loadStatus(logDir, parentId)?.spawnerSession;
-		if (inherited) return inherited;
+function sweepOrphanWorktrees(logDir, minAgeMin = 10) {
+	const root = worktreesDir(logDir);
+	if (!existsSync(root)) return [];
+	const swept = [];
+	for (const ent of readdirSync(root, { withFileTypes: true })) {
+		if (!ent.isDirectory()) continue;
+		const id = ent.name;
+		const dir = join(root, id);
+		if (existsSync(statusPath(logDir, id))) continue;
+		try {
+			if ((Date.now() - statSync(dir).mtimeMs) / 6e4 < minAgeMin) continue;
+		} catch {}
+		let gitDir = null;
+		try {
+			const raw = git(dir, ["rev-parse", "--git-common-dir"]);
+			gitDir = isAbsolute(raw) ? raw : resolve(dir, raw);
+		} catch {
+			gitDir = null;
+		}
+		removeWorktree(gitDir ?? dir, dir, true);
+		if (gitDir) try {
+			git(gitDir, ["worktree", "prune"]);
+			git(gitDir, [
+				"branch",
+				"-D",
+				worktreeBranch(id)
+			]);
+		} catch {}
+		swept.push(id);
 	}
-	const path = sessionMapPath(logDir);
-	if (!existsSync(path) || !cwd) return null;
-	try {
-		const entry = JSON.parse(readFileSync(path, "utf8"))[cwd];
-		if (entry && entry.session && now - entry.ts < SPAWNER_SESSION_TTL_MS) return entry.session;
-	} catch {}
-	return null;
+	return swept;
 }
-/**
-* The iTerm UUID a claude session last rendered its status line in, when the
-* map knows one: the freshest entry naming that session. This is the reverse
-* of resolveSpawnerSession — worker → orchestrator there, orchestrator →
-* terminal here — and it exists so daemon-side pushes (supervision) can reach
-* a session that has no iTerm identity of its own in any worker status.
-*/
-function itermForClaudeSession(logDir, claudeSession, now = Date.now()) {
-	const path = sessionMapPath(logDir);
-	if (!existsSync(path) || !claudeSession) return null;
-	let map;
+/** Commits the branch collected on top of its base. */
+function commitsSince(dir, base) {
 	try {
-		map = JSON.parse(readFileSync(path, "utf8"));
+		return parseInt(git(dir, [
+			"rev-list",
+			"--count",
+			`${base}..HEAD`
+		]), 10) || 0;
 	} catch {
-		return null;
-	}
-	let best = null;
-	for (const e of Object.values(map)) {
-		if (e.session !== claudeSession || !e.term) continue;
-		if (now - e.ts >= SESSION_MAP_PRUNE_MS) continue;
-		if (!best || e.ts > best.ts) best = e;
+		return 0;
 	}
-	const term = best?.term;
-	return term ? itermUuid(term) : null;
 }
-
-//#endregion
-//#region src/workers/pane.ts
 /**
-* 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, 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. The follow
-* command is part of the split itself — iTerm creates the new session already
-* running it — so no text is ever typed into any session afterwards; a separate
-* typing step raced the operator's keystrokes (focus briefly sits on the new
-* pane after a split, and in one observed failure the command landed in the
-* operator's own shell). A split still makes the new session the tab's active
-* one — the scripts re-select the launching session right after, so a pane
-* opening never steals the keystrokes the operator is typing. Each
-* pane runs `pai worker follow <id> --auto-exit <n>` under the `pai-worker`
-* dynamic profile (Close Sessions On End), so panes disappear by themselves.
-*
-* Panes are tracked per scope (AIBroker session id, else tab key) in
-* <logDir>/panes/<key>.json, keyed by iTerm session unique id, newest first —
-* the split lands below the lowest live worker pane.
-*
-* The dynamic profile's font is the family of iTerm's DEFAULT profile (the
-* `Default Bookmark Guid` entry in New Bookmarks) at workers.pane.fontSize —
-* never the launching session's profile, which the Python version did and
-* which produced iTerm's "unknown parent name" dialog whenever the two
-* differed. `Dynamic Profile Parent Name` is only written when that name
-* actually exists in New Bookmarks; when iTerm's preferences cannot be read
-* the profile is still written, with font Menlo-Regular and no parent.
+* Record the worktree result in the status file: branch and commit count on
+* success, the worktree cleaned up on failure. Returns the updated status.
 */
-const PROFILE_NAME = "pai-worker";
-/** Where the dynamic profile lives (env override keeps tests off the real one). */
-function dynamicProfilePath() {
-	return process.env.PAI_WORKER_PROFILE ?? join(homedir(), "Library", "Application Support", "iTerm2", "DynamicProfiles", "pai-worker.json");
-}
-const WORKER_SPLIT_SCRIPT = `on run(argv)
-    set targetID to item 1 of argv
-    set candList to item 2 of argv
-    set followCmd to item 3 of argv
-    set profileName to item 4 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
-                        -- 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)
-                        end repeat
-                        set lived to {}
-                        set splitS to missing value
-                        repeat with cid in my splitIds(candList)
-                            set cidText to (cid as text)
-                            if sessIDs contains cidText then
-                                set end of lived to cidText
-                                if splitS is missing value then
-                                    set splitS to first session of t whose id is cidText
-                                end if
-                            end if
-                        end repeat
-                        -- the follow command is part of the split itself: the
-                        -- pane is born already running it, so no text is ever
-                        -- typed into any session — a typing step raced the
-                        -- operator's keystrokes and could even land in the
-                        -- operator's own session
-                        if profileName is "" then
-                            if splitS is missing value then
-                                tell s
-                                    set newS to split vertically with default profile command followCmd
-                                end tell
-                            else
-                                tell splitS
-                                    set newS to split horizontally with default profile command followCmd
-                                end tell
-                            end if
-                        else
-                            if splitS is missing value then
-                                tell s
-                                    set newS to split vertically with profile profileName command followCmd
-                                end tell
-                            else
-                                tell splitS
-                                    set newS to split horizontally with profile profileName command followCmd
-                                end tell
-                            end if
-                        end if
-                        -- a split makes the new session the tab's active one:
-                        -- re-select the launching session so focus returns to
-                        -- where the operator was typing, never the new pane
-                        try
-                            select s
-                        end try
-                        try
-                            set bounds of w to winBounds
-                        end try
-                        set out to ""
-                        repeat with lid in lived
-                            set out to out & lid & ","
-                        end repeat
-                        return out & "|" & (id of newS as text)
-                    end if
-                end repeat
-            end repeat
-        end repeat
-    end tell
-    return "notfound"
-end run
-
-on splitIds(s)
-    set out to {}
-    if s is "" then return out
-    set prevDels to AppleScript's text item delimiters
-    set AppleScript's text item delimiters to ","
-    repeat with part in text items of s
-        set end of out to (part as text)
-    end repeat
-    set AppleScript's text item delimiters to prevDels
-    return out
-end splitIds`;
-const TAB_TTYS_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
-                        set ttys to {}
-                        repeat with other in sessions of t
-                            copy (tty of other) to end of ttys
-                        end repeat
-                        return ttys
-                    end if
-                end repeat
-            end repeat
-        end repeat
-    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
-    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
-                        -- the follow command is part of the split itself (see
-                        -- WORKER_SPLIT_SCRIPT): nothing is ever typed into a
-                        -- session afterwards
-                        tell s
-                            set newS to split vertically with default profile command followCmd
-                        end tell
-                        -- keep the tab's active session where it was (see
-                        -- WORKER_SPLIT_SCRIPT)
-                        try
-                            select s
-                        end try
-                        return "opened"
-                    end if
-                end repeat
-            end repeat
-        end repeat
-    end tell
-    return "notfound"
-end run`;
-/** Run an AppleScript with argv. Rejects when osascript itself cannot run. */
-function osascript(script, args) {
-	return new Promise((resolve, reject) => {
-		const proc = spawn("osascript", ["-", ...args], { stdio: [
-			"pipe",
-			"pipe",
-			"pipe"
-		] });
-		let out = "";
-		let err = "";
-		proc.stdout.on("data", (c) => out += c.toString("utf8"));
-		proc.stderr.on("data", (c) => err += c.toString("utf8"));
-		proc.on("error", reject);
-		proc.on("close", () => resolve({
-			stdout: out,
-			stderr: err
-		}));
-		proc.stdin.write(script);
-		proc.stdin.end();
-	});
-}
-function psOutput(format) {
-	try {
-		return execFileSync("ps", ["-axo", format], { encoding: "utf8" });
-	} catch {
-		return "";
-	}
-}
-/** TTys of running `worker follow` processes, normalised to /dev/ttysNNN. */
-function followTtys() {
-	const ttys = /* @__PURE__ */ new Set();
-	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;
-		if (parts[0].startsWith("ttys")) ttys.add(`/dev/${parts[0]}`);
+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;
 	}
-	return ttys;
-}
-/** 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("command=").split("\n").some((ln) => pat.test(ln));
-}
-/** plutil's message for an ExecFileSync failure, else the exception text. */
-function toolErr(e) {
-	const err = e;
-	return ((typeof err.stderr === "string" ? err.stderr : err.stderr?.toString("utf8")) || err.message || String(e)).trim();
+	saveStatus(logDir, s);
+	return s;
 }
-/**
-* Read New Bookmarks and Default Bookmark Guid from an iTerm preferences
-* plist. Key-scoped `plutil -extract`, never a whole-file JSON conversion:
-* real iTerm preferences carry `<date>` objects (SULastCheckTime & friends)
-* which `plutil -convert json` rejects outright — "Invalid object in plist
-* for JSON format" — so the whole-file read always failed and the dynamic
-* profile was never written.
-*/
-function readItermPlist(plistPath) {
-	let bookmarks = [];
-	try {
-		const out = execFileSync("plutil", [
-			"-extract",
-			"New Bookmarks",
-			"json",
-			"-o",
-			"-",
-			plistPath
-		], {
-			encoding: "utf8",
-			timeout: 1e4
-		});
-		const parsed = JSON.parse(out);
-		if (Array.isArray(parsed)) bookmarks = parsed;
-	} catch (e) {
-		return {
-			bookmarks: [],
-			defaultGuid: null,
-			error: `extracting New Bookmarks: ${toolErr(e)}`
-		};
-	}
-	let defaultGuid = null;
+/** Remove a worktree directory from git's books and the filesystem. */
+function removeWorktree(cwd, dir, force) {
 	try {
-		defaultGuid = execFileSync("plutil", [
-			"-extract",
-			"Default Bookmark Guid",
-			"raw",
-			"-o",
-			"-",
-			plistPath
-		], {
-			encoding: "utf8",
-			timeout: 1e4
-		}).trim() || null;
+		git(cwd, [
+			"worktree",
+			"remove",
+			...force ? ["--force"] : [],
+			dir
+		]);
+		return;
 	} catch {}
-	return {
-		bookmarks,
-		defaultGuid,
-		error: null
-	};
-}
-/** iTerm's exported preferences, via a temp plist (no shell pipe involved). */
-function itermPrefs() {
-	let dir = null;
-	try {
-		dir = mkdtempSync(join(tmpdir(), "pai-iterm-"));
-		const plist = join(dir, "iterm2.plist");
-		execFileSync("defaults", [
-			"export",
-			"com.googlecode.iterm2",
-			plist
-		], {
-			encoding: "utf8",
-			timeout: 1e4
+	if (existsSync(dir)) try {
+		rmSync(dir, {
+			recursive: true,
+			force: true
 		});
-		return readItermPlist(plist);
-	} catch (e) {
-		return {
-			bookmarks: [],
-			defaultGuid: null,
-			error: `defaults export: ${toolErr(e)}`
-		};
-	} finally {
-		if (dir) try {
-			rmSync(dir, {
-				recursive: true,
-				force: true
-			});
-		} catch {}
-	}
-}
-/** The New Bookmarks entry of that profile name, null if absent. */
-function bookmarkFrom(read, named) {
-	return read.bookmarks.find((b) => b.Name === named) ?? null;
-}
-/** The bookmark iTerm marks default, null when it is missing or unreadable. */
-function defaultBookmarkFrom(read) {
-	return read.defaultGuid ? read.bookmarks.find((b) => b.Guid === read.defaultGuid) ?? null : null;
-}
-/** The default profile, read fresh from iTerm's preferences. */
-function defaultBookmark() {
-	return defaultBookmarkFrom(itermPrefs());
+		git(cwd, ["worktree", "prune"]);
+	} catch {}
 }
 /**
-* The pane profile's font: the family of iTerm's default profile at
-* `fontSize` points ("MesloLGLNFM-Regular 18" + 13 → "MesloLGLNFM-Regular 13"),
-* or "Menlo-Regular <fontSize>" when the default font cannot be read.
+* Tracked changes (staged or not) plus untracked files — everything a
+* `git add -A` in `wtDir` would commit. The same two calls the old patch
+* carry used; name-only, not porcelain: a worktree-only change renders as
+* " M path" and the shared git() helper trims that leading space away.
 */
-function paneFont(font, fontSize) {
-	const idx = (font ?? "").lastIndexOf(" ");
-	if (idx > 0) {
-		const family = font.slice(0, idx);
-		if (!Number.isNaN(parseFloat(font.slice(idx + 1)))) return `${family} ${fontSize}`;
-	}
-	return `Menlo-Regular ${fontSize}`;
-}
-/** Write the pai-worker dynamic profile; iTerm2 loads that directory itself. */
-function writeDynamicProfile(parent, fontSize, read = itermPrefs) {
-	const profile = {
-		Name: PROFILE_NAME,
-		Guid: "pai-worker-dynamic-profile",
-		"Normal Font": paneFont(parent?.["Normal Font"], fontSize),
-		"Close Sessions On End": true
-	};
-	if (parent?.Name && bookmarkFrom(read(), parent.Name)) profile["Dynamic Profile Parent Name"] = parent.Name;
-	const path = dynamicProfilePath();
-	const dir = dirname(path);
-	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-	const tmp = `${path}.tmp`;
-	writeFileSync(tmp, JSON.stringify({ Profiles: [profile] }, null, 2) + "\n", "utf8");
-	renameSync(tmp, path);
+function uncommittedPaths(wtDir) {
+	const tracked = git(wtDir, [
+		"diff",
+		"--name-only",
+		"HEAD"
+	]).split("\n").filter(Boolean);
+	const untracked = git(wtDir, [
+		"ls-files",
+		"--others",
+		"--exclude-standard"
+	]).split("\n").filter(Boolean);
+	return [...tracked, ...untracked];
 }
-let warnedPrefs = false;
 /**
-* Profile for new worker panes, creating the small-font one on demand.
-* "" means "split with the default profile" (also the fallback when the
-* dynamic profile does not show up in time).
-*
-* The profile file is written whenever it is missing — even when iTerm's
-* preferences cannot be read; then it gets font "Menlo-Regular <fontSize>"
-* and no parent, and the reason is logged to stderr once.
+* Commit a worktree's uncommitted changes to its branch so the merge carries
+* them. `git merge` only moves committed work, so a worker that stopped
+* without committing would lose its edits to `worktree remove` — exactly
+* what happened live on 2026-09-17. Returns the salvaged paths, [] when the
+* worktree is clean. A failed commit throws with the worktree untouched:
+* its edits are still on disk, so nothing is lost.
 */
-async function followProfile(fontSize, read = itermPrefs) {
-	const first = read();
-	const parent = defaultBookmarkFrom(first);
-	const path = dynamicProfilePath();
-	const existed = existsSync(path);
-	if (!existed) writeDynamicProfile(parent, fontSize, () => first);
-	if (!parent) {
-		if (!warnedPrefs) {
-			warnedPrefs = true;
-			const reason = first.error ?? "no profile is marked default";
-			const what = existed ? `keeping ${path} as-is` : `wrote ${path} with Menlo-Regular ${fontSize} and no parent`;
-			process.stderr.write(`pai worker pane: cannot read iTerm's default profile (${reason}) — ${what}\n`);
-		}
-		if (first.error) return "";
-	}
-	for (let i = 0; i < 10; i++) {
-		if (bookmarkFrom(read(), PROFILE_NAME)) return PROFILE_NAME;
-		await new Promise((r) => setTimeout(r, 200));
-	}
-	process.stderr.write(`pai worker pane: profile ${PROFILE_NAME} not visible, splitting with default\n`);
-	return "";
-}
-function loadRegistry(path) {
+function salvageUncommitted(wtDir, label) {
+	const paths = uncommittedPaths(wtDir);
+	if (!paths.length) return [];
 	try {
-		const reg = JSON.parse(readFileSync(path, "utf8"));
-		return Array.isArray(reg) ? reg : [];
-	} catch {
-		return [];
+		git(wtDir, ["add", "-A"]);
+		git(wtDir, [
+			"commit",
+			"-m",
+			`salvaged: ${label}`
+		]);
+	} catch (e) {
+		throw new Error(`cannot salvage the uncommitted changes in ${wtDir} — ${e.message}; nothing was lost: commit them there by hand, then re-run merge`);
 	}
-}
-function saveRegistry(path, reg) {
-	const dir = dirname(path);
-	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-	const tmp = `${path}.tmp`;
-	writeFileSync(tmp, JSON.stringify(reg, null, 1), "utf8");
-	renameSync(tmp, path);
+	return paths;
 }
 /**
-* The command a worker pane runs: one exec-able line with no shell syntax —
-* iTerm's split command parameter execs without a shell (proven live: panes
-* survive `sleep 30` and a single-quoted `/bin/sh -c`, die instantly on
-* `export …; …` or a redirect), so the command must be one exec-able line.
-* Absolute node on the CLI entry file also sidesteps the panes' bare launchd
-* PATH (no pai, no node) and the `#!/usr/bin/env node` shebang.
+* The dirty paths of a checkout, parsed from `git status --porcelain -z`:
+* NUL-separated (a path with a newline in it cannot corrupt the parse),
+* rename entries contribute both sides, and any quoting is stripped.
 */
-function followCommand(wid, autoExitSecs) {
-	return `${process.execPath} ${absoluteCliPath()} worker follow ${wid} --auto-exit ${autoExitSecs}`;
+function dirtyPaths(cwd) {
+	const fields = execFileSync("git", [
+		"-C",
+		cwd,
+		"status",
+		"--porcelain",
+		"-z"
+	], {
+		encoding: "utf8",
+		timeout: 3e4,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	}).split("\0");
+	const strip = (p) => p.startsWith("\"") && p.endsWith("\"") ? p.slice(1, -1) : p;
+	const out = [];
+	for (let i = 0; i < fields.length; i++) {
+		const f = fields[i];
+		if (!f || f.length < 4 || f.charAt(2) !== " ") continue;
+		out.push(strip(f.slice(3)));
+		const xy = f.slice(0, 2);
+		if (xy.includes("R") || xy.includes("C")) {
+			const orig = fields[i + 1];
+			if (orig && orig.charAt(2) !== " ") {
+				out.push(strip(orig));
+				i += 1;
+			}
+		}
+	}
+	return out;
 }
-/** Absolute path of the running pai CLI; falls back to PATH lookup at spawn. */
-function absoluteCliPath() {
-	const argv1 = process.argv[1] ?? "";
-	if (argv1.endsWith("pai")) return argv1;
-	return "pai";
+/**
+* Refuse the merge when the original checkout is dirty in paths the branch
+* touches: the merge would overwrite those edits or fail on them, either way
+* leaving a half-state. No merge is made, the worktree stays.
+*/
+function assertNoDirtyOverlap(cwd, incoming, id, branch) {
+	const dirty = new Set(dirtyPaths(cwd));
+	const overlap = [...new Set(incoming)].filter((p) => dirty.has(p)).sort();
+	if (!overlap.length) return;
+	throw new Error(`worker ${id}: the checkout ${cwd} has uncommitted changes in paths ${branch} touches: ${overlap.join(", ")}. Commit or stash them in the checkout, then re-run: pai worker merge ${id}. No merge was made; the worktree was kept.`);
 }
-/** Open (or only report on) the stacked follow pane of one worker. */
-async function openPaneForWorker(logDir, config, wid, term) {
-	if (workerPaneOpen(wid)) return `pane for ${wid} already open`;
-	const uid = itermUuid(term);
-	const regPath = join(panesDir(logDir), `${scopeKey(term)}.json`);
-	const reg = loadRegistry(regPath);
-	const profile = await followProfile(config.pane.fontSize);
-	const cmd = followCommand(wid, config.pane.autoExitSecs);
-	const p = await osascript(WORKER_SPLIT_SCRIPT, [
-		uid,
-		[...reg].reverse().map((e) => e.session).join(","),
-		cmd,
-		profile
-	]);
-	const out = p.stdout.trim();
-	if (out === "notfound" || out === "notrunning") throw new Error(out === "notfound" ? "pai worker pane: no open iTerm2 session matches ITERM_SESSION_ID" : "pai worker pane: iTerm2 is not running");
-	const bar = out.indexOf("|");
-	if (bar < 0) throw new Error(`pai worker pane: osascript failed: ${(p.stderr || out).slice(0, 200)}`);
-	const live = new Set(out.slice(0, bar).split(",").filter(Boolean));
-	const pruned = reg.filter((e) => live.has(e.session));
-	pruned.push({
-		session: out.slice(bar + 1),
-		worker: wid,
-		opened: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19)
-	});
-	saveRegistry(regPath, pruned);
-	return `pane opened for ${wid}`;
+/** Never remove a worktree that still holds uncommitted changes. */
+function assertWorktreeClean(wtDir, id) {
+	const leftover = uncommittedPaths(wtDir);
+	if (leftover.length) throw new Error(`worker ${id}: the worktree ${wtDir} still holds uncommitted changes (${leftover.join(", ")}) — it was NOT removed; commit or copy them by hand, then re-run merge`);
 }
 /**
-* 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.
+* `pai worker merge <id>`: salvage whatever the worker left uncommitted onto
+* its branch, refuse when the original checkout is dirty in paths the branch
+* touches, merge with --no-ff (the merge commit names the worker), then
+* remove the worktree and delete the branch; the status gains `merged: true`.
+* A branch with nothing to merge is refused loudly — after salvage that
+* genuinely means it holds nothing, and reporting success there would
+* destroy the worktree for no gain.
 */
-async function windowBoundsLine(term) {
-	const uid = itermUuid(term);
-	if (!uid) return "window bounds: (not in iTerm2)";
+function mergeWorker(logDir, id) {
+	const st = mustHaveBranch(logDir, id);
+	if (st.merged) return `worker ${id}: branch ${st.branch} already merged`;
+	const salvaged = existsSync(st.worktreeDir) ? salvageUncommitted(st.worktreeDir, st.label || UNLABELED) : [];
+	if ((parseInt(git(st.cwd, [
+		"rev-list",
+		"--count",
+		`HEAD..${st.branch}`
+	]), 10) || 0) <= 0) throw new Error(`worker ${id}: branch ${st.branch} has no commits to merge. The worktree ${st.worktreeDir} was NOT removed — uncommitted work there would be destroyed. Commit it yourself, or drop everything with: pai worker discard ${id}`);
+	const mergeBase = git(st.cwd, [
+		"merge-base",
+		"HEAD",
+		st.branch
+	]);
+	const incomingPaths = git(st.cwd, [
+		"diff",
+		"--name-only",
+		mergeBase,
+		st.branch
+	]).split("\n").filter(Boolean);
+	assertNoDirtyOverlap(st.cwd, incomingPaths, id, st.branch);
 	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)})`;
+		git(st.cwd, [
+			"merge",
+			"--no-ff",
+			st.branch,
+			"-m",
+			`merge worker ${id} (${st.label})`
+		]);
 	} catch (e) {
-		return `window bounds: (osascript: ${String(e.message ?? e).slice(0, 120)})`;
+		throw new Error(`worker ${id}: git refused the merge of ${st.branch} — ${e.message}. The worktree ${st.worktreeDir} was kept: resolve the conflict, then re-run merge`);
+	}
+	if (existsSync(st.worktreeDir)) assertWorktreeClean(st.worktreeDir, id);
+	removeWorktree(st.cwd, st.worktreeDir, false);
+	let branchGone = true;
+	try {
+		git(st.cwd, [
+			"branch",
+			"-d",
+			st.branch
+		]);
+	} catch {
+		branchGone = false;
 	}
+	saveStatus(logDir, {
+		...st,
+		merged: true
+	});
+	const base = `merged ${st.branch} into ${st.cwd} (worktree removed${branchGone ? ", branch deleted" : "; branch kept: git refused -d"})`;
+	return salvaged.length ? `${base}; salvaged ${salvaged.length} uncommitted change(s): ${salvaged.join(", ")}` : base;
 }
-/**
-* Report-only variant used by `pai worker pane <id> --check`: whether a pane
-* 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, 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)";
-		try {
-			font = JSON.parse(readFileSync(path, "utf8")).Profiles?.[0]?.["Normal Font"] ?? "(none)";
-		} catch {}
-		lines.push(`profile file: ${path} (exists)`);
-		lines.push(`profile font: ${font}`);
-	} else {
-		const parent = defaultBookmark();
-		lines.push(`profile file: ${path} (missing)`);
-		lines.push(`profile font (would write): ${paneFont(parent?.["Normal Font"], fontSize)}`);
+/** `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;
 	}
-	return lines.join("\n");
+	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;
 }
 /**
-* Split this iTerm tab and run `pai worker follow` in the new pane, unless
-* one already runs here (detected by TTY — iTerm overwrites session names
-* with the running command, so names cannot serve as idempotence).
+* 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.
 */
-async function openFollowPane(logDir, _config, term, checkOnly) {
-	const uid = itermUuid(term);
-	const out = (await osascript(TAB_TTYS_SCRIPT, [uid])).stdout.trim();
-	if (out === "notfound") throw new Error("pai worker pane: no open iTerm2 session matches ITERM_SESSION_ID");
-	if (out === "notrunning") throw new Error("pai worker pane: iTerm2 is not running");
-	if ([...new Set(out.split(",").map((t) => t.trim()).filter(Boolean))].filter((t) => followTtys().has(t)).length > 0) return "follow pane already open";
-	if (checkOnly) return "no follow pane";
-	const s = await osascript(SPLIT_SCRIPT, [uid, `${process.execPath} ${absoluteCliPath()} worker follow`]);
-	const sout = s.stdout.trim();
-	if (sout === "opened") return "follow pane opened";
-	if (sout === "notfound") throw new Error("pai worker pane: no open iTerm2 session matches ITERM_SESSION_ID");
-	throw new Error(`pai worker pane: osascript failed: ${(s.stderr || sout).slice(0, 200)}`);
+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`.",
+		"Use ONLY relative paths inside the worktree, never absolute worktree paths — absolute paths break after merge and leak machine layout."
+	].join("\n");
 }
 
 //#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;
+//#region src/workers/scope.ts
+/**
+* scope.ts — which workers "belong" to the terminal asking about them.
+*
+* Two identities, in priority order:
+*
+*   1. AIBroker's session registry (~/.aibroker/session-names.json): iTerm
+*      session UUID → session name. The launching session's UUID is stored in
+*      each worker's status file as `session.id`, so every pane of a named
+*      session sees its workers — regardless of tab layout.
+*   2. The iTerm tab key (`w<window>t<tab>` prefix of ITERM_SESSION_ID): the
+*      original heuristic, kept as the fallback when no registry entry
+*      matches (AIBroker absent, unnamed session, non-iTerm terminal).
+*
+* If neither is available, viewers fall back to "all workers".
+*
+* A third case: workers spawned from a Claude Code Bash tool (the
+* orchestrator pattern) have neither — Claude Code exports no terminal or
+* session identity to its Bash children. Those record `spawnerSession`, the
+* orchestrator's claude session id bridged through the status line's
+* session map (see below), so their tab still claims them.
+*/
+const AIBROKER_REGISTRY = join(homedir(), ".aibroker", "session-names.json");
+/**
+* `w<window>t<tab>` prefix of an iTerm session id, "" if empty or malformed.
+* Panes split from the same tab share this prefix and differ only in `p<n>`.
+*/
+function tabKey(term) {
+	if (!term) return "";
+	const head = term.split("p", 1)[0];
+	const parts = head.slice(1).split("t");
+	if (head.startsWith("w") && parts.length === 2 && parts.every((p) => /^\d+$/.test(p))) return head;
+	return "";
+}
+/** Tab key of the iTerm tab this process runs in, "" if not inside iTerm2. */
+function currentTabKey(env = process.env) {
+	return tabKey(env.ITERM_SESSION_ID ?? "");
+}
+/** The iTerm UUID part of an ITERM_SESSION_ID (after the last colon). */
+function itermUuid(term) {
+	if (!term) return "";
+	return term.split(":").pop() ?? "";
 }
 /**
-* 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. `chatIsRoot` stops one level short of the
-* chat-pane tracker (origin "chat"): the status line treats the pane as the
-* bar itself, so the workers it spawned are its top level.
+* Resolve the AIBroker session for an ITERM_SESSION_ID. Reads the persistent
+* name registry (the same store `aibroker_rename` writes); returns null when
+* AIBroker is absent or the session is not in it — callers then use the tab
+* key, which is the pre-AIBroker behaviour.
 */
-function workerDepth(statuses, id, opts) {
-	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;
-		if (!(opts?.chatIsRoot && next.origin === "chat")) depth += 1;
-		cur = next;
+function resolveSession(term, registryPath = AIBROKER_REGISTRY) {
+	const uuid = itermUuid(term);
+	if (!uuid) return null;
+	let names;
+	try {
+		if (!existsSync(registryPath)) return null;
+		names = JSON.parse(readFileSync(registryPath, "utf8"));
+	} catch {
+		return null;
 	}
-	return depth;
-}
-/** Children of `parent` that are still running, oldest first. */
-function runningChildren(statuses, parent) {
-	return statuses.filter((s) => s.parent === parent && isLive(s));
+	const name = names[uuid];
+	if (typeof name !== "string" || !name) return null;
+	return {
+		id: uuid,
+		name
+	};
 }
 /**
-* 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).
+* True when `worker` was launched from `term` (the terminal asking about it).
+* Session-id match first; the tab key only when no registry entry matched —
+* a session without a name keeps the tab-scoped behaviour it always had.
 */
-function 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`);
+function workerInScope(worker, term) {
+	if (!term) return false;
+	const uuid = itermUuid(term);
+	if (worker.session?.id && uuid) return worker.session.id === uuid;
+	return tabKey(worker.term) === tabKey(term) && tabKey(term) !== "";
 }
 /**
-* 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.
+* Registry key for pane files: the session id when AIBroker knows this
+* terminal, else the tab key, else the raw iTerm UUID.
 */
-function launchParent(explicit, env = process.env) {
-	return explicit ?? parentFromEnv(env);
+function scopeKey(term) {
+	const session = resolveSession(term);
+	if (session) return session.id;
+	return currentTabKey() || itermUuid(term);
 }
-/** 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;
+/** `[Name]` when the worker has an AIBroker session name, else "". */
+function sessionTag(worker) {
+	return worker.session?.name ? `[${worker.session.name}]` : "";
+}
+/** How old a map entry may be for a spawn to adopt it (status lines refresh constantly while a session lives). */
+const SPAWNER_SESSION_TTL_MS = 10 * 6e4;
+/** Map entries not refreshed within this window are pruned on write. */
+const SESSION_MAP_PRUNE_MS = 60 * 6e4;
+function sessionMapPath(logDir) {
+	return join(logDir, "claude-session-map.json");
 }
-
-//#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.
+* The claude session a new run was spawned by, when it can be known: a run
+* inside another worker inherits its spawner (chain stages keep the
+* orchestrator's tab that way); otherwise a fresh map entry for `cwd`.
 */
-function operatorSocketPath(logDir, id) {
-	return join(logDir, `${id}.sock`);
+function resolveSpawnerSession(logDir, cwd, env = process.env, now = Date.now()) {
+	const parentId = env.PAI_WORKER_ID;
+	if (parentId) {
+		const inherited = loadStatus(logDir, parentId)?.spawnerSession;
+		if (inherited) return inherited;
+	}
+	const path = sessionMapPath(logDir);
+	if (!existsSync(path) || !cwd) return null;
+	try {
+		const entry = JSON.parse(readFileSync(path, "utf8"))[cwd];
+		if (entry && entry.session && now - entry.ts < SPAWNER_SESSION_TTL_MS) return entry.session;
+	} catch {}
+	return null;
 }
 /**
-* The 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).
+* The iTerm UUID a claude session last rendered its status line in, when the
+* map knows one: the freshest entry naming that session. This is the reverse
+* of resolveSpawnerSession — worker → orchestrator there, orchestrator →
+* terminal here — and it exists so daemon-side pushes (supervision) can reach
+* a session that has no iTerm identity of its own in any worker status.
 */
-function createOperatorServer(logDir, id, onLine) {
-	const path = operatorSocketPath(logDir, id);
+function itermForClaudeSession(logDir, claudeSession, now = Date.now()) {
+	const path = sessionMapPath(logDir);
+	if (!existsSync(path) || !claudeSession) return null;
+	let map;
 	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;
+		map = JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		return null;
+	}
+	let best = null;
+	for (const e of Object.values(map)) {
+		if (e.session !== claudeSession || !e.term) continue;
+		if (now - e.ts >= SESSION_MAP_PRUNE_MS) continue;
+		if (!best || e.ts > best.ts) best = e;
+	}
+	const term = best?.term;
+	return term ? itermUuid(term) : null;
+}
+
+//#endregion
+//#region src/workers/engines/image.ts
+/**
+* engines/image.ts — the `engine: image` worker.
+*
+* No claude-code process, no worktree, no MCP: `pai worker run --capability
+* image` POSTs one OpenAI-compatible images-generations request straight to
+* the provider's `url` and writes the PNG it gets back. One request, no
+* retries beyond the fetch's own timeout — a caller that wants another try
+* just runs again.
+*/
+const DEFAULT_SIZE = "1024x1024";
+const DEFAULT_IMAGE_TIMEOUT_MS = 12e4;
+/**
+* `POST {url}/images/generations` with `{model, prompt, size, n: 1,
+* response_format: "b64_json"}` and the provider's bearer token, decode the
+* base64 PNG it returns, and write it to `outPath`.
+*/
+async function runImageCapability(opts) {
+	if (!opts.provider.baseUrl) throw new WorkersConfigError(`provider "${opts.providerName}" (engine image) has no "url" configured — set one with: pai worker providers update ${opts.providerName} --base-url <url>`);
+	const token = resolveProviderKey(opts.provider);
+	const url = `${opts.provider.baseUrl.replace(/\/+$/, "")}/images/generations`;
+	const timeoutMs = opts.timeoutMs ?? DEFAULT_IMAGE_TIMEOUT_MS;
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+	const t0 = Date.now();
+	let res;
+	try {
+		res = await fetch(url, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				...token ? { authorization: `Bearer ${token}` } : {}
+			},
+			body: JSON.stringify({
+				model: opts.model,
+				prompt: opts.prompt,
+				size: opts.size ?? DEFAULT_SIZE,
+				n: 1,
+				response_format: "b64_json"
+			}),
+			signal: controller.signal
+		});
+	} catch (e) {
+		if (e instanceof Error && e.name === "AbortError") throw new WorkersConfigError(`provider "${opts.providerName}": image request timed out after ${timeoutMs}ms`);
+		throw new WorkersConfigError(`provider "${opts.providerName}": image request failed: ${e instanceof Error ? e.message : String(e)}`);
+	} finally {
+		clearTimeout(timer);
+	}
+	const durationMs = Date.now() - t0;
+	const text = await res.text();
+	if (!res.ok) throw new WorkersConfigError(`provider "${opts.providerName}": image request failed (${res.status}): ${text.slice(0, 500)}`);
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		throw new WorkersConfigError(`provider "${opts.providerName}": image response was not JSON`);
+	}
+	const b64 = parsed.data?.[0]?.b64_json;
+	if (!b64) throw new WorkersConfigError(`provider "${opts.providerName}": image response had no data[0].b64_json`);
+	const bytes = Buffer.from(b64, "base64");
+	mkdirSync(dirname(opts.outPath), { recursive: true });
+	writeFileSync(opts.outPath, bytes);
+	return {
+		ok: true,
+		path: opts.outPath,
+		model: opts.model,
+		provider: opts.providerName,
+		durationMs,
+		bytes: bytes.length
+	};
 }
+
+//#endregion
+//#region src/workers/pane.ts
 /**
-* `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.
+* 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, 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. The follow
+* command is part of the split itself — iTerm creates the new session already
+* running it — so no text is ever typed into any session afterwards; a separate
+* typing step raced the operator's keystrokes (focus briefly sits on the new
+* pane after a split, and in one observed failure the command landed in the
+* operator's own shell). A split still makes the new session the tab's active
+* one — the scripts re-select the launching session right after, so a pane
+* opening never steals the keystrokes the operator is typing. Each
+* pane runs `pai worker follow <id> --auto-exit <n>` under the `pai-worker`
+* dynamic profile (Close Sessions On End), so panes disappear by themselves.
+*
+* Panes are tracked per scope (AIBroker session id, else tab key) in
+* <logDir>/panes/<key>.json, keyed by iTerm session unique id, newest first —
+* the split lands below the lowest live worker pane.
+*
+* The dynamic profile's font is the family of iTerm's DEFAULT profile (the
+* `Default Bookmark Guid` entry in New Bookmarks) at workers.pane.fontSize —
+* never the launching session's profile, which the Python version did and
+* which produced iTerm's "unknown parent name" dialog whenever the two
+* differed. `Dynamic Profile Parent Name` is only written when that name
+* actually exists in New Bookmarks; when iTerm's preferences cannot be read
+* the profile is still written, with font Menlo-Regular and no parent.
 */
-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 (!isLive(status)) 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`));
+const PROFILE_NAME = "pai-worker";
+/** Where the dynamic profile lives (env override keeps tests off the real one). */
+function dynamicProfilePath() {
+	return process.env.PAI_WORKER_PROFILE ?? join(homedir(), "Library", "Application Support", "iTerm2", "DynamicProfiles", "pai-worker.json");
+}
+const WORKER_SPLIT_SCRIPT = `on run(argv)
+    set targetID to item 1 of argv
+    set candList to item 2 of argv
+    set followCmd to item 3 of argv
+    set profileName to item 4 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
+                        -- 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)
+                        end repeat
+                        set lived to {}
+                        set splitS to missing value
+                        repeat with cid in my splitIds(candList)
+                            set cidText to (cid as text)
+                            if sessIDs contains cidText then
+                                set end of lived to cidText
+                                if splitS is missing value then
+                                    set splitS to first session of t whose id is cidText
+                                end if
+                            end if
+                        end repeat
+                        -- the follow command is part of the split itself: the
+                        -- pane is born already running it, so no text is ever
+                        -- typed into any session — a typing step raced the
+                        -- operator's keystrokes and could even land in the
+                        -- operator's own session
+                        if profileName is "" then
+                            if splitS is missing value then
+                                tell s
+                                    set newS to split vertically with default profile command followCmd
+                                end tell
+                            else
+                                tell splitS
+                                    set newS to split horizontally with default profile command followCmd
+                                end tell
+                            end if
+                        else
+                            if splitS is missing value then
+                                tell s
+                                    set newS to split vertically with profile profileName command followCmd
+                                end tell
+                            else
+                                tell splitS
+                                    set newS to split horizontally with profile profileName command followCmd
+                                end tell
+                            end if
+                        end if
+                        -- a split makes the new session the tab's active one:
+                        -- re-select the launching session so focus returns to
+                        -- where the operator was typing, never the new pane
+                        try
+                            select s
+                        end try
+                        try
+                            set bounds of w to winBounds
+                        end try
+                        set out to ""
+                        repeat with lid in lived
+                            set out to out & lid & ","
+                        end repeat
+                        return out & "|" & (id of newS as text)
+                    end if
+                end repeat
+            end repeat
+        end repeat
+    end tell
+    return "notfound"
+end run
+
+on splitIds(s)
+    set out to {}
+    if s is "" then return out
+    set prevDels to AppleScript's text item delimiters
+    set AppleScript's text item delimiters to ","
+    repeat with part in text items of s
+        set end of out to (part as text)
+    end repeat
+    set AppleScript's text item delimiters to prevDels
+    return out
+end splitIds`;
+const TAB_TTYS_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
+                        set ttys to {}
+                        repeat with other in sessions of t
+                            copy (tty of other) to end of ttys
+                        end repeat
+                        return ttys
+                    end if
+                end repeat
+            end repeat
+        end repeat
+    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
+    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
+                        -- the follow command is part of the split itself (see
+                        -- WORKER_SPLIT_SCRIPT): nothing is ever typed into a
+                        -- session afterwards
+                        tell s
+                            set newS to split vertically with default profile command followCmd
+                        end tell
+                        -- keep the tab's active session where it was (see
+                        -- WORKER_SPLIT_SCRIPT)
+                        try
+                            select s
+                        end try
+                        return "opened"
+                    end if
+                end repeat
+            end repeat
+        end repeat
+    end tell
+    return "notfound"
+end run`;
+/** Run an AppleScript with argv. Rejects when osascript itself cannot run. */
+function osascript(script, args) {
 	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");
-		});
+		const proc = spawn("osascript", ["-", ...args], { stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		] });
+		let out = "";
+		let err = "";
+		proc.stdout.on("data", (c) => out += c.toString("utf8"));
+		proc.stderr.on("data", (c) => err += c.toString("utf8"));
+		proc.on("error", reject);
+		proc.on("close", () => resolve({
+			stdout: out,
+			stderr: err
+		}));
+		proc.stdin.write(script);
+		proc.stdin.end();
 	});
 }
-
-//#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 psOutput(format) {
+	try {
+		return execFileSync("ps", ["-axo", format], { encoding: "utf8" });
+	} catch {
+		return "";
+	}
+}
+/** TTys of running `worker follow` processes, normalised to /dev/ttysNNN. */
+function followTtys() {
+	const ttys = /* @__PURE__ */ new Set();
+	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;
+		if (parts[0].startsWith("ttys")) ttys.add(`/dev/${parts[0]}`);
+	}
+	return ttys;
 }
-function isHandoffKind(v) {
-	return typeof v === "string" && HANDOFF_KINDS.includes(v);
+/** 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("command=").split("\n").some((ln) => pat.test(ln));
+}
+/** plutil's message for an ExecFileSync failure, else the exception text. */
+function toolErr(e) {
+	const err = e;
+	return ((typeof err.stderr === "string" ? err.stderr : err.stderr?.toString("utf8")) || err.message || String(e)).trim();
 }
 /**
-* 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.
+* Read New Bookmarks and Default Bookmark Guid from an iTerm preferences
+* plist. Key-scoped `plutil -extract`, never a whole-file JSON conversion:
+* real iTerm preferences carry `<date>` objects (SULastCheckTime & friends)
+* which `plutil -convert json` rejects outright — "Invalid object in plist
+* for JSON format" — so the whole-file read always failed and the dynamic
+* profile was never written.
 */
-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;
+function readItermPlist(plistPath) {
+	let bookmarks = [];
+	try {
+		const out = execFileSync("plutil", [
+			"-extract",
+			"New Bookmarks",
+			"json",
+			"-o",
+			"-",
+			plistPath
+		], {
+			encoding: "utf8",
+			timeout: 1e4
+		});
+		const parsed = JSON.parse(out);
+		if (Array.isArray(parsed)) bookmarks = parsed;
+	} catch (e) {
+		return {
+			bookmarks: [],
+			defaultGuid: null,
+			error: `extracting New Bookmarks: ${toolErr(e)}`
+		};
+	}
+	let defaultGuid = null;
+	try {
+		defaultGuid = execFileSync("plutil", [
+			"-extract",
+			"Default Bookmark Guid",
+			"raw",
+			"-o",
+			"-",
+			plistPath
+		], {
+			encoding: "utf8",
+			timeout: 1e4
+		}).trim() || null;
+	} catch {}
 	return {
-		from,
-		to,
-		kind: o.kind,
-		text,
-		...data ? { data } : {}
+		bookmarks,
+		defaultGuid,
+		error: null
 	};
 }
-/** 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));
+/** iTerm's exported preferences, via a temp plist (no shell pipe involved). */
+function itermPrefs() {
+	let dir = null;
+	try {
+		dir = mkdtempSync(join(tmpdir(), "pai-iterm-"));
+		const plist = join(dir, "iterm2.plist");
+		execFileSync("defaults", [
+			"export",
+			"com.googlecode.iterm2",
+			plist
+		], {
+			encoding: "utf8",
+			timeout: 1e4
+		});
+		return readItermPlist(plist);
+	} catch (e) {
+		return {
+			bookmarks: [],
+			defaultGuid: null,
+			error: `defaults export: ${toolErr(e)}`
+		};
+	} finally {
+		if (dir) try {
+			rmSync(dir, {
+				recursive: true,
+				force: true
+			});
 		} 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()}`;
+/** The New Bookmarks entry of that profile name, null if absent. */
+function bookmarkFrom(read, named) {
+	return read.bookmarks.find((b) => b.Name === named) ?? null;
 }
-/** 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);
+/** The bookmark iTerm marks default, null when it is missing or unreadable. */
+function defaultBookmarkFrom(read) {
+	return read.defaultGuid ? read.bookmarks.find((b) => b.Guid === read.defaultGuid) ?? null : null;
+}
+/** The default profile, read fresh from iTerm's preferences. */
+function defaultBookmark() {
+	return defaultBookmarkFrom(itermPrefs());
 }
 /**
-* 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.
+* The pane profile's font: the family of iTerm's default profile at
+* `fontSize` points ("MesloLGLNFM-Regular 18" + 13 → "MesloLGLNFM-Regular 13"),
+* or "Menlo-Regular <fontSize>" when the default font cannot be read.
 */
-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 && isLive(parent)) try {
-		await say(h.to, handoffMessage(h));
-	} catch {}
-	return h;
+function paneFont(font, fontSize) {
+	const idx = (font ?? "").lastIndexOf(" ");
+	if (idx > 0) {
+		const family = font.slice(0, idx);
+		if (!Number.isNaN(parseFloat(font.slice(idx + 1)))) return `${family} ${fontSize}`;
+	}
+	return `Menlo-Regular ${fontSize}`;
+}
+/** Write the pai-worker dynamic profile; iTerm2 loads that directory itself. */
+function writeDynamicProfile(parent, fontSize, read = itermPrefs) {
+	const profile = {
+		Name: PROFILE_NAME,
+		Guid: "pai-worker-dynamic-profile",
+		"Normal Font": paneFont(parent?.["Normal Font"], fontSize),
+		"Close Sessions On End": true
+	};
+	if (parent?.Name && bookmarkFrom(read(), parent.Name)) profile["Dynamic Profile Parent Name"] = parent.Name;
+	const path = dynamicProfilePath();
+	const dir = dirname(path);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	const tmp = `${path}.tmp`;
+	writeFileSync(tmp, JSON.stringify({ Profiles: [profile] }, null, 2) + "\n", "utf8");
+	renameSync(tmp, path);
 }
+let warnedPrefs = false;
 /**
-* 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.
+* Profile for new worker panes, creating the small-font one on demand.
+* "" means "split with the default profile" (also the fallback when the
+* dynamic profile does not show up in time).
+*
+* The profile file is written whenever it is missing — even when iTerm's
+* preferences cannot be read; then it gets font "Menlo-Regular <fontSize>"
+* and no parent, and the reason is logged to stderr once.
 */
-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);
+async function followProfile(fontSize, read = itermPrefs) {
+	const first = read();
+	const parent = defaultBookmarkFrom(first);
+	const path = dynamicProfilePath();
+	const existed = existsSync(path);
+	if (!existed) writeDynamicProfile(parent, fontSize, () => first);
+	if (!parent) {
+		if (!warnedPrefs) {
+			warnedPrefs = true;
+			const reason = first.error ?? "no profile is marked default";
+			const what = existed ? `keeping ${path} as-is` : `wrote ${path} with Menlo-Regular ${fontSize} and no parent`;
+			process.stderr.write(`pai worker pane: cannot read iTerm's default profile (${reason}) — ${what}\n`);
+		}
+		if (first.error) return "";
+	}
+	for (let i = 0; i < 10; i++) {
+		if (bookmarkFrom(read(), PROFILE_NAME)) return PROFILE_NAME;
+		await new Promise((r) => setTimeout(r, 200));
+	}
+	process.stderr.write(`pai worker pane: profile ${PROFILE_NAME} not visible, splitting with default\n`);
+	return "";
+}
+function loadRegistry(path) {
+	try {
+		const reg = JSON.parse(readFileSync(path, "utf8"));
+		return Array.isArray(reg) ? reg : [];
+	} catch {
+		return [];
+	}
+}
+function saveRegistry(path, reg) {
+	const dir = dirname(path);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	const tmp = `${path}.tmp`;
+	writeFileSync(tmp, JSON.stringify(reg, null, 1), "utf8");
+	renameSync(tmp, path);
 }
-
-//#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 + delete branch
-*   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.
+* The command a worker pane runs: one exec-able line with no shell syntax —
+* iTerm's split command parameter execs without a shell (proven live: panes
+* survive `sleep 30` and a single-quoted `/bin/sh -c`, die instantly on
+* `export …; …` or a redirect), so the command must be one exec-able line.
+* Absolute node on the CLI entry file also sidesteps the panes' bare launchd
+* PATH (no pai, no node) and the `#!/usr/bin/env node` shebang.
 */
-function worktreesDir(logDir) {
-	return join(logDir, "worktrees");
+function followCommand(wid, autoExitSecs) {
+	return `${process.execPath} ${absoluteCliPath()} worker follow ${wid} --auto-exit ${autoExitSecs}`;
 }
-function worktreeBranch(id) {
-	return `worker/${id}`;
+/** Absolute path of the running pai CLI; falls back to PATH lookup at spawn. */
+function absoluteCliPath() {
+	const argv1 = process.argv[1] ?? "";
+	if (argv1.endsWith("pai")) return argv1;
+	return "pai";
 }
-function worktreePath(logDir, id) {
-	return join(worktreesDir(logDir), id);
+/** Open (or only report on) the stacked follow pane of one worker. */
+async function openPaneForWorker(logDir, config, wid, term) {
+	if (workerPaneOpen(wid)) return `pane for ${wid} already open`;
+	const uid = itermUuid(term);
+	const regPath = join(panesDir(logDir), `${scopeKey(term)}.json`);
+	const reg = loadRegistry(regPath);
+	const profile = await followProfile(config.pane.fontSize);
+	const cmd = followCommand(wid, config.pane.autoExitSecs);
+	const p = await osascript(WORKER_SPLIT_SCRIPT, [
+		uid,
+		[...reg].reverse().map((e) => e.session).join(","),
+		cmd,
+		profile
+	]);
+	const out = p.stdout.trim();
+	if (out === "notfound" || out === "notrunning") throw new Error(out === "notfound" ? "pai worker pane: no open iTerm2 session matches ITERM_SESSION_ID" : "pai worker pane: iTerm2 is not running");
+	const bar = out.indexOf("|");
+	if (bar < 0) throw new Error(`pai worker pane: osascript failed: ${(p.stderr || out).slice(0, 200)}`);
+	const live = new Set(out.slice(0, bar).split(",").filter(Boolean));
+	const pruned = reg.filter((e) => live.has(e.session));
+	pruned.push({
+		session: out.slice(bar + 1),
+		worker: wid,
+		opened: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19)
+	});
+	saveRegistry(regPath, pruned);
+	return `pane opened for ${wid}`;
 }
-/** Run git in `cwd`, returning trimmed stdout; throws with stderr on failure. */
-function git(cwd, args) {
+/**
+* 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 {
-		return execFileSync("git", [
-			"-C",
-			cwd,
-			...args
-		], {
-			encoding: "utf8",
-			timeout: 3e4,
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			]
-		}).trim();
+		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) {
-		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;
+		return `window bounds: (osascript: ${String(e.message ?? e).slice(0, 120)})`;
 	}
 }
 /**
-* 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.
+* Report-only variant used by `pai worker pane <id> --check`: whether a pane
+* 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).
 */
-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 ?? "");
+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)";
+		try {
+			font = JSON.parse(readFileSync(path, "utf8")).Profiles?.[0]?.["Normal Font"] ?? "(none)";
+		} catch {}
+		lines.push(`profile file: ${path} (exists)`);
+		lines.push(`profile font: ${font}`);
+	} else {
+		const parent = defaultBookmark();
+		lines.push(`profile file: ${path} (missing)`);
+		lines.push(`profile font (would write): ${paneFont(parent?.["Normal Font"], fontSize)}`);
+	}
+	return lines.join("\n");
 }
 /**
-* 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.
+* Split this iTerm tab and run `pai worker follow` in the new pane, unless
+* one already runs here (detected by TTY — iTerm overwrites session names
+* with the running command, so names cannot serve as idempotence).
 */
-function addWorktree(logDir, id, cwd) {
-	const swept = sweepOrphanWorktrees(logDir);
-	if (swept.length) appendLedger(ledgerPath(logDir), "WORKER-NOTE", {
-		id,
-		note: `swept orphan worktree(s): ${swept.join(", ")}`
-	});
-	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
-	};
+async function openFollowPane(logDir, _config, term, checkOnly) {
+	const uid = itermUuid(term);
+	const out = (await osascript(TAB_TTYS_SCRIPT, [uid])).stdout.trim();
+	if (out === "notfound") throw new Error("pai worker pane: no open iTerm2 session matches ITERM_SESSION_ID");
+	if (out === "notrunning") throw new Error("pai worker pane: iTerm2 is not running");
+	if ([...new Set(out.split(",").map((t) => t.trim()).filter(Boolean))].filter((t) => followTtys().has(t)).length > 0) return "follow pane already open";
+	if (checkOnly) return "no follow pane";
+	const s = await osascript(SPLIT_SCRIPT, [uid, `${process.execPath} ${absoluteCliPath()} worker follow`]);
+	const sout = s.stdout.trim();
+	if (sout === "opened") return "follow pane opened";
+	if (sout === "notfound") throw new Error("pai worker pane: no open iTerm2 session matches ITERM_SESSION_ID");
+	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;
 }
 /**
-* Remove worktrees (and their `worker/<id>` branches) whose worker no longer
-* exists — no status file left in the log dir. Killed and failed runs clean
-* up after themselves, but a `kill -9` or a crash strands a directory and a
-* branch; every worktree creation sweeps first so they cannot accumulate.
-* Directories younger than `minAgeMin` minutes are left alone: a run that is
-* just starting owns its worktree a moment before its status file exists.
+* 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. `chatIsRoot` stops one level short of the
+* chat-pane tracker (origin "chat"): the status line treats the pane as the
+* bar itself, so the workers it spawned are its top level.
 */
-function sweepOrphanWorktrees(logDir, minAgeMin = 10) {
-	const root = worktreesDir(logDir);
-	if (!existsSync(root)) return [];
-	const swept = [];
-	for (const ent of readdirSync(root, { withFileTypes: true })) {
-		if (!ent.isDirectory()) continue;
-		const id = ent.name;
-		const dir = join(root, id);
-		if (existsSync(statusPath(logDir, id))) continue;
-		try {
-			if ((Date.now() - statSync(dir).mtimeMs) / 6e4 < minAgeMin) continue;
-		} catch {}
-		let gitDir = null;
-		try {
-			const raw = git(dir, ["rev-parse", "--git-common-dir"]);
-			gitDir = isAbsolute(raw) ? raw : resolve(dir, raw);
-		} catch {
-			gitDir = null;
-		}
-		removeWorktree(gitDir ?? dir, dir, true);
-		if (gitDir) try {
-			git(gitDir, ["worktree", "prune"]);
-			git(gitDir, [
-				"branch",
-				"-D",
-				worktreeBranch(id)
-			]);
-		} catch {}
-		swept.push(id);
+function workerDepth(statuses, id, opts) {
+	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;
+		if (!(opts?.chatIsRoot && next.origin === "chat")) depth += 1;
+		cur = next;
 	}
-	return swept;
+	return depth;
 }
-/** 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;
-	}
+/** Children of `parent` that are still running, oldest first. */
+function runningChildren(statuses, parent) {
+	return statuses.filter((s) => s.parent === parent && isLive(s));
 }
 /**
-* Record the worktree result in the status file: branch and commit count on
-* success, the worktree cleaned up on failure. Returns the updated status.
+* 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 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;
+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`);
 }
-/** Remove a worktree directory from git's books and the filesystem. */
-function removeWorktree(cwd, dir, force) {
+/**
+* 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 {
-		git(cwd, [
-			"worktree",
-			"remove",
-			...force ? ["--force"] : [],
-			dir
-		]);
-		return;
+		if (existsSync(path)) unlinkSync(path);
 	} catch {}
-	if (existsSync(dir)) try {
-		rmSync(dir, {
-			recursive: true,
-			force: true
+	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");
+			}
 		});
-		git(cwd, ["worktree", "prune"]);
-	} catch {}
+	});
+	server.listen(path);
+	server.on("close", () => {
+		try {
+			if (existsSync(path)) unlinkSync(path);
+		} catch {}
+	});
+	return server;
 }
 /**
-* Tracked changes (staged or not) plus untracked files — everything a
-* `git add -A` in `wtDir` would commit. The same two calls the old patch
-* carry used; name-only, not porcelain: a worktree-only change renders as
-* " M path" and the shared git() helper trims that leading space away.
+* `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 uncommittedPaths(wtDir) {
-	const tracked = git(wtDir, [
-		"diff",
-		"--name-only",
-		"HEAD"
-	]).split("\n").filter(Boolean);
-	const untracked = git(wtDir, [
-		"ls-files",
-		"--others",
-		"--exclude-standard"
-	]).split("\n").filter(Boolean);
-	return [...tracked, ...untracked];
+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 (!isLive(status)) 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
 /**
-* Commit a worktree's uncommitted changes to its branch so the merge carries
-* them. `git merge` only moves committed work, so a worker that stopped
-* without committing would lose its edits to `worktree remove` — exactly
-* what happened live on 2026-09-17. Returns the salvaged paths, [] when the
-* worktree is clean. A failed commit throws with the worktree untouched:
-* its edits are still on disk, so nothing is lost.
+* 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`).
 */
-function salvageUncommitted(wtDir, label) {
-	const paths = uncommittedPaths(wtDir);
-	if (!paths.length) return [];
-	try {
-		git(wtDir, ["add", "-A"]);
-		git(wtDir, [
-			"commit",
-			"-m",
-			`salvaged: ${label}`
-		]);
-	} catch (e) {
-		throw new Error(`cannot salvage the uncommitted changes in ${wtDir} — ${e.message}; nothing was lost: commit them there by hand, then re-run merge`);
-	}
-	return paths;
+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);
 }
 /**
-* The dirty paths of a checkout, parsed from `git status --porcelain -z`:
-* NUL-separated (a path with a newline in it cannot corrupt the parse),
-* rename entries contribute both sides, and any quoting is stripped.
+* 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 dirtyPaths(cwd) {
-	const fields = execFileSync("git", [
-		"-C",
-		cwd,
-		"status",
-		"--porcelain",
-		"-z"
-	], {
-		encoding: "utf8",
-		timeout: 3e4,
-		stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		]
-	}).split("\0");
-	const strip = (p) => p.startsWith("\"") && p.endsWith("\"") ? p.slice(1, -1) : p;
+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 (let i = 0; i < fields.length; i++) {
-		const f = fields[i];
-		if (!f || f.length < 4 || f.charAt(2) !== " ") continue;
-		out.push(strip(f.slice(3)));
-		const xy = f.slice(0, 2);
-		if (xy.includes("R") || xy.includes("C")) {
-			const orig = fields[i + 1];
-			if (orig && orig.charAt(2) !== " ") {
-				out.push(strip(orig));
-				i += 1;
-			}
-		}
+	for (const line of readFileSync(path, "utf8").split("\n")) {
+		if (!line.trim()) continue;
+		try {
+			out.push(JSON.parse(line));
+		} catch {}
 	}
 	return out;
 }
-/**
-* Refuse the merge when the original checkout is dirty in paths the branch
-* touches: the merge would overwrite those edits or fail on them, either way
-* leaving a half-state. No merge is made, the worktree stays.
-*/
-function assertNoDirtyOverlap(cwd, incoming, id, branch) {
-	const dirty = new Set(dirtyPaths(cwd));
-	const overlap = [...new Set(incoming)].filter((p) => dirty.has(p)).sort();
-	if (!overlap.length) return;
-	throw new Error(`worker ${id}: the checkout ${cwd} has uncommitted changes in paths ${branch} touches: ${overlap.join(", ")}. Commit or stash them in the checkout, then re-run: pai worker merge ${id}. No merge was made; the worktree was kept.`);
+/** 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()}`;
 }
-/** Never remove a worktree that still holds uncommitted changes. */
-function assertWorktreeClean(wtDir, id) {
-	const leftover = uncommittedPaths(wtDir);
-	if (leftover.length) throw new Error(`worker ${id}: the worktree ${wtDir} still holds uncommitted changes (${leftover.join(", ")}) — it was NOT removed; commit or copy them by hand, then re-run merge`);
+/** 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);
 }
 /**
-* `pai worker merge <id>`: salvage whatever the worker left uncommitted onto
-* its branch, refuse when the original checkout is dirty in paths the branch
-* touches, merge with --no-ff (the merge commit names the worker), then
-* remove the worktree and delete the branch; the status gains `merged: true`.
-* A branch with nothing to merge is refused loudly — after salvage that
-* genuinely means it holds nothing, and reporting success there would
-* destroy the worktree for no gain.
+* 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.
 */
-function mergeWorker(logDir, id) {
-	const st = mustHaveBranch(logDir, id);
-	if (st.merged) return `worker ${id}: branch ${st.branch} already merged`;
-	const salvaged = existsSync(st.worktreeDir) ? salvageUncommitted(st.worktreeDir, st.label || UNLABELED) : [];
-	if ((parseInt(git(st.cwd, [
-		"rev-list",
-		"--count",
-		`HEAD..${st.branch}`
-	]), 10) || 0) <= 0) throw new Error(`worker ${id}: branch ${st.branch} has no commits to merge. The worktree ${st.worktreeDir} was NOT removed — uncommitted work there would be destroyed. Commit it yourself, or drop everything with: pai worker discard ${id}`);
-	const mergeBase = git(st.cwd, [
-		"merge-base",
-		"HEAD",
-		st.branch
-	]);
-	const incomingPaths = git(st.cwd, [
-		"diff",
-		"--name-only",
-		mergeBase,
-		st.branch
-	]).split("\n").filter(Boolean);
-	assertNoDirtyOverlap(st.cwd, incomingPaths, id, st.branch);
-	try {
-		git(st.cwd, [
-			"merge",
-			"--no-ff",
-			st.branch,
-			"-m",
-			`merge worker ${id} (${st.label})`
-		]);
-	} catch (e) {
-		throw new Error(`worker ${id}: git refused the merge of ${st.branch} — ${e.message}. The worktree ${st.worktreeDir} was kept: resolve the conflict, then re-run merge`);
-	}
-	if (existsSync(st.worktreeDir)) assertWorktreeClean(st.worktreeDir, id);
-	removeWorktree(st.cwd, st.worktreeDir, false);
-	let branchGone = true;
-	try {
-		git(st.cwd, [
-			"branch",
-			"-d",
-			st.branch
-		]);
-	} catch {
-		branchGone = false;
-	}
-	saveStatus(logDir, {
-		...st,
-		merged: true
-	});
-	const base = `merged ${st.branch} into ${st.cwd} (worktree removed${branchGone ? ", branch deleted" : "; branch kept: git refused -d"})`;
-	return salvaged.length ? `${base}; salvaged ${salvaged.length} uncommitted change(s): ${salvaged.join(", ")}` : base;
-}
-/** `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;
+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 && isLive(parent)) try {
+		await say(h.to, handoffMessage(h));
+	} catch {}
+	return h;
 }
 /**
-* 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.
+* 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.
 */
-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`.",
-		"Use ONLY relative paths inside the worktree, never absolute worktree paths — absolute paths break after merge and leak machine layout."
-	].join("\n");
+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
@@ -2677,21 +2750,51 @@ async function runWorker(opts) {
 	const logDir = workersLogDir(config);
 	mkdirSync(logDir, { recursive: true });
 	if (opts.className === "plan" && !opts._planner) {
-		const { runPlanner } = await import("./planner-Cn8HmT7l.mjs");
+		const { runPlanner } = await import("./planner-BiH9msqq.mjs");
 		return runPlanner(opts);
 	}
 	const parent = launchParent(opts.parent);
 	if (parent) assertChildAllowed(logDir, parent, config.tree);
-	const target = resolveTarget(config, logDir, {
+	const capability = opts.providerFlag ? null : capabilityForRun(config, {
+		capabilityFlag: opts.capabilityFlag,
+		className: opts.className
+	});
+	const capabilityResolution = capability ? resolveCapabilityRun(config, capability) : null;
+	const target = capabilityResolution ? {
+		providerName: capabilityResolution.providerName,
+		provider: capabilityResolution.provider,
+		modelAlias: null,
+		classMcp: null,
+		via: "class"
+	} : resolveTarget(config, logDir, {
 		flagProvider: opts.providerFlag,
 		className: opts.className
 	});
 	assertProviderRunnable(target.providerName, target.provider);
 	const parsed = parseRunnerArgs(opts.claudeArgs);
 	const label = opts.label ?? shortText(parsed.prompt ?? UNLABELED, 70);
-	const model = resolveRunModel(target, opts.className, opts.modelFlag);
+	const model = capabilityResolution ? capabilityResolution.model : resolveRunModel(target, opts.className, opts.modelFlag);
 	const reportFormat = resolveReportFormat(opts.reportFormatFlag);
 	try {
+		if (target.provider.engine === "image") return await executeImageRun({
+			config,
+			logDir,
+			target,
+			model,
+			label,
+			parsed,
+			capability: capability ?? "image",
+			outPath: opts.imageOut,
+			size: opts.imageSize,
+			timeoutMs: opts.imageTimeoutMs,
+			cwd: opts.cwd,
+			specPath: opts.specPath,
+			parent: parent ?? void 0,
+			stage: opts.stage,
+			quiet: opts.quiet,
+			onWorkerStart: opts.onWorkerStart,
+			id: opts.id
+		});
 		if (target.provider.engine === "codex") return await executeCodexRun({
 			config,
 			logDir,
@@ -2710,7 +2813,8 @@ async function runWorker(opts) {
 			id: opts.id,
 			worktreeFlag: opts.worktreeFlag,
 			className: opts.className,
-			reportFormat
+			reportFormat,
+			capability: capability ?? void 0
 		});
 		return await executeRun({
 			config,
@@ -2729,6 +2833,7 @@ async function runWorker(opts) {
 			quiet: opts.quiet,
 			onWorkerStart: opts.onWorkerStart,
 			id: opts.id,
+			capability: capability ?? void 0,
 			worktreeFlag: opts.worktreeFlag,
 			className: opts.className,
 			reroutes: opts._reroutes ?? 0,
@@ -2840,6 +2945,104 @@ function interactiveMcpTools(explicitMcp, callerTools, projectLaunch) {
 		tools: !callerTools && projectLaunch?.tools?.length ? projectLaunch.tools : []
 	};
 }
+async function executeImageRun(a) {
+	const { logDir, target, model, label, parsed } = a;
+	if (!parsed.headless || parsed.prompt === null) throw new Error(`provider "${target.providerName}" (engine image) supports headless runs only: pass the task with -p '<prompt>'`);
+	const wid = a.id ?? newWorkerId();
+	const cwd = a.cwd ?? process.cwd();
+	const term = process.env.ITERM_SESSION_ID ?? "";
+	const outPath = a.outPath ?? join(logDir, `${wid}.png`);
+	const status = {
+		id: wid,
+		pid: process.pid,
+		label,
+		cwd,
+		term,
+		provider: target.providerName,
+		model,
+		state: "running",
+		started: nowStamp(),
+		updated: nowStamp(),
+		turns: 0,
+		tools: 0,
+		last: "generating image",
+		rc: null,
+		secs: null,
+		origin: "spawn",
+		outputFormat: parsed.outputFormat,
+		reportFormat: "json",
+		...a.parent ? {
+			parent: a.parent,
+			stage: a.stage
+		} : {},
+		...a.specPath ? { spec: a.specPath } : {}
+	};
+	saveStatus(logDir, status);
+	a.onWorkerStart?.(wid);
+	const ledger = ledgerPath(logDir);
+	appendLedger(ledger, "WORKER-START", {
+		id: wid,
+		provider: target.providerName,
+		mode: "headless",
+		engine: "image",
+		model,
+		cwd,
+		label,
+		capability: a.capability,
+		...a.specPath ? { spec: a.specPath } : {}
+	});
+	const t0 = Date.now();
+	try {
+		const result = await runImageCapability({
+			providerName: target.providerName,
+			provider: target.provider,
+			model,
+			prompt: parsed.prompt,
+			outPath,
+			size: a.size,
+			timeoutMs: a.timeoutMs
+		});
+		const secs = Math.round((Date.now() - t0) / 1e3);
+		status.state = "done";
+		status.rc = 0;
+		status.secs = secs;
+		status.last = `wrote ${result.path}`;
+		saveStatus(logDir, status);
+		appendLedger(ledger, "WORKER-END", {
+			id: wid,
+			provider: target.providerName,
+			mode: "headless",
+			engine: "image",
+			model,
+			rc: 0,
+			secs,
+			label,
+			capability: a.capability
+		});
+		if (!a.quiet) process.stdout.write(JSON.stringify(result) + "\n");
+		return 0;
+	} catch (e) {
+		const secs = Math.round((Date.now() - t0) / 1e3);
+		const message = e instanceof Error ? e.message : String(e);
+		status.state = "failed";
+		status.rc = 1;
+		status.secs = secs;
+		status.last = message;
+		saveStatus(logDir, status);
+		appendLedger(ledger, "WORKER-END", {
+			id: wid,
+			provider: target.providerName,
+			mode: "headless",
+			engine: "image",
+			model,
+			rc: 1,
+			secs,
+			label,
+			capability: a.capability
+		});
+		throw e;
+	}
+}
 async function executeRun(a) {
 	const { config, logDir, target, model, label, parsed, noPane } = a;
 	const headless = parsed.headless;
@@ -2965,6 +3168,7 @@ async function executeRun(a) {
 		model,
 		cwd,
 		label,
+		...a.capability ? { capability: a.capability } : {},
 		...a.specPath ? { spec: a.specPath } : {}
 	});
 	if (headless && !noPane && config.pane.enabled && term && process.env.PAI_WORKER_AUTOPANE !== "0") openPaneForWorker(logDir, config, wid, term).catch(() => {});
@@ -3321,7 +3525,8 @@ async function executeCodexRun(a) {
 		engine: "codex",
 		model,
 		cwd,
-		label
+		label,
+		...a.capability ? { capability: a.capability } : {}
 	});
 	const dropped = codexDroppedFlags(a.claudeArgs);
 	if (dropped.length) appendLedger(ledger, "WORKER-NOTE", {
@@ -3575,5 +3780,5 @@ function resultFromOutput(out) {
 }
 
 //#endregion
-export { isLive as A, parseRunnerArgs as B, ledgerSummary as C, contextLabel as D, alive as E, ownsPid as F, describeMcp as H, saveStatus as I, setWorkerLabel as L, loadStatuses as M, newWorkerId as N, contextPercent as O, nowStamp as P, waitForTerminalStatus as R, appendLedger as S, ageOf as T, expandMcpNames as U, shortText as V, currentTabKey as _, projectLaunchConfig as a, sessionTag as b, discardWorker as c, readInbox as d, sayToWorker as f, openPaneForWorker as g, openFollowPane as h, usageContextTokens as i, loadStatus as j, isChatPane as k, mergeWorker as l, checkPaneForWorker as m, runWorker as n, parseWorkerReport as o, workerDepth as p, testProvider as r, renderReport as s, printResult as t, handoffFromInside as u, itermForClaudeSession as v, UNLABELED as w, workerInScope as x, resolveSession as y, longInlinePromptHint as z };
-//# sourceMappingURL=run-Cls0YGgV.mjs.map
+export { contextLabel as A, setWorkerLabel as B, mergeWorker as C, UNLABELED as D, ledgerSummary as E, loadStatuses as F, describeMcp as G, longInlinePromptHint as H, newWorkerId as I, expandMcpNames as K, nowStamp as L, isChatPane as M, isLive as N, ageOf as O, loadStatus as P, ownsPid as R, discardWorker as S, appendLedger as T, parseRunnerArgs as U, waitForTerminalStatus as V, shortText as W, itermUuid as _, projectLaunchConfig as a, sessionTag as b, handoffFromInside as c, workerDepth as d, checkPaneForWorker as f, itermForClaudeSession as g, currentTabKey as h, usageContextTokens as i, contextPercent as j, alive as k, readInbox as l, openPaneForWorker as m, runWorker as n, parseWorkerReport as o, openFollowPane as p, testProvider as r, renderReport as s, printResult as t, sayToWorker as u, resolveSession as v, worktreesDir as w, workerInScope as x, sessionMapPath as y, saveStatus as z };
+//# sourceMappingURL=run-TChOnMO_.mjs.map