@tekmidian/pai 0.37.0 → 0.38.0

package/dist/{providers-sXcK5bDZ.mjs → providers-DUshcB-d.mjs}

@@ -104,6 +104,28 @@ function writeJsonAtomic(path, data, opts = {}) {
 * `engine: "codex"` providers run through the Codex CLI instead of Claude
 * Code.
 */
+const DEFAULT_COST_TIER = 3;
+/** Tags a provider may carry; classes filter auto-routing on them. */
+const PROVIDER_TAGS = [
+	"code",
+	"vision",
+	"image-gen",
+	"long-context",
+	"fast",
+	"reasoning"
+];
+/** The standard task classes; `workers.classes` maps each to a target. */
+const WORKER_CLASSES = [
+	"draft",
+	"plan",
+	"implement",
+	"review",
+	"research",
+	"spotcheck",
+	"simple",
+	"complex",
+	"image"
+];
 const DEFAULT_LOG_DIR = "~/.claude/logs/workers";
 const DEFAULT_PANE = {
 	enabled: true,
@@ -120,7 +142,7 @@ function defaultWorkersConfig() {
 		enabled: false,
 		active: null,
 		providers: {},
-		roles: {},
+		classes: {},
 		mcpSets: {},
 		pane: { ...DEFAULT_PANE },
 		logDir: DEFAULT_LOG_DIR,
@@ -171,6 +193,16 @@ function parseProvider(name, raw) {
 	}
 	const upstreamUrl = str(p.upstreamUrl);
 	if (protocol === "openai" && !upstreamUrl) bad(`.providers.${name}.upstreamUrl`, `is required for protocol "openai" (the Chat Completions base, e.g. "https://api.openai.com/v1")`);
+	const costTier = p.costTier === void 0 ? void 0 : p.costTier;
+	if (costTier !== void 0) {
+		if (typeof costTier !== "number" || !Number.isInteger(costTier) || costTier < 1 || costTier > 5) bad(`.providers.${name}.costTier`, "must be an integer 1 (cheapest) … 5 (most expensive)");
+	}
+	let tags;
+	if (p.tags !== void 0) {
+		if (!Array.isArray(p.tags) || p.tags.some((x) => typeof x !== "string")) bad(`.providers.${name}.tags`, `must be an array of tags from: ${PROVIDER_TAGS.join(", ")}`);
+		for (const t of p.tags) if (!PROVIDER_TAGS.includes(t)) bad(`.providers.${name}.tags`, `"${t}" is not a tag (from: ${PROVIDER_TAGS.join(", ")})`);
+		tags = p.tags;
+	}
 	return {
 		enabled: p.enabled === void 0 ? true : p.enabled === true,
 		protocol,
@@ -186,7 +218,9 @@ function parseProvider(name, raw) {
 		...engine !== "claude" ? { engine } : {},
 		...str(p.quotaProbe) ? { quotaProbe: str(p.quotaProbe) } : {},
 		...quotaSkipAt !== void 0 ? { quotaSkipAt } : {},
-		...contextWindow !== void 0 ? { contextWindow } : {}
+		...contextWindow !== void 0 ? { contextWindow } : {},
+		...costTier !== void 0 ? { costTier } : {},
+		...tags ? { tags } : {}
 	};
 }
 /**
@@ -203,26 +237,47 @@ function parseWorkersConfig(raw) {
 		if (typeof w.providers !== "object" || w.providers === null || Array.isArray(w.providers)) bad(".providers", "must be an object keyed by provider name");
 		for (const [name, p] of Object.entries(w.providers)) providers[name] = parseProvider(name, p);
 	}
-	const roles = {};
-	if (w.roles !== void 0) {
-		if (typeof w.roles !== "object" || w.roles === null || Array.isArray(w.roles)) bad(".roles", "must be an object of role → provider[/alias] or {provider, mcp}");
-		for (const [role, target] of Object.entries(w.roles)) if (typeof target === "object" && target !== null && !Array.isArray(target)) {
+	const classes = {};
+	const classesRaw = w.classes !== void 0 ? w.classes : w.roles;
+	if (classesRaw !== void 0) {
+		if (typeof classesRaw !== "object" || classesRaw === null || Array.isArray(classesRaw)) bad(w.classes !== void 0 ? ".classes" : ".roles", "must be an object of class → provider[/alias] or {provider, mcp, maxCostTier, requireTags, order}");
+		for (const [cls, target] of Object.entries(classesRaw)) if (typeof target === "object" && target !== null && !Array.isArray(target)) {
 			const o = target;
 			const provider = str(o.provider);
-			if (!provider || provider.includes(" ")) bad(`.roles.${role}.provider`, `invalid provider "${provider}"`);
+			if (o.provider !== void 0 && (!provider || provider.includes(" "))) bad(`.classes.${cls}.provider`, `invalid provider "${provider}"`);
 			let mcp;
 			if (o.mcp !== void 0) {
-				if (!Array.isArray(o.mcp) || o.mcp.some((x) => typeof x !== "string")) bad(`.roles.${role}.mcp`, "must be an array of MCP server or set names");
+				if (!Array.isArray(o.mcp) || o.mcp.some((x) => typeof x !== "string")) bad(`.classes.${cls}.mcp`, "must be an array of MCP server or set names");
 				mcp = o.mcp;
 			}
-			roles[role] = mcp ? {
-				provider,
-				mcp
-			} : { provider };
+			let maxCostTier;
+			if (o.maxCostTier !== void 0) {
+				if (typeof o.maxCostTier !== "number" || !Number.isInteger(o.maxCostTier) || o.maxCostTier < 1 || o.maxCostTier > 5) bad(`.classes.${cls}.maxCostTier`, "must be an integer 1 … 5");
+				maxCostTier = o.maxCostTier;
+			}
+			let requireTags;
+			if (o.requireTags !== void 0) {
+				if (!Array.isArray(o.requireTags) || o.requireTags.some((x) => typeof x !== "string")) bad(`.classes.${cls}.requireTags`, `must be an array of tags from: ${PROVIDER_TAGS.join(", ")}`);
+				for (const t of o.requireTags) if (!PROVIDER_TAGS.includes(t)) bad(`.classes.${cls}.requireTags`, `"${t}" is not a tag (from: ${PROVIDER_TAGS.join(", ")})`);
+				requireTags = o.requireTags;
+			}
+			let order;
+			if (o.order !== void 0) {
+				if (!Array.isArray(o.order) || o.order.some((x) => typeof x !== "string")) bad(`.classes.${cls}.order`, "must be an array of provider names");
+				order = o.order;
+			}
+			const obj = {
+				...provider ? { provider } : {},
+				...mcp ? { mcp } : {},
+				...maxCostTier !== void 0 ? { maxCostTier } : {},
+				...requireTags ? { requireTags } : {},
+				...order ? { order } : {}
+			};
+			classes[cls] = Object.keys(obj).length ? obj : {};
 		} else {
 			const t = str(target);
-			if (!t || t.includes(" ")) bad(`.roles.${role}`, `invalid target "${t}"`);
-			roles[role] = t;
+			if (!t || t.includes(" ")) bad(`.classes.${cls}`, `invalid target "${t}"`);
+			classes[cls] = t;
 		}
 	}
 	const mcpSets = {};
@@ -271,7 +326,7 @@ function parseWorkersConfig(raw) {
 		enabled: w.enabled === void 0 ? d.enabled : w.enabled === true,
 		active,
 		providers,
-		roles,
+		classes,
 		mcpSets,
 		pane,
 		logDir: str(w.logDir) || d.logDir,
@@ -308,6 +363,10 @@ function providerKeyPath(p) {
 	return p.keyFile ? expandHome(p.keyFile) : null;
 }
 const DEFAULT_CONTEXT_WINDOW = 2e5;
+/** Cost tier of a provider for class filtering (unset = 3, the middle). */
+function providerCostTier(p) {
+	return p.costTier ?? DEFAULT_COST_TIER;
+}
 /** Context window used by the meter when the init event carries none. */
 function providerContextWindow(p) {
 	return p.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
@@ -525,9 +584,18 @@ function nowStamp(d = /* @__PURE__ */ new Date()) {
 	const p = (n) => String(n).padStart(2, "0");
 	return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
 }
+let lastId = "";
+let idSeq = 0;
 function newWorkerId(d = /* @__PURE__ */ new Date(), pid = process.pid) {
 	const p = (n) => String(n).padStart(2, "0");
-	return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}-${pid}`;
+	const base = `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}-${pid}`;
+	if (base === lastId) {
+		idSeq += 1;
+		return `${base}-${String(idSeq).padStart(2, "0")}`;
+	}
+	lastId = base;
+	idSeq = 0;
+	return base;
 }
 /** Write status atomically (temp + rename) and stamp `updated`. */
 function saveStatus(logDir, status, d = /* @__PURE__ */ new Date()) {
@@ -676,16 +744,19 @@ function sessionTag(worker) {
 //#endregion
 //#region src/workers/routing.ts
 /**
-* routing.ts — provider selection: flag > role > active (possibly "auto").
+* routing.ts — provider selection: flag > class > active (possibly "auto").
 *
-* Auto-routing walks `workers.routing.order` and takes the first provider
-* that is enabled, out of cooldown, and (when it defines a quotaProbe) under
-* its quotaSkipAt threshold. A run that dies of a quota/rate error puts its
-* provider in cooldown for cooldownMinutes; when that happens before the
-* first tool call and retryOnQuota is set, the runner restarts the same task
-* on the next provider (ledger: WORKER-REROUTE).
+* Auto-routing walks `workers.routing.order` — or the class's own `order` —
+* and takes the first provider that is enabled, out of cooldown, (when it
+* defines a quotaProbe) under its quotaSkipAt threshold, and — when the class
+* constrains it — within `maxCostTier` and carrying all `requireTags`. A run
+* that dies of a quota/rate error puts its provider in cooldown for
+* cooldownMinutes; when that happens before the first tool call and
+* retryOnQuota is set, the runner restarts the same task on the next provider
+* (ledger: WORKER-REROUTE).
 *
-* An explicit --provider or --role always bypasses all of this.
+* An explicit --provider or a class mapping that pins a provider always
+* bypasses all of this.
 */
 const QUOTA_SKIP_DEFAULT = 95;
 const PROBE_TIMEOUT_MS = 1e4;
@@ -764,34 +835,61 @@ function mustBeRunnable(name, p) {
 	if (!p.enabled) throw new NoProviderError(`provider "${name}" is disabled. Enable it with: pai worker providers enable ${name}`);
 	return p;
 }
+/** Why one provider of a routing order did not qualify (message fragment). */
+function exclusionReason(config, state, name, cls) {
+	const p = config.providers[name];
+	if (!p) return "not configured";
+	if (!p.enabled) return "disabled";
+	if (cooldownRemaining(state, name) > 0) return "cooldown";
+	if (quotaExceeded(p)) return "quota";
+	const tier = providerCostTier(p);
+	if (cls?.maxCostTier !== void 0 && tier > cls.maxCostTier) return `cost tier ${tier} > max ${cls.maxCostTier}`;
+	if (cls?.requireTags?.length) {
+		const have = p.tags ?? [];
+		const missing = cls.requireTags.filter((t) => !have.includes(t));
+		if (missing.length) return `missing tags: ${missing.join(", ")}`;
+	}
+	return null;
+}
 /**
 * Resolve which provider (and model alias) a run uses.
 *
 * @param flagProvider --provider value, highest precedence
-* @param role         --role value, looked up in workers.roles
+* @param className    --class value (the old --role), looked up in workers.classes
 */
 function resolveTarget(config, logDir, opts = {}) {
 	if (opts.flagProvider) return {
 		providerName: opts.flagProvider,
 		provider: mustBeRunnable(opts.flagProvider, mustExist(config, opts.flagProvider)),
 		modelAlias: null,
-		roleMcp: null,
+		classMcp: null,
 		via: "flag"
 	};
-	if (opts.role) {
-		const target = config.roles[opts.role];
-		if (!target) throw new NoProviderError(`no role named "${opts.role}". Defined: ${Object.keys(config.roles).join(", ") || "(none)"}.\nSet one with: pai worker roles set ${opts.role}=<provider[/alias]>`);
-		const name = typeof target === "string" ? target.split("/")[0] : target.provider;
-		const alias = typeof target === "string" ? target.split("/")[1] : void 0;
-		const roleMcp = typeof target === "string" ? null : target.mcp ?? null;
+	const clsTarget = opts.className ? config.classes[opts.className] : void 0;
+	const cls = typeof clsTarget === "object" && clsTarget !== null ? clsTarget : void 0;
+	if (opts.className && clsTarget !== void 0 && typeof clsTarget !== "object") {
+		const [name, alias] = clsTarget.split("/");
 		return {
 			providerName: name,
 			provider: mustBeRunnable(name, mustExist(config, name)),
 			modelAlias: alias ?? null,
-			roleMcp,
-			via: "role"
+			classMcp: null,
+			via: "class"
+		};
+	}
+	if (opts.className && cls?.provider) {
+		const provider = mustBeRunnable(cls.provider, mustExist(config, cls.provider));
+		return {
+			providerName: cls.provider,
+			provider,
+			modelAlias: null,
+			classMcp: cls.mcp ?? null,
+			via: "class"
 		};
 	}
+	if (opts.className && clsTarget === void 0) {
+		if (!WORKER_CLASSES.includes(opts.className)) throw new NoProviderError(`no class named "${opts.className}". Standard classes: ${WORKER_CLASSES.join(", ")}.Defined: ${Object.keys(config.classes).join(", ") || "(none)"}.\nSet one with: pai worker classes set ${opts.className}=<provider[/alias]>`);
+	}
 	if (config.active !== "auto") {
 		const name = config.active;
 		if (!name) throw new NoProviderError("no active worker provider. Add one with: pai worker providers add <name> --base-url <url> --key-file <path> --model <model>\n(or point one that exists at it: pai worker providers use <name>)");
@@ -799,32 +897,29 @@ function resolveTarget(config, logDir, opts = {}) {
 			providerName: name,
 			provider: mustBeRunnable(name, mustExist(config, name)),
 			modelAlias: null,
-			roleMcp: null,
+			classMcp: null,
 			via: "active"
 		};
 	}
 	const state = readRoutingState(logDir);
-	const skipped = [];
-	for (const name of config.routing.order) {
+	const order = cls?.order ?? config.routing.order;
+	const excluded = [];
+	for (const name of order) {
 		const p = config.providers[name];
-		if (!p || !p.enabled) continue;
-		if (cooldownRemaining(state, name) > 0) {
-			skipped.push(`${name}(cooldown)`);
-			continue;
-		}
-		if (quotaExceeded(p)) {
-			skipped.push(`${name}(quota)`);
+		const why = exclusionReason(config, state, name, cls);
+		if (why) {
+			excluded.push(`${name}: ${why}`);
 			continue;
 		}
 		return {
 			providerName: name,
 			provider: p,
 			modelAlias: null,
-			roleMcp: null,
+			classMcp: cls?.mcp ?? null,
 			via: "auto"
 		};
 	}
-	throw new NoProviderError(`auto-routing found no usable provider (order: [${config.routing.order.join(", ")}]${skipped.length ? `; skipped: ${skipped.join(", ")}` : ""}).\nClear a cooldown with: pai worker providers enable <name>`);
+	throw new NoProviderError(`auto-routing found no usable provider${opts.className ? ` for class "${opts.className}"` : ""} (order: [${order.join(", ")}]).${excluded.length ? `\nExcluded: ${excluded.join("; ")}.` : ""}\nClear a cooldown with: pai worker providers enable <name>; widen the class with: pai worker classes set ${opts.className ?? "<class>"}=<target>`);
 }
 /**
 * Next provider after `from` in auto order, applying the same filters.
@@ -859,11 +954,13 @@ function isQuotaFailure(resultText) {
 * pane.ts — the per-worker follow pane in iTerm2.
 *
 * One small-font pane per worker, stacked in a right-hand column: the first
-* worker of a scope splits the launching session vertically (right, ~40% of
-* the columns), every further one splits the lowest live worker pane
-* horizontally, so panes stack top to bottom. Each pane runs
-* `pai worker follow <id> --auto-exit <n>` under the `pai-worker` dynamic
-* profile (Close Sessions On End), so panes disappear by themselves.
+* worker of a scope splits the launching session vertically, every further
+* one splits the lowest live worker pane horizontally, so panes stack top to
+* bottom. The split never sizes the new session — that would grow the whole
+* window; instead the window's bounds are read before the split and restored
+* right after, so the panes share the space the window already had. Each
+* pane runs `pai worker follow <id> --auto-exit <n>` under the `pai-worker`
+* dynamic profile (Close Sessions On End), so panes disappear by themselves.
 *
 * Panes are tracked per scope (AIBroker session id, else tab key) in
 * <logDir>/panes/<key>.json, keyed by iTerm session unique id, newest first —
@@ -893,10 +990,14 @@ const WORKER_SPLIT_SCRIPT = `on run(argv)
             repeat with t in tabs of w
                 repeat with s in sessions of t
                     if id of s is targetID then
-                        set parentCols to missing value
-                        try
-                            set parentCols to columns of s
-                        end try
+                        -- sizing the new session would grow the whole window:
+                        -- pin the window's bounds now and restore them after
+                        -- the split, so the panes share the existing space.
+                        -- copy, never set: set stores the property
+                        -- reference lazily, so restoring it would re-read the
+                        -- post-split bounds instead of these — observed as the
+                        -- window jumping to the main display
+                        copy bounds of w to winBounds
                         set sessIDs to {}
                         repeat with other in sessions of t
                             set end of sessIDs to (id of other as text)
@@ -936,13 +1037,9 @@ const WORKER_SPLIT_SCRIPT = `on run(argv)
                         tell newS
                             write text followCmd
                         end tell
-                        if splitS is missing value and parentCols is not missing value then
-                            try
-                                tell newS
-                                    set columns to (round (parentCols * 0.4))
-                                end tell
-                            end try
-                        end if
+                        try
+                            set bounds of w to winBounds
+                        end try
                         set out to ""
                         repeat with lid in lived
                             set out to out & lid & ","
@@ -987,6 +1084,27 @@ const TAB_TTYS_SCRIPT = `on run(argv)
     end tell
     return "notfound"
 end run`;
+const WINDOW_BOUNDS_SCRIPT = `on run(argv)
+    set targetID to item 1 of argv
+    tell application id "com.googlecode.iterm2"
+        if not running then return "notrunning"
+        repeat with w in windows
+            repeat with t in tabs of w
+                repeat with s in sessions of t
+                    if id of s is targetID then
+                        copy bounds of w to winBounds
+                        set prevDels to AppleScript's text item delimiters
+                        set AppleScript's text item delimiters to ", "
+                        set out to winBounds as text
+                        set AppleScript's text item delimiters to prevDels
+                        return out
+                    end if
+                end repeat
+            end repeat
+        end repeat
+    end tell
+    return "notfound"
+end run`;
 const SPLIT_SCRIPT = `on run(argv)
     set targetID to item 1 of argv
     set followCmd to item 2 of argv
@@ -1257,12 +1375,31 @@ async function openPaneForWorker(logDir, config, wid, term) {
 	return `pane opened for ${wid}`;
 }
 /**
+* One `--check` line with the bounds of the window hosting `term`'s iTerm
+* session — the before/after pair that shows whether a split moved it.
+* Read-only; never touches the window.
+*/
+async function windowBoundsLine(term) {
+	const uid = itermUuid(term);
+	if (!uid) return "window bounds: (not in iTerm2)";
+	try {
+		const p = await osascript(WINDOW_BOUNDS_SCRIPT, [uid]);
+		const out = p.stdout.trim();
+		if (out && out !== "notfound" && out !== "notrunning") return `window bounds: ${out}`;
+		return `window bounds: (${out === "notfound" ? "iTerm2 session not found" : out === "notrunning" ? "iTerm2 not running" : (p.stderr.trim() || "no output").slice(0, 120)})`;
+	} catch (e) {
+		return `window bounds: (osascript: ${String(e.message ?? e).slice(0, 120)})`;
+	}
+}
+/**
 * Report-only variant used by `pai worker pane <id> --check`: whether a pane
-* runs for the worker, plus the dynamic profile's path, its existence, and
-* the font it contains (or, when missing, would write).
+* runs for the worker, the bounds of the window hosting the asking session,
+* plus the dynamic profile's path, its existence, and the font it contains
+* (or, when missing, would write).
 */
-async function checkPaneForWorker(wid, fontSize) {
+async function checkPaneForWorker(wid, fontSize, term) {
 	const lines = [workerPaneOpen(wid) ? `pane for ${wid} open` : `no pane for ${wid}`];
+	lines.push(await windowBoundsLine(term));
 	const path = dynamicProfilePath();
 	if (existsSync(path)) {
 		let font = "(unreadable)";
@@ -1877,9 +2014,19 @@ function stdinUserMessage(text) {
 		}
 	});
 }
-/** ISO stamp with seconds, attached to every mirrored event (2g). */
-function isoStamp(d = /* @__PURE__ */ new Date()) {
-	return d.toISOString().replace(/\.\d{3}Z$/, "Z");
+/**
+* ISO stamp with seconds, attached to every mirrored event (2g): local time
+* with its offset (`2026-09-17T14:19:23+02:00`), so the viewer can render the
+* wall clock the operator lives in. `offMin` is east-positive minutes —
+* injectable so tests do not depend on the machine's zone.
+*/
+function isoStamp(d = /* @__PURE__ */ new Date(), offMin = -d.getTimezoneOffset()) {
+	const t = new Date(d.getTime() + offMin * 6e4);
+	const sign = offMin < 0 ? "-" : "+";
+	const abs = Math.abs(offMin);
+	const hh = String(Math.floor(abs / 60)).padStart(2, "0");
+	const mm = String(abs % 60).padStart(2, "0");
+	return `${t.toISOString().slice(0, 19)}${sign}${hh}:${mm}`;
 }
 /** Context tokens of an assistant/result usage block (input+cache+output). */
 function usageContextTokens(u) {
@@ -1904,7 +2051,7 @@ async function runWorker(opts) {
 	mkdirSync(logDir, { recursive: true });
 	const target = resolveTarget(config, logDir, {
 		flagProvider: opts.providerFlag,
-		role: opts.role
+		className: opts.className
 	});
 	assertProviderRunnable(target.providerName, target.provider);
 	const parsed = parseRunnerArgs(opts.claudeArgs);
@@ -1920,6 +2067,10 @@ async function runWorker(opts) {
 			parsed,
 			claudeArgs: opts.claudeArgs,
 			noPane: opts.noPane ?? false,
+			cwd: opts.cwd,
+			parent: opts.parent,
+			stage: opts.stage,
+			quiet: opts.quiet,
 			onWorkerStart: opts.onWorkerStart
 		});
 		return await executeRun({
@@ -1932,6 +2083,10 @@ async function runWorker(opts) {
 			claudeArgs: opts.claudeArgs,
 			noPane: opts.noPane ?? false,
 			mcpFlag: opts.mcpFlag,
+			cwd: opts.cwd,
+			parent: opts.parent,
+			stage: opts.stage,
+			quiet: opts.quiet,
 			onWorkerStart: opts.onWorkerStart,
 			reroutes: opts._reroutes ?? 0
 		});
@@ -1947,7 +2102,7 @@ async function executeRun(a) {
 	if (target.provider.protocol === "openai") proxyUrl = `${await ensureProxyRunning(DEFAULT_PROXY_PORT, logDir)}/${target.providerName}`;
 	const env = buildRunEnv(target.provider, headless, proxyUrl);
 	const wid = newWorkerId();
-	const cwd = process.cwd();
+	const cwd = a.cwd ?? process.cwd();
 	const term = process.env.ITERM_SESSION_ID ?? "";
 	const session = resolveSession(term);
 	const status = {
@@ -1967,7 +2122,11 @@ async function executeRun(a) {
 		rc: null,
 		secs: null,
 		...session ? { session } : {},
-		contextWindow: providerContextWindow(target.provider)
+		contextWindow: providerContextWindow(target.provider),
+		...a.parent ? {
+			parent: a.parent,
+			stage: a.stage
+		} : {}
 	};
 	saveStatus(logDir, status);
 	a.onWorkerStart?.(wid);
@@ -1986,7 +2145,7 @@ async function executeRun(a) {
 		const wanted = [
 			...a.mcpFlag ? [a.mcpFlag] : [],
 			...parsed.mcp,
-			...target.roleMcp ?? []
+			...target.classMcp ?? []
 		];
 		if (wanted.length) mcpArgs = [
 			"--strict-mcp-config",
@@ -2154,7 +2313,7 @@ async function executeRun(a) {
 		tools: status.tools,
 		label
 	});
-	if (headless) printResult(parsed.outputFormat, resultEvent, rc, logDir, wid, ctx.resultReport);
+	if (headless && !a.quiet) printResult(parsed.outputFormat, resultEvent, rc, logDir, wid, ctx.resultReport);
 	const resultText = resultEvent?.result ?? "";
 	if (!ok && headless && a.target.via === "auto" && config.routing.retryOnQuota && status.turns <= 1 && status.tools === 0 && isQuotaFailure(resultText)) {
 		setCooldown(logDir, target.providerName, config.routing.cooldownMinutes);
@@ -2170,6 +2329,9 @@ async function executeRun(a) {
 				label,
 				noPane: a.noPane,
 				mcpFlag: a.mcpFlag,
+				cwd: a.cwd,
+				parent: a.parent,
+				stage: a.stage,
 				claudeArgs: a.claudeArgs,
 				onWorkerStart: a.onWorkerStart,
 				_reroutes: a.reroutes + 1
@@ -2183,7 +2345,7 @@ async function executeCodexRun(a) {
 	if (!parsed.headless || parsed.prompt === null) throw new Error(`provider "${target.providerName}" (engine codex) supports headless runs only: pass the task with -p '<prompt>'`);
 	const env = buildCodexEnv(target.provider);
 	const wid = newWorkerId();
-	const cwd = process.cwd();
+	const cwd = a.cwd ?? process.cwd();
 	const term = process.env.ITERM_SESSION_ID ?? "";
 	const session = resolveSession(term);
 	const status = {
@@ -2203,7 +2365,11 @@ async function executeCodexRun(a) {
 		rc: null,
 		secs: null,
 		...session ? { session } : {},
-		contextWindow: providerContextWindow(target.provider)
+		contextWindow: providerContextWindow(target.provider),
+		...a.parent ? {
+			parent: a.parent,
+			stage: a.stage
+		} : {}
 	};
 	saveStatus(logDir, status);
 	a.onWorkerStart?.(wid);
@@ -2313,7 +2479,7 @@ async function executeCodexRun(a) {
 		tools: status.tools,
 		label
 	});
-	printResult(parsed.outputFormat, resultEvent, rc, logDir, wid, report);
+	if (!a.quiet) printResult(parsed.outputFormat, resultEvent, rc, logDir, wid, report);
 	return rc !== 0 ? rc : ok ? 0 : 1;
 }
 function printResult(fmt, resultEvent, rc, logDir, wid, report) {
@@ -2440,6 +2606,392 @@ function resultFromOutput(out) {
 	return trimmed.slice(0, 200);
 }
 
+//#endregion
+//#region src/workers/chain.ts
+/**
+* chain.ts — draft-then-implement chains: `--chain draft,implement[,review]`.
+*
+* The chain runs each stage as its own worker (own id, own pane, `parent` set
+* to the chain id), so `ps` shows the chain as a tree and every stage can be
+* followed, replayed and said to like any other worker:
+*
+*   - draft    turns the operator's brief into a full spec file under
+*              <logDir>/specs/<chain id>.md (goal, constraints, files likely
+*              touched, acceptance checks, verification commands);
+*   - any other stage (implement, plan, …) runs with that spec as its prompt
+*              and the original brief attached;
+*   - review   reads the spec and the working-tree diff and produces the
+*              structured report.
+*
+* A stage that fails (or a draft that produces no spec file) stops the chain;
+* the caller then writes the spec itself and re-runs without the draft stage.
+*/
+/** Where a chain's spec file lives: <logDir>/specs/<chain id>.md. */
+function specPathFor(logDir, chainId) {
+	return join(logDir, "specs", `${chainId}.md`);
+}
+/**
+* Replace the caller's -p value with `prompt`, dropping every existing
+* -p/--print pair first (two -p flags on one claude command line are an error,
+* so the chain must never leave the brief in place when swapping prompts).
+*/
+function swapPromptArg(claudeArgs, prompt) {
+	const out = [];
+	for (let i = 0; i < claudeArgs.length; i++) {
+		const a = claudeArgs[i];
+		if (a === "-p" || a === "--print") {
+			if (i + 1 < claudeArgs.length && !claudeArgs[i + 1].startsWith("-")) i += 1;
+			continue;
+		}
+		out.push(a);
+	}
+	out.push("-p", prompt);
+	return out;
+}
+function draftPrompt(brief, specPath) {
+	return [
+		"You are the DRAFT stage of a worker chain. Turn the operator's brief below into a full implementation spec and write it to",
+		specPath,
+		"with the Write tool.",
+		"",
+		"Use exactly these five sections as Markdown headings:",
+		"# Goal",
+		"# Constraints",
+		"# Files likely touched",
+		"# Acceptance checks",
+		"# Verification commands",
+		"",
+		"Read the repository first (Glob/Grep/Read) so the spec names real files and real commands. Do not implement anything.",
+		"",
+		"## Operator brief",
+		"",
+		brief
+	].join("\n");
+}
+function implementPrompt(brief, specPath, spec) {
+	return [
+		...spec ? [
+			"You are the IMPLEMENT stage of a worker chain. The draft stage wrote the spec below (also at " + specPath + "). Implement it exactly, then run the spec's verification commands before finishing.",
+			"",
+			"## Spec",
+			"",
+			spec
+		] : ["Implement the operator's brief below."],
+		"",
+		"## Operator brief",
+		"",
+		brief
+	].join("\n");
+}
+function reviewPrompt(brief, specPath, spec) {
+	return [
+		"You are the REVIEW stage of a worker chain. The implement stage just ran. Read the repository's diff (run `git diff` and `git status`; use `git diff --stat` for the overview) and check it against the spec's acceptance checks and verification commands — run the checks when they are cheap. Do not fix anything you find; report it.",
+		...spec ? [
+			"",
+			"## Spec (also at " + specPath + ")",
+			"",
+			spec
+		] : [],
+		"",
+		"## Operator brief",
+		"",
+		brief
+	].join("\n");
+}
+/** Run a chain of stages; returns the exit code of the first failed stage, 0 when all pass. */
+async function runChain(opts, deps = {}) {
+	const stages = opts.stages.map((s) => s.trim()).filter(Boolean);
+	if (!stages.length) throw new Error("--chain needs at least one class, e.g. --chain draft,implement");
+	const runStage = deps.runStage ?? runWorker;
+	const logDir = deps.logDir ?? workersLogDir(readWorkersSection().workers);
+	const chainId = newWorkerId();
+	const specPath = specPathFor(logDir, chainId);
+	mkdirSync(join(logDir, "specs"), { recursive: true });
+	const baseLabel = opts.label ?? shortText(opts.brief, 40);
+	appendLedger(ledgerPath(logDir), "WORKER-CHAIN", {
+		chain: chainId,
+		stages: stages.join(","),
+		label: baseLabel
+	});
+	opts.onChainStart?.(chainId);
+	let spec = null;
+	for (let i = 0; i < stages.length; i++) {
+		const stage = stages[i];
+		if (stage === "draft") spec = null;
+		else if (spec === null && existsSync(specPath)) spec = readFileSync(specPath, "utf8");
+		const prompt = stage === "draft" ? draftPrompt(opts.brief, specPath) : stage === "review" ? reviewPrompt(opts.brief, spec ? specPath : null, spec) : implementPrompt(opts.brief, spec ? specPath : null, spec);
+		process.stderr.write(`chain ${chainId}: stage ${i + 1}/${stages.length} ${stage} (spec: ${specPath})\n`);
+		const rc = await runStage({
+			className: opts.className ?? stage,
+			providerFlag: opts.providerFlag,
+			modelFlag: opts.modelFlag,
+			label: `${baseLabel} · ${stage}`,
+			noPane: opts.noPane,
+			mcpFlag: opts.mcpFlag,
+			claudeArgs: swapPromptArg(opts.claudeArgs, prompt),
+			cwd: opts.cwd,
+			parent: chainId,
+			stage,
+			quiet: opts.quiet
+		});
+		if (stage === "draft") {
+			if (!existsSync(specPath)) {
+				process.stderr.write(`chain ${chainId}: draft stage produced no spec at ${specPath} — stopping. Write the spec yourself and re-run without the draft stage.\n`);
+				appendLedger(ledgerPath(logDir), "WORKER-CHAIN-END", {
+					chain: chainId,
+					rc: rc !== 0 ? rc : 1,
+					failed: "draft"
+				});
+				return rc !== 0 ? rc : 1;
+			}
+			spec = readFileSync(specPath, "utf8");
+		}
+		if (rc !== 0) {
+			appendLedger(ledgerPath(logDir), "WORKER-CHAIN-END", {
+				chain: chainId,
+				rc,
+				failed: stage
+			});
+			return rc;
+		}
+	}
+	appendLedger(ledgerPath(logDir), "WORKER-CHAIN-END", {
+		chain: chainId,
+		rc: 0
+	});
+	return 0;
+}
+
+//#endregion
+//#region src/workers/chatui.ts
+/**
+* chatui.ts — the chat line of a `follow` pane.
+*
+* A follow pane with a target behaves like a small chat, Claude Code style:
+* the transcript lives in a terminal scroll region that ends two rows above
+* the pane's bottom; the last two rows are fixed — the prompt row (`› `,
+* readline line editing) and the ticker row. A transcript line is inserted
+* above the fixed rows with a save-cursor / scroll-region / restore-cursor
+* write that never touches them; the scroll region makes the transcript roll
+* inside itself. Everything here builds strings (or parses one line), so the
+* tests assert exact byte sequences — no terminal needed.
+*/
+/** The prompt marker of the chat row. */
+const CHAT_PROMPT = "› ";
+/** Dim hint shown once behind the cursor until the first line is typed. */
+const CHAT_HINT = "type here and press Enter · /help for commands";
+/** What `/help` prints (one command per line, dim). */
+const CHAT_HELP = [
+	"/quit            close this pane",
+	"/resume <text>   continue the finished worker with <text>",
+	"/status          one-line worker status",
+	"anything else is sent to the worker — said while it runs, resumed after"
+];
+/** Index just past the escape starting at `i` (CSI, OSC or a two-char one). */
+function endOfEscape(s, i) {
+	const n = s[i + 1];
+	if (n === "[") {
+		let j = i + 2;
+		while (j < s.length && !(s[j] >= "@" && s[j] <= "~")) j++;
+		return Math.min(s.length, j + 1);
+	}
+	if (n === "]") {
+		let j = i + 2;
+		while (j < s.length && s[j] !== "\x07") j++;
+		return Math.min(s.length, j + 1);
+	}
+	return i + 2;
+}
+/** Printable columns of `s` — ANSI escape sequences measure zero. */
+function visibleWidth(s) {
+	let w = 0;
+	let i = 0;
+	while (i < s.length) {
+		if (s[i] === "\x1B") {
+			i = endOfEscape(s, i);
+			continue;
+		}
+		w += 1;
+		i += 1;
+	}
+	return w;
+}
+/**
+* The SGR sequences in effect at `upto`: everything opened since the last
+* reset, in order. Anything that is not an SGR escape is ignored (it does
+* not change colour state).
+*/
+function sgrStateAt(text, upto) {
+	const open = [];
+	let i = 0;
+	while (i < Math.min(upto, text.length)) {
+		if (text[i] === "\x1B") {
+			const end = endOfEscape(text, i);
+			const esc = text.slice(i, end);
+			if (/^\x1b\[[0-9;]*m$/.test(esc)) {
+				const params = esc.slice(2, -1);
+				if (params === "" || params.split(";").includes("0")) open.length = 0;
+				if (!(params === "" || params === "0")) open.push(esc);
+			}
+			i = end;
+			continue;
+		}
+		i += 1;
+	}
+	return open;
+}
+/**
+* Wrap one rendered row to `width` printable columns. Breaks on whitespace
+* where possible, hard-wraps words longer than the width, never splits an
+* ANSI escape, and re-opens the colours it wraps inside of, so a diff row
+* keeps its `-`/`+` colour on every continuation row.
+*/
+function wrapText(text, width) {
+	if (width < 1 || visibleWidth(text) <= width) return [text];
+	const chars = [];
+	for (let i = 0; i < text.length; i++) {
+		if (text[i] === "\x1B") {
+			i = endOfEscape(text, i) - 1;
+			continue;
+		}
+		chars.push(i);
+	}
+	const words = [];
+	{
+		let s = -1;
+		let w = 0;
+		for (let k = 0; k <= chars.length; k++) if ((k === chars.length ? " " : text[chars[k]]) === " ") {
+			if (s >= 0) {
+				words.push({
+					s,
+					e: k - 1,
+					w
+				});
+				s = -1;
+				w = 0;
+			}
+		} else {
+			if (s < 0) s = k;
+			w++;
+		}
+	}
+	if (words.length && words[0].s > 0) words[0] = {
+		s: 0,
+		e: words[0].e,
+		w: words[0].w + words[0].s
+	};
+	const spans = [];
+	let cs = -1;
+	let ce = -1;
+	for (const word of words) {
+		if (word.w > width) {
+			const room = cs < 0 ? 0 : width - (ce - cs + 1);
+			const take = room > 0 ? ce + room - word.s + 1 : 0;
+			if (take > 0) spans.push([cs, ce + room]);
+			else if (cs >= 0) spans.push([cs, ce]);
+			let pos = word.s + Math.max(0, take);
+			let remaining = word.w - Math.max(0, take);
+			while (remaining > width) {
+				spans.push([pos, pos + width - 1]);
+				pos += width;
+				remaining -= width;
+			}
+			cs = pos;
+			ce = pos + remaining - 1;
+			continue;
+		}
+		if (cs < 0) {
+			cs = word.s;
+			ce = word.e;
+			continue;
+		}
+		if (word.e - cs + 1 <= width) {
+			ce = word.e;
+			continue;
+		}
+		spans.push([cs, ce]);
+		cs = word.s;
+		ce = word.e;
+	}
+	if (cs >= 0) spans.push([cs, ce]);
+	const out = [];
+	for (const [a, b] of spans) {
+		const from = chars[a];
+		let end = chars[b] + 1;
+		while (end < text.length && text[end] === "\x1B") end = endOfEscape(text, end);
+		let piece = text.slice(from, end);
+		const reopen = sgrStateAt(text, from);
+		if (reopen.length) piece = reopen.join("") + piece;
+		if (sgrStateAt(text, end).length) piece += "\x1B[0m";
+		out.push(piece);
+	}
+	return out.length ? out : [""];
+}
+/** Restrict scrolling to the transcript region (rows 1 … rows-2). */
+function chatScrollRegion(rows) {
+	return `\x1b[1;${Math.max(1, rows - 2)}r`;
+}
+/**
+* Enter the chat layout: clear the pane, set the scroll region, park the
+* cursor at column 1 of the prompt row (rows-1). The ticker owns row `rows`.
+*/
+function chatEnter(rows) {
+	return "\x1B[2J" + chatScrollRegion(rows) + `\x1b[${Math.max(1, rows - 1)};1H`;
+}
+/** Leave it: reset the scroll region, show the cursor, drop to the last row. */
+function chatLeave(rows) {
+	return `[?25h\x1b[${Math.max(1, rows)};1H`;
+}
+/** Redraw the ticker on its own row without moving the user's cursor. */
+function chatTickerRow(text, rows) {
+	return `7\x1b[${Math.max(1, rows)};1H\x1b[K` + text + "\x1B8";
+}
+/** Move to column 1 of the prompt row and draw prompt (and hint). */
+function chatPromptRow(rows, prompt = CHAT_PROMPT, hint) {
+	return `\x1b[${Math.max(1, rows - 1)};1H` + prompt + (hint ?? "");
+}
+/**
+* Insert one transcript row above the fixed prompt/ticker rows. While the
+* region is still filling (`fill < regionRows`) the row is placed top-down;
+* once full, the cursor moves to the region's bottom row and a newline
+* scrolls the region up by one — the two fixed rows are never touched. The
+* user's cursor is saved before and restored after, so readline keeps its
+* position on the prompt row.
+*/
+function chatInsertLine(line, fill, regionRows) {
+	return {
+		seq: "\x1B7" + (fill < regionRows ? `\x1b[${fill + 1};1H${line}\x1b[K` : `\x1b[${regionRows};1H\n${line}\x1b[K`) + "\x1B8",
+		fill: Math.min(fill + 1, regionRows)
+	};
+}
+/**
+* One submitted prompt line → what to do with it. `/help`, `/quit`,
+* `/status` and `/resume <text>` are commands (a bare `/resume` comes back
+* with empty text so the caller can print its usage); anything else,
+* including any other `/word`, is a message for the worker.
+*/
+function parseChatLine(raw) {
+	const text = raw.trim();
+	if (text === "/help") return { kind: "help" };
+	if (text === "/quit") return { kind: "quit" };
+	if (text === "/status") return { kind: "status" };
+	if (text.startsWith("/resume")) return {
+		kind: "resume",
+		text: text.slice(7).trim()
+	};
+	return {
+		kind: "message",
+		text
+	};
+}
+/**
+* The auto-exit countdown must not fire while the prompt holds unsent text:
+* true while it does. null/undefined (no prompt wired) never holds.
+*/
+function holdAutoExit(promptText) {
+	return typeof promptText === "string" && promptText.trim() !== "";
+}
+
 //#endregion
 //#region src/workers/render.ts
 /**
@@ -2493,21 +3045,82 @@ function unifiedDiffLines(oldStr, newStr) {
 	return out;
 }
 /**
+* `HH:MM:SS` at an offset east of UTC in minutes (Date.getTimezoneOffset()
+* negated), from any ISO stamp the runner wrote — `Z` or a local `+HH:MM`.
+* null when the stamp cannot be parsed. Offsets make this testable without
+* depending on the machine's zone; the default is this machine's.
+*/
+function clockOf(ts, offMin = -(/* @__PURE__ */ new Date()).getTimezoneOffset()) {
+	const t = Date.parse(ts);
+	if (Number.isNaN(t)) return null;
+	return new Date(t + offMin * 6e4).toISOString().slice(11, 19);
+}
+/** `YYYY-MM-DD` at the same offset — the local day a date separator shows. */
+function dayOf(ts, offMin = -(/* @__PURE__ */ new Date()).getTimezoneOffset()) {
+	const t = Date.parse(ts);
+	if (Number.isNaN(t)) return null;
+	return new Date(t + offMin * 6e4).toISOString().slice(0, 10);
+}
+/**
 * The transcript gutter (2g): `HH:MM:SS │ ` from the event's `_ts`, dim, with
 * the worker tag in front when several run at once. Continuation lines get
-* blanks of the same width so wrapped text stays aligned. null when the event
-* carries no stamp (logs from before 2g render with the plain prefix).
+* blanks of the same width so wrapped text stays aligned; when the viewer
+* wraps lines itself, continuation rows carry the `│` bar instead (barCont)
+* so the bar runs unbroken down the pane. null when the event carries no
+* stamp (logs from before 2g render with the plain prefix). The time is the
+* stamp's wall clock at `offMin` — the default renders local time, whatever
+* zone stamped the log (old logs were stamped in UTC).
 */
-function gutterFor(c, e, tag) {
+function gutterFor(c, e, tag, offMin) {
 	if (!e._ts) return null;
-	const time = e._ts.length >= 19 ? e._ts.slice(11, 19) : e._ts;
+	const time = clockOf(e._ts, offMin) ?? (e._ts.length >= 19 ? e._ts.slice(11, 19) : e._ts);
 	const head = tag ? `${tag} ${time}` : time;
 	const width = head.length + 3;
 	return {
 		first: c("dim", `${head} │ `),
-		cont: " ".repeat(width)
+		cont: " ".repeat(width),
+		barCont: c("dim", `${" ".repeat(head.length)} │ `),
+		width
 	};
 }
+/**
+* The ticker's tool part: `$ <command>` for Bash (first 60 chars), the file
+* basename for the file tools, the bare name for everything else.
+*/
+function tickerTool(name, inp) {
+	const i = typeof inp === "object" && inp !== null ? inp : {};
+	const get = (k) => typeof i[k] === "string" ? i[k] : "";
+	if (name === "Bash") return `$ ${shortText(get("command").replace(/\s+/g, " ").trim(), 60)}`;
+	if (name === "Read" || name === "Edit" || name === "Write" || name === "MultiEdit") return (get("file_path").split("/").pop() ?? "") || name;
+	return name;
+}
+/**
+* The liveness line: `⋯ 12s · run tests before the fix · $ bun run test` —
+* seconds since the last *rendered* event, the worker's last stated intent
+* (its last assistant text, ≤60 chars) and the tool it is currently running.
+* Parts that are empty drop out.
+*/
+function tickerText(secs, intent, tool, meter) {
+	const head = `⋯ ${secs}s`;
+	const tail = [intent, tool].map((p) => p.trim()).filter(Boolean).join(" · ");
+	const line = tail ? `${head} · ${tail}` : head;
+	return meter ? `${line} · ${meter}` : line;
+}
+/**
+* One blank line between turns, none inside one: a blank goes before an
+* assistant message that follows a tool result or an operator message (the
+* worker starting to speak again after its tools were answered / it was told
+* something), not between the text, tool calls and results of one turn.
+*/
+function blankBetween(prev, e) {
+	if (!prev) return false;
+	if (e.type !== "assistant") return false;
+	return prev.type === "user" || prev.type === "operator";
+}
+/** The worker's last stated intent: the first line of its last text, ≤60. */
+function intentOf(text) {
+	return shortText((text.trim().split("\n").find((l) => l.trim()) ?? "").trim().replace(/\s+/g, " "), 60);
+}
 /** Compact token count: 84k, 200k, 900. */
 function fmtK(n) {
 	return n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n);
@@ -2582,7 +3195,18 @@ function headerLine(c, s) {
 	const sep = bits ? `  ${bits}` : "";
 	return c("bold", `━━ ${s.id}${sep}  ${s.label}  (${basename(s.cwd)})`);
 }
-/** The ps table (RUNNING + FINISHED last 8). */
+/** The chain label behind a stage label: strip the trailing " · <stage>". */
+function chainLabelOf(stages) {
+	const first = stages[0];
+	if (!first) return "";
+	const suffix = first.stage ? ` · ${first.stage}` : "";
+	return first.label.endsWith(suffix) && suffix ? first.label.slice(0, first.label.length - suffix.length) : first.label;
+}
+/**
+* The ps table (RUNNING + FINISHED last 8). Chain stages carry `parent` and
+* render as a tree under one `chain <id>` header; plain workers render as
+* before.
+*/
 function renderTable(c, statuses, scopeLabel, now = /* @__PURE__ */ new Date()) {
 	const running = [];
 	const done = [];
@@ -2591,21 +3215,55 @@ function renderTable(c, statuses, scopeLabel, now = /* @__PURE__ */ new Date())
 		if (s.state === "running") s.state = "lost";
 		done.push(s);
 	}
+	const group = (list) => {
+		const out = [];
+		for (const s of list) out.push({
+			s,
+			chain: s.parent ?? null
+		});
+		return out;
+	};
+	const treeLine = (line, chain, last) => {
+		if (chain === null) return line;
+		const mark = last ? "└" : "├";
+		const bar = last ? " " : "│";
+		return line.startsWith("      ") ? `  ${bar}   ${line.slice(6)}` : `  ${mark} ${line.slice(2)}`;
+	};
 	const lines = [c("bold", `Workers  ${`${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}`}`), ""];
 	lines.push(c("bold", `RUNNING (${running.length})`));
 	if (!running.length) lines.push("  none");
-	for (const s of running) {
+	const runEntries = group(running);
+	for (let i = 0; i < runEntries.length; i++) {
+		const { s, chain } = runEntries[i];
+		if (chain) {
+			const prev = runEntries[i - 1];
+			if (!prev || prev.chain !== chain) {
+				const stages = runEntries.filter((e) => e.chain === chain).map((e) => e.s);
+				lines.push(`  ${c("bold", `chain ${chain}`)}  ${chainLabelOf(stages)}`);
+			}
+		}
+		const last = !chain || !runEntries[i + 1] || runEntries[i + 1].chain !== chain;
 		const meter = contextMeter(c, s, 60);
-		lines.push(`  ${c("cyan", s.id)} [${s.provider}]  ${ageOf(s.started, now).padStart(4)} old  turns ${String(s.turns).padStart(2)}  tools ${String(s.tools).padStart(2)}  ${basename(s.cwd)}${meter ? "  " + meter : ""}`);
-		lines.push(`      task: ${s.label}`);
-		lines.push(`      now:  ${c("yellow", s.last)}  (${ageOf(s.updated, now)} ago)`);
+		lines.push(treeLine(`  ${c("cyan", s.id)} [${s.provider}]  ${ageOf(s.started, now).padStart(4)} old  turns ${String(s.turns).padStart(2)}  tools ${String(s.tools).padStart(2)}  ${basename(s.cwd)}${meter ? "  " + meter : ""}`, chain, last));
+		lines.push(treeLine(`      task: ${s.label}`, chain, last));
+		lines.push(treeLine(`      now:  ${c("yellow", s.last)}  (${ageOf(s.updated, now)} ago)`, chain, last));
 	}
 	lines.push("");
 	lines.push(c("bold", "FINISHED (last 8)"));
-	for (const s of done.slice(-8)) {
+	const doneEntries = group(done.slice(-8));
+	for (let i = 0; i < doneEntries.length; i++) {
+		const { s, chain } = doneEntries[i];
+		if (chain) {
+			const prev = doneEntries[i - 1];
+			if (!prev || prev.chain !== chain) {
+				const stages = doneEntries.filter((e) => e.chain === chain).map((e) => e.s);
+				lines.push(`  ${c("bold", `chain ${chain}`)}  ${chainLabelOf(stages)}`);
+			}
+		}
+		const last = !chain || !doneEntries[i + 1] || doneEntries[i + 1].chain !== chain;
 		const col = s.state === "done" ? "green" : "red";
 		const tag = sessionTag(s);
-		lines.push(`  ${s.id} [${s.provider}]${tag ? " " + tag : ""}  ${c(col, s.state.padEnd(6))} rc=${s.rc}  ${String(s.secs ?? "?").padStart(4)}s  turns ${String(s.turns).padStart(2)}  tools ${String(s.tools).padStart(2)}  ${basename(s.cwd)}  ${s.label}`);
+		lines.push(treeLine(`  ${s.id} [${s.provider}]${tag ? " " + tag : ""}  ${c(col, s.state.padEnd(6))} rc=${s.rc}  ${String(s.secs ?? "?").padStart(4)}s  turns ${String(s.turns).padStart(2)}  tools ${String(s.tools).padStart(2)}  ${basename(s.cwd)}  ${s.label}`, chain, last));
 	}
 	lines.push("");
 	lines.push(c("dim", "worker follow        live transcript of running workers"));
@@ -2642,19 +3300,101 @@ function renderStatusLine(mine, now = /* @__PURE__ */ new Date(), c = makeColor(
 * Outside iTerm, everything degrades to "all workers" — the Python behaviour.
 *
 * Transcripts render with a `HH:MM:SS │ ` gutter (2g): dim, taken from the
-* `_ts` stamp on every mirrored event, the worker tag in front when several
-* run at once, a date separator when the day changes, and — on a TTY — a
-* liveness line (`⋯ 12s since last event · Bash: npm test · ctx 84k/200k (42%)`)
-* that is rewritten in place between events. Following one worker also wires
-* this pane's stdin: every typed line is said to the worker while it runs and
-* resumes it (same Claude session) once it has finished.
+* `_ts` stamp on every mirrored event (local wall clock — stamps carry a local
+* offset and old UTC stamps are converted), the worker tag in front when
+* several run at once, a date separator when the day changes, and — on a TTY —
+* a liveness line (`⋯ 12s · run tests before the fix · $ bun run test`) that
+* is rewritten in place between events. Attaching to a worker that is already
+* running first replays its last events (backfill), then continues live.
+*
+* Following one worker turns the pane into a small chat (see chatui.ts): the
+* transcript scrolls in a region that ends two rows above the bottom, the
+* prompt row (`› `, readline editing) and the ticker row stay fixed, and every
+* submitted line is said to the worker while it runs and resumes it (same
+* Claude session) once it has finished. Lines the pane wraps itself keep the
+* `│` bar on continuation rows, so no content ever lands left of the bar.
+* Non-TTY output keeps the plain scrolling behaviour.
 */
+/** How many existing events a fresh follow pane replays before going live. */
+const BACKFILL_EVENTS = 200;
 function psOutput(logDir, showAll, env = process.env, color = process.stdout.isTTY === true) {
 	const c = makeColor(color);
 	const term = env.ITERM_SESSION_ID ?? "";
 	const statuses = loadStatuses(logDir);
 	return renderTable(c, showAll || !term ? statuses : statuses.filter((s) => workerInScope(s, term)), showAll || !term ? "scope: all workers" : resolveSession(term) ? `scope: session ${resolveSession(term).name}` : `scope: tab ${currentTabKey(env)} (this iTerm tab)`);
 }
+function initialFollowState(intent = "waiting for first event") {
+	return {
+		lastDay: "",
+		tools: {},
+		intent,
+		tool: "",
+		prev: null
+	};
+}
+/**
+* Gutter the rendered body of one event, wrapping when the pane width is
+* known. Unwrapped (null `wrapWidth`, e.g. piped output): the first row gets
+* the stamped gutter, later rows of the event blanks — exactly the pre-chat
+* rendering. Wrapped: every row is folded at `wrapWidth` columns and each
+* continuation row carries the blank gutter with the `│` bar, so the bar runs
+* unbroken down the pane and no content ever lands left of it.
+*/
+function gutterBody(body, gutter, wrapWidth) {
+	if (!gutter) return body;
+	if (wrapWidth === null || wrapWidth <= gutter.width) return body.map((ln, i) => (i === 0 ? gutter.first : gutter.cont) + ln);
+	const out = [];
+	for (const ln of body) for (const piece of wrapText(ln, wrapWidth - gutter.width)) out.push((out.length === 0 ? gutter.first : gutter.barCont) + piece);
+	return out;
+}
+/**
+* Render one event and advance the follow state. Everything the viewer shows
+* between events of one worker comes from here: replay, the backfill on
+* attach and the live tail all use it, so they space identically — events
+* back to back, one blank line between turns. `activity` is false for events
+* that render nothing (stream noise, empty tool results): they leave the
+* ticker's "since last event" clock running. `wrapWidth` (the pane's column
+* count, re-read on resize) makes the viewer wrap rows itself; null keeps
+* the terminal's own wrapping.
+*/
+function applyEvent(c, s, e, cwd, tag, offMin, wrapWidth) {
+	const tools = { ...s.tools };
+	if (e.type === "assistant") {
+		for (const b of e.message?.content ?? []) if (b.type === "tool_use" && b.id) tools[b.id] = b.name ?? "?";
+	}
+	const day = typeof e._ts === "string" ? dayOf(e._ts, offMin) ?? rawDay(e._ts) : "";
+	const state = {
+		lastDay: day && day !== s.lastDay ? day : s.lastDay,
+		tools,
+		intent: s.intent,
+		tool: s.tool,
+		prev: e
+	};
+	if (e.type === "assistant") {
+		for (const b of e.message?.content ?? []) if (b.type === "text" && (b.text ?? "").trim()) state.intent = intentOf(b.text ?? "");
+		else if (b.type === "tool_use") state.tool = tickerTool(b.name ?? "?", b.input);
+	}
+	const gutter = gutterFor(c, e, tag, offMin);
+	const body = gutterBody(renderEvent(c, "", e, cwd, tools), gutter, wrapWidth ?? null);
+	const lines = blankBetween(s.prev, e) ? ["", ...body] : body;
+	return {
+		lines,
+		day: day && day !== s.lastDay ? day : null,
+		activity: lines.some((ln) => ln !== ""),
+		state
+	};
+}
+/** `YYYY-MM-DD` straight out of an unparsable stamp, "" when it has none. */
+function rawDay(ts) {
+	return /^\d{4}-\d{2}-\d{2}/.test(ts) ? ts.slice(0, 10) : "";
+}
+/**
+* The events a fresh follow replays before going live: the last `cap`
+* non-empty log lines, oldest first.
+*/
+function backfillLines(raw, cap = BACKFILL_EVENTS) {
+	return raw.split("\n").filter((l) => l.trim()).slice(-cap);
+}
 /** The rendered transcript of one worker, from the start, as one string. */
 function replayOutput(logDir, wid, color = process.stdout.isTTY === true, tailLines) {
 	const path = eventsPath(logDir, wid);
@@ -2666,11 +3406,12 @@ function replayOutput(logDir, wid, color = process.stdout.isTTY === true, tailLi
 		cwd: "",
 		provider: ""
 	};
-	const tools = {};
+	const wrapWidth = typeof process.stdout.columns === "number" ? process.stdout.columns : null;
 	const out = [headerLine(c, st)];
-	const lines = readFileSync(path, "utf8").split("\n");
-	let lastDay = "";
-	for (const line of tailLines !== void 0 ? lines.slice(-tailLines) : lines) {
+	const raw = readFileSync(path, "utf8");
+	const lines = tailLines !== void 0 ? raw.split("\n").slice(-tailLines) : raw.split("\n");
+	let state = initialFollowState("");
+	for (const line of lines) {
 		if (!line.trim()) continue;
 		let e;
 		try {
@@ -2678,20 +3419,13 @@ function replayOutput(logDir, wid, color = process.stdout.isTTY === true, tailLi
 		} catch {
 			continue;
 		}
-		if (typeof e._ts === "string" && e._ts.slice(0, 10) !== lastDay) {
-			lastDay = e._ts.slice(0, 10);
-			out.push(c("dim", `── ${lastDay} ──`));
-		}
-		const g = gutterFor(c, e);
-		collectTools(e, tools);
-		out.push(...renderEvent(c, g ? "" : "  ", e, st.cwd ?? "", tools, g));
+		const step = applyEvent(c, state, e, st.cwd ?? "", void 0, void 0, wrapWidth);
+		if (step.day) out.push(c("dim", `── ${step.day} ──`));
+		out.push(...step.lines);
+		state = step.state;
 	}
 	return out.join("\n");
 }
-function collectTools(e, tools) {
-	if (e.type !== "assistant") return;
-	for (const b of e.message?.content ?? []) if (b.type === "tool_use" && b.id) tools[b.id] = b.name ?? "?";
-}
 /**
 * The follow exit decision for one worker: it is over once its result event
 * was rendered, or once its status left "running" while its pid is gone — a
@@ -2702,110 +3436,307 @@ function workerEnded(resultRendered, state, pidAlive) {
 	return resultRendered || state !== void 0 && state !== "running" && !pidAlive;
 }
 /**
+* One typed stdin line → say (worker running) or resume (worker finished):
+* the operator channel of a `follow <id>` pane. Trimmed; empty lines and a
+* missing target are ignored.
+*/
+function makeOperatorInput(d) {
+	return (raw) => {
+		const text = raw.trim();
+		if (!text) return;
+		const id = d.target();
+		if (id === null) return;
+		d.say(id, text).then(() => d.sent ? d.sent(id) : d.note(d.paint("dim", `» sent to ${id}`)), (e) => {
+			if (d.workerKnown(id)) d.resume(text, id);
+			else d.note(d.paint("red", `» ${e.message}`));
+		});
+	};
+}
+/**
 * Tail one worker (target) or the running workers of this scope, live.
-* Auto-exit: with a target, wait `autoExit` seconds after its end; without
-* one, exit once no worker in scope has run for that many seconds in a row,
-* never within the first 30 s. With a target on a TTY, typed stdin lines are
-* said to the worker (or resume it after it finished).
+* Workers whose event log already exists are first replayed (last
+* BACKFILL_EVENTS events), then tailed. Auto-exit: with a target, wait
+* `autoExit` seconds after its end; without one, exit once no worker in
+* scope has run for that many seconds in a row, never within the first 30 s.
+*
+* With a target on a TTY the pane becomes a chat (chatui.ts): transcript in
+* a scroll region, fixed prompt and ticker rows, submitted lines said to the
+* worker (or resuming it after it finished) and echoed as `»` rows. A draft
+* in the prompt holds the auto-exit countdown. Non-TTY output keeps the
+* plain scrolling behaviour; FORCE_TTY=1 emits the chat layout over a pipe.
 */
-async function followWorkers(logDir, target, showAll, autoExit, env = process.env, color = process.stdout.isTTY === true) {
+async function followWorkers(logDir, target, showAll, autoExit, env = process.env, color = process.stdout.isTTY === true, io) {
 	const c = makeColor(color);
-	const tty = process.stdout.isTTY === true;
+	const out_ = io?.stdout ?? process.stdout;
+	const in_ = io?.stdin ?? process.stdin;
+	const tty = out_.isTTY === true || env.FORCE_TTY === "1";
 	const term = env.ITERM_SESSION_ID ?? "";
 	const scopeTab = target || showAll ? "" : currentTabKey(env);
-	const tools = {};
 	const handles = /* @__PURE__ */ new Map();
 	const seenHeader = /* @__PURE__ */ new Set();
 	const finished = /* @__PURE__ */ new Set();
-	const lastDayBy = /* @__PURE__ */ new Map();
+	const states = /* @__PURE__ */ new Map();
 	const started = Date.now();
 	let idleSince = null;
 	let aborted = false;
 	let lastEventAt = Date.now();
-	let lastAction = "waiting for first event";
 	let meterStatus = null;
-	let livenessLen = 0;
 	const onInt = () => {
 		aborted = true;
 	};
 	process.once("SIGINT", onInt);
-	const plainOf = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
-	const eraseLiveness = () => {
-		if (livenessLen > 0) {
-			process.stdout.write("\r" + " ".repeat(livenessLen) + "\r");
-			livenessLen = 0;
+	const chat = tty && target !== null;
+	let rows = out_.rows ?? 24;
+	const columns = () => typeof out_.columns === "number" ? out_.columns : null;
+	let fill = 0;
+	const regionRows = () => Math.max(1, rows - 2);
+	/** Every line the pane shows goes through here: plain newline, or a row
+	*  inserted above the fixed prompt/ticker rows (chatui.chatInsertLine). */
+	const out = (line) => {
+		if (!chat) {
+			out_.write(line + "\n");
+			return;
 		}
+		const r = chatInsertLine(line, fill, regionRows());
+		out_.write(r.seq);
+		fill = r.fill;
+	};
+	const eraseLiveness = () => {
+		if (chat) return;
+		if (tty) out_.write("\r\x1B[K");
 	};
+	let ticker = initialFollowState();
 	const writeLiveness = () => {
 		if (!tty) return;
-		eraseLiveness();
 		const secs = Math.max(0, Math.floor((Date.now() - lastEventAt) / 1e3));
 		const meter = meterStatus ? contextMeter(c, meterStatus) : null;
-		const plain = `⋯ ${secs}s since last event · ${lastAction}${meter ? ` · ${plainOf(meter)}` : ""}`;
-		process.stdout.write(`
-		livenessLen = plain.length;
+		const text = tickerText(secs, ticker.intent, ticker.tool, meter);
+		if (chat) out_.write(chatTickerRow(text, rows));
+		else {
+			out_.write("\r\x1B[K");
+			out_.write(text);
+		}
 	};
 	const runningIds = () => loadStatuses(logDir).filter((s) => s.state === "running" && alive(s.pid) && (target !== null || showAll || (scopeTab ? workerInScope(s, term) : true))).map((s) => s.id);
+	const emitEvent = (e, wid, st, multi) => {
+		if (e.type === "operator" && chat && suppressMirror(String(e.text ?? ""))) return;
+		if (!seenHeader.has(wid)) {
+			eraseLiveness();
+			out(headerLine(c, st));
+			seenHeader.add(wid);
+		}
+		const step = applyEvent(c, states.get(wid) ?? initialFollowState(), e, st.cwd ?? "", multi ? c("cyan", wid.slice(-4)) : void 0, void 0, columns());
+		if (step.day) out(c("dim", `── ${step.day} ──`));
+		states.set(wid, step.state);
+		if (wid === target) ticker = step.state;
+		eraseLiveness();
+		for (const ln of step.lines) out(ln);
+		if (step.activity) lastEventAt = Date.now();
+		if (e.type === "result") {
+			meterStatus = st;
+			finished.add(wid);
+		} else if (wid === target || target === null) meterStatus = st;
+	};
+	const attachHandle = (wid, path, st, multi) => {
+		const handle = {
+			fd: openSync(path, "r"),
+			buf: ""
+		};
+		try {
+			const existing = readFileSync(path, "utf8");
+			if (existing.trim()) for (const line of backfillLines(existing)) {
+				let e;
+				try {
+					e = JSON.parse(line);
+				} catch {
+					continue;
+				}
+				emitEvent(e, wid, st, multi);
+			}
+			else if (!seenHeader.has(wid)) {
+				out(headerLine(c, st));
+				seenHeader.add(wid);
+			}
+			const sink = Buffer.alloc(65536);
+			for (;;) {
+				let n;
+				try {
+					n = readSync(handle.fd, sink, 0, sink.length, null);
+				} catch {
+					break;
+				}
+				if (n <= 0) break;
+			}
+		} catch {}
+		return handle;
+	};
 	const noteLine = (s) => {
 		eraseLiveness();
-		process.stdout.write(s + "\n");
+		out(s);
 	};
+	const spawnResume = io?.spawnResume ?? ((id, text) => spawn("pai", [
+		"worker",
+		"resume",
+		id,
+		text,
+		"--print-id",
+		"--no-pane"
+	], { stdio: [
+		"ignore",
+		"pipe",
+		"inherit"
+	] }));
 	const resumeTarget = (text, id) => {
 		noteLine(c("dim", `» resuming ${id} …`));
-		const child = spawn("pai", [
-			"worker",
-			"resume",
-			id,
-			text,
-			"--print-id",
-			"--no-pane"
-		], { stdio: [
-			"ignore",
-			"pipe",
-			"inherit"
-		] });
+		const child = spawnResume(id, text);
 		let idOut = "";
 		child.stdout?.on("data", (chunk) => {
 			idOut += chunk.toString("utf8");
 		});
 		child.on("close", (rc) => {
 			const newId = idOut.trim().split("\n").pop() ?? "";
-			if (rc === 0 && /^[0-9]{8}-[0-9]{6}-[0-9]+$/.test(newId)) {
+			if (rc === 0 && /^\d{8}-\d{6}-\d+$/.test(newId)) {
 				noteLine(c("dim", `» resumed as ${newId}`));
 				target = newId;
 				finished.delete(newId);
 				seenHeader.delete(newId);
+				states.delete(newId);
+				ticker = initialFollowState("resumed");
 				lastEventAt = Date.now();
-				lastAction = "resumed";
 			} else noteLine(c("red", `» resume failed (rc=${rc})`));
 		});
 	};
-	const handleOperatorLine = (raw) => {
-		const text = raw.trim();
-		if (!text || target === null) return;
-		const id = target;
-		sayToWorker(logDir, id, text).then(() => noteLine(c("dim", `» sent to ${id}`)), (e) => {
-			if (loadStatuses(logDir).some((s) => s.id === id)) resumeTarget(text, id);
-			else noteLine(c("red", `» ${e.message}`));
-		});
-	};
+	const handleOperatorLine = makeOperatorInput({
+		target: () => target,
+		say: (id, text) => sayToWorker(logDir, id, text),
+		workerKnown: (id) => loadStatuses(logDir).some((s) => s.id === id),
+		resume: resumeTarget,
+		note: noteLine,
+		paint: c,
+		...chat ? { sent: () => void 0 } : {}
+	});
+	const terminalIn = in_.isTTY === true;
+	let hintUp = true;
 	let rlIn = null;
-	if (target !== null && process.stdin.isTTY) {
-		rlIn = createInterface({ input: process.stdin });
+	let onResize = null;
+	const echoed = /* @__PURE__ */ new Map();
+	const suppressMirror = (text) => {
+		const g = echoed.get(text);
+		if (!g || Date.now() > g.until) return false;
+		g.n -= 1;
+		if (g.n <= 0) echoed.delete(text);
+		return true;
+	};
+	const drawPrompt = () => {
+		if (!chat || terminalIn) return;
+		out_.write(chatPromptRow(rows, CHAT_PROMPT, hintUp ? c("dim", CHAT_HINT) : void 0));
+	};
+	if (chat) {
+		const echoOperator = (text) => {
+			const id = target;
+			if (id === null) return;
+			echoed.set(text, {
+				n: 1,
+				until: Date.now() + 1e4
+			});
+			const step = applyEvent(c, states.get(id) ?? initialFollowState(), {
+				type: "operator",
+				_ts: (/* @__PURE__ */ new Date()).toISOString(),
+				text
+			}, "", void 0, void 0, columns());
+			if (step.day) out(c("dim", `── ${step.day} ──`));
+			for (const ln of step.lines) out(ln);
+			states.set(id, step.state);
+		};
+		const handleChatLine = (raw) => {
+			hintUp = false;
+			const act = parseChatLine(raw);
+			switch (act.kind) {
+				case "message":
+					if (!act.text) break;
+					echoOperator(act.text);
+					handleOperatorLine(act.text);
+					break;
+				case "resume":
+					if (!act.text) {
+						out(c("dim", "usage: /resume <text>"));
+						break;
+					}
+					echoOperator(act.text);
+					if (target !== null) resumeTarget(act.text, target);
+					break;
+				case "help":
+					for (const ln of CHAT_HELP) out(c("dim", ln));
+					break;
+				case "status": {
+					const s = target !== null ? loadStatuses(logDir).find((x) => x.id === target) : void 0;
+					out(c("dim", s ? `${s.id} · ${s.state} · ${s.last}` : `${target ?? "?"} · no status`));
+					break;
+				}
+				case "quit":
+					aborted = true;
+					break;
+			}
+			drawPrompt();
+		};
+		rlIn = createInterface({
+			input: in_,
+			output: out_,
+			terminal: terminalIn
+		});
+		rlIn.on("line", handleChatLine);
+		rlIn.on("SIGINT", () => {
+			if ((rlIn?.line ?? "").trim() === "") aborted = true;
+			else rlIn?.write(null, {
+				ctrl: true,
+				name: "u"
+			});
+		});
+		rlIn.on("close", () => {
+			aborted = true;
+		});
+		out_.write(chatEnter(rows));
+		if (terminalIn) {
+			rlIn.setPrompt(CHAT_PROMPT);
+			rlIn.prompt();
+			out_.write(c("dim", CHAT_HINT));
+		} else drawPrompt();
+		onResize = () => {
+			if (typeof out_.rows === "number") rows = out_.rows;
+			fill = 0;
+			out_.write(chatScrollRegion(rows));
+			drawPrompt();
+		};
+		out_.on?.("resize", onResize);
+	} else if (target !== null && in_.isTTY) {
+		rlIn = createInterface({ input: in_ });
 		rlIn.on("line", handleOperatorLine);
 	}
+	/** The prompt's unsent text — a draft holds the auto-exit countdown. */
+	const promptText = () => io?.promptLine ? io.promptLine() : rlIn?.line ?? "";
 	try {
 		for (;;) {
 			if (aborted) return;
-			for (const wid of target ? [target] : runningIds()) {
+			const statuses = new Map(loadStatuses(logDir).map((s) => [s.id, s]));
+			const wanted = target ? [target] : runningIds();
+			for (const wid of wanted) {
 				if (handles.has(wid) || finished.has(wid)) continue;
 				const path = eventsPath(logDir, wid);
-				if (existsSync(path)) handles.set(wid, {
-					fd: openSync(path, "r"),
-					buf: ""
-				});
+				const st = statuses.get(wid) ?? {
+					id: wid,
+					label: "",
+					cwd: "",
+					provider: ""
+				};
+				if (existsSync(path)) {
+					const multi = target === null || handles.size > 0;
+					handles.set(wid, attachHandle(wid, path, st, multi));
+					states.set(wid, states.get(wid) ?? initialFollowState());
+				} else if (!seenHeader.has(wid)) {
+					out(headerLine(c, st));
+					seenHeader.add(wid);
+				}
 			}
-			const statuses = new Map(loadStatuses(logDir).map((s) => [s.id, s]));
 			const multi = handles.size > 1 || target === null;
 			let progressed = false;
 			for (const [wid, h] of [...handles.entries()]) {
@@ -2815,7 +3746,6 @@ async function followWorkers(logDir, target, showAll, autoExit, env = process.en
 					cwd: "",
 					provider: ""
 				};
-				const prefix = multi ? c("cyan", wid.slice(-4)) + c("dim", " ┃ ") : "  ";
 				const buffer = Buffer.alloc(65536);
 				for (;;) {
 					let n;
@@ -2830,42 +3760,20 @@ async function followWorkers(logDir, target, showAll, autoExit, env = process.en
 				const lines = h.buf.split("\n");
 				h.buf = lines.pop() ?? "";
 				for (const line of lines) {
-					progressed = true;
-					if (!seenHeader.has(wid)) {
-						eraseLiveness();
-						process.stdout.write(headerLine(c, st) + "\n");
-						seenHeader.add(wid);
-					}
 					if (!line.trim()) continue;
+					progressed = true;
 					let e;
 					try {
 						e = JSON.parse(line);
 					} catch {
 						continue;
 					}
-					const day = typeof e._ts === "string" ? e._ts.slice(0, 10) : "";
-					if (day && day !== lastDayBy.get(wid)) {
-						eraseLiveness();
-						process.stdout.write(`${multi ? prefix : ""}${c("dim", `── ${day} ──`)}\n`);
-						lastDayBy.set(wid, day);
-					}
-					collectTools(e, tools);
-					const g = gutterFor(c, e, multi ? c("cyan", wid.slice(-4)) : void 0);
-					eraseLiveness();
-					for (const ln of renderEvent(c, g ? "" : prefix, e, st.cwd ?? "", tools, g)) process.stdout.write(ln + "\n");
-					lastEventAt = Date.now();
-					if (e.type === "operator") lastAction = "operator message";
-					else if (e.type === "assistant") {
-						const tool = (e.message?.content ?? []).find((b) => b.type === "tool_use");
-						lastAction = tool ? `${tool.name ?? "?"} running` : "thinking";
-					} else if (e.type === "result") lastAction = "finished";
-					meterStatus = st;
-					if (e.type === "result") finished.add(wid);
+					emitEvent(e, wid, st, multi);
 				}
 				if (workerEnded(finished.has(wid), st.state, alive(st.pid))) {
 					if (!finished.has(wid)) {
 						eraseLiveness();
-						process.stdout.write(`${prefix}${c("red", "✗ " + (st.state || "ended"))} · ${st.last ?? ""}\n`);
+						out(`${multi ? c("cyan", wid.slice(-4)) + c("dim", " ┃ ") : "  "}${c("red", "✗ " + (st.state || "ended"))} · ${st.last ?? ""}`);
 						finished.add(wid);
 					}
 					closeSync(h.fd);
@@ -2875,14 +3783,19 @@ async function followWorkers(logDir, target, showAll, autoExit, env = process.en
 			const lingerOn = target;
 			if (lingerOn !== null && finished.has(lingerOn)) {
 				if (autoExit) {
+					if (holdAutoExit(promptText())) {
+						writeLiveness();
+						await sleep(250);
+						continue;
+					}
 					const until = Date.now() + autoExit * 1e3;
-					while (Date.now() < until && !aborted && target === lingerOn) {
+					while (Date.now() < until && !aborted && target === lingerOn && !holdAutoExit(promptText())) {
 						writeLiveness();
 						await sleep(250);
 					}
-					if (aborted || target !== lingerOn) continue;
+					if (aborted || target !== lingerOn || holdAutoExit(promptText())) continue;
 					eraseLiveness();
-					process.stdout.write(c("dim", "closing") + "\n");
+					out(c("dim", "closing"));
 					return;
 				}
 				if (rlIn === null) return;
@@ -2892,7 +3805,7 @@ async function followWorkers(logDir, target, showAll, autoExit, env = process.en
 				else if (idleSince === null) idleSince = Date.now();
 				else if (Date.now() - started >= 3e4 && Date.now() - idleSince >= autoExit * 1e3) {
 					eraseLiveness();
-					process.stdout.write(c("dim", "closing") + "\n");
+					out(c("dim", "closing"));
 					return;
 				}
 			}
@@ -2904,6 +3817,8 @@ async function followWorkers(logDir, target, showAll, autoExit, env = process.en
 	} finally {
 		rlIn?.close();
 		process.removeListener("SIGINT", onInt);
+		if (onResize) out_.removeListener?.("resize", onResize);
+		if (chat) out_.write(chatLeave(rows));
 		for (const h of handles.values()) try {
 			closeSync(h.fd);
 		} catch {}
@@ -2924,7 +3839,7 @@ function statusLineOutput(logDir, term, cwd, now = /* @__PURE__ */ new Date()) {
 //#endregion
 //#region src/workers/providers.ts
 /**
-* providers.ts — provider, role and switch management over the workers config.
+* providers.ts — provider, class and switch management over the workers config.
 *
 * One layer under both `pai worker providers …` and the MCP worker_providers
 * tool. Every mutation re-reads the config file, changes only the workers
@@ -2969,27 +3884,52 @@ function addProvider(input) {
 		...input.upstreamUrl ? { upstreamUrl: input.upstreamUrl } : {},
 		...input.engine && input.engine !== "claude" ? { engine: input.engine } : {},
 		...input.quotaProbe ? { quotaProbe: input.quotaProbe } : {},
-		...input.contextWindow ? { contextWindow: input.contextWindow } : {}
+		...input.contextWindow ? { contextWindow: input.contextWindow } : {},
+		...input.costTier ? { costTier: input.costTier } : {},
+		...input.tags?.length ? { tags: input.tags } : {}
 	};
 	workers.providers[input.name] = provider;
 	if (Object.keys(workers.providers).length === 1) {
 		workers.enabled = true;
 		workers.active = input.name;
 		workers.logDir = workers.logDir || DEFAULT_LOG_DIR;
-		workers.roles = {
+		const fast = input.fastModel ? `${input.name}/fast` : input.name;
+		workers.classes = {
+			draft: fast,
+			plan: input.name,
 			implement: input.name,
+			review: input.name,
 			research: input.name,
-			spotcheck: input.fastModel ? `${input.name}/fast` : input.name
+			spotcheck: fast,
+			simple: fast,
+			complex: input.name,
+			image: input.name
 		};
 	}
 	writeWorkersSection(raw, workers);
 	return workers;
 }
+/** Change costTier / tags on an existing provider (MCP action "update"). */
+function updateProvider(name, changes) {
+	const { raw, workers } = readWorkersSection();
+	const p = workers.providers[name];
+	if (!p) throw new WorkersConfigError(`no provider named "${name}". Configured: ${Object.keys(workers.providers).join(", ") || "(none)"}`);
+	if (changes.costTier !== void 0) {
+		if (!Number.isInteger(changes.costTier) || changes.costTier < 1 || changes.costTier > 5) throw new WorkersConfigError("costTier must be an integer 1 (cheapest) … 5 (most expensive)");
+		p.costTier = changes.costTier;
+	}
+	if (changes.tags !== void 0) {
+		for (const t of changes.tags) if (!PROVIDER_TAGS.includes(t)) throw new WorkersConfigError(`"${t}" is not a tag (from: ${PROVIDER_TAGS.join(", ")})`);
+		p.tags = changes.tags;
+	}
+	writeWorkersSection(raw, workers);
+	return workers;
+}
 function removeProvider(name) {
 	const { raw, workers } = readWorkersSection();
 	if (!workers.providers[name]) throw new WorkersConfigError(`no provider named "${name}"`);
 	delete workers.providers[name];
-	for (const [role, target] of Object.entries(workers.roles)) if ((typeof target === "string" ? target.split("/")[0] : target.provider) === name) delete workers.roles[role];
+	for (const [cls, target] of Object.entries(workers.classes)) if ((typeof target === "string" ? target.split("/")[0] : target.provider) === name) delete workers.classes[cls];
 	if (workers.active === name) workers.active = null;
 	writeWorkersSection(raw, workers);
 	return workers;
@@ -3010,21 +3950,30 @@ function setProviderEnabled(name, enabled) {
 	if (enabled) clearCooldown(workersLogDir(parseWorkersConfig(raw.workers)), name);
 	return workers;
 }
-function setRole(role, target) {
+/**
+* Point a class at a target ("provider", "provider/fast", or an object with
+* provider + optional mcp/maxCostTier/requireTags/order). An object without
+* a provider only constrains auto-routing for that class.
+*/
+function setClass(name, target) {
 	const { raw, workers } = readWorkersSection();
-	const [name, alias] = target.split("/");
-	const p = workers.providers[name];
-	if (!p) throw new WorkersConfigError(`no provider named "${name}" in "${target}". Configured: ${Object.keys(workers.providers).join(", ") || "(none)"}`);
-	if (alias && alias !== "default" && alias !== "fast") throw new WorkersConfigError(`unknown model alias "${alias}" — providers expose "default" and "fast"`);
-	if (alias === "fast" && !p.models.fast) throw new WorkersConfigError(`provider "${name}" has no fast model configured`);
-	workers.roles[role] = target;
+	if (typeof target === "string") {
+		const [provider, alias] = target.split("/");
+		const p = workers.providers[provider];
+		if (!p) throw new WorkersConfigError(`no provider named "${provider}" in "${target}". Configured: ${Object.keys(workers.providers).join(", ") || "(none)"}`);
+		if (alias && alias !== "default" && alias !== "fast") throw new WorkersConfigError(`unknown model alias "${alias}" — providers expose "default" and "fast"`);
+		if (alias === "fast" && !p.models.fast) throw new WorkersConfigError(`provider "${provider}" has no fast model configured`);
+	} else if (target.provider) {
+		if (!workers.providers[target.provider]) throw new WorkersConfigError(`no provider named "${target.provider}". Configured: ${Object.keys(workers.providers).join(", ") || "(none)"}`);
+	}
+	workers.classes[name] = target;
 	writeWorkersSection(raw, workers);
 	return workers;
 }
-function unsetRole(role) {
+function unsetClass(name) {
 	const { raw, workers } = readWorkersSection();
-	if (!(role in workers.roles)) throw new WorkersConfigError(`no role named "${role}"`);
-	delete workers.roles[role];
+	if (!(name in workers.classes)) throw new WorkersConfigError(`no class named "${name}"`);
+	delete workers.classes[name];
 	writeWorkersSection(raw, workers);
 	return workers;
 }
@@ -3034,6 +3983,17 @@ function setWorkersEnabled(enabled) {
 	writeWorkersSection(raw, workers);
 	return workers;
 }
+/** `glm/fast` | `{provider, mcp, …}` → one printable target line. */
+function classTargetText(target) {
+	if (typeof target === "string") return target;
+	return [
+		target.provider ?? "(routing)",
+		...target.mcp?.length ? [`mcp(${target.mcp.join(",")})`] : [],
+		...target.maxCostTier !== void 0 ? [`max tier ${target.maxCostTier}`] : [],
+		...target.requireTags?.length ? [`needs ${target.requireTags.join(",")}`] : [],
+		...target.order?.length ? [`order [${target.order.join(",")}]`] : []
+	].join(" ");
+}
 /** Human-readable provider listing (quota probe included when configured). */
 function describeProviders(workers) {
 	const lines = [];
@@ -3048,8 +4008,10 @@ function describeProviders(workers) {
 		const flags = [p.enabled ? "enabled" : "disabled", workers.active === name ? "active" : null].filter(Boolean);
 		const quota = p.quotaProbe ? probeQuota(p) : null;
 		const quotaNote = quota === null ? "" : `  quota ${quota}% (skip at ${quotaSkipThreshold(p)})`;
+		const tierTags = [`tier ${providerCostTier(p)}`, ...p.tags ?? []].join(", ");
 		lines.push(`${name}  [${flags.join(", ")}]  ${p.baseUrl}`);
 		lines.push(`    model ${p.models.default}${p.models.fast ? ` (fast: ${p.models.fast})` : ""}${quotaNote}`);
+		lines.push(`    ${tierTags}`);
 		if (p.keyFile) lines.push(`    key file ${expandHome(p.keyFile)}`);
 		else lines.push(`    no key file (token "local")`);
 		if (p.note) lines.push(`    ${p.note}`);
@@ -3058,10 +4020,12 @@ function describeProviders(workers) {
 	}
 	const setNames = Object.keys(workers.mcpSets);
 	if (setNames.length) lines.push(`mcp sets: ${setNames.map((s) => `${s}=[${workers.mcpSets[s].join(",")}]`).join("  ")}`);
+	const classNames = Object.keys(workers.classes);
+	if (classNames.length) lines.push(`classes: ${classNames.map((cl) => `${cl}=${classTargetText(workers.classes[cl])}`).join("  ")}`);
 	if (workers.active === "auto") lines.push(`routing: auto — order [${workers.routing.order.join(", ")}], cooldown ${workers.routing.cooldownMinutes}m`);
 	return lines;
 }
 
 //#endregion
-export { readJsonStrict as A, loadStatus as C, workersLogDir as D, ledgerPath as E, WorkersConfigError as O, openPaneForWorker as S, eventsPath as T, stopProxy as _, setRole as a, checkPaneForWorker as b, useProvider as c, replayOutput as d, statusLineOutput as f, ensureProxyRunning as g, DEFAULT_PROXY_PORT as h, setProviderEnabled as i, writeJsonAtomic as j, readWorkersSection as k, followWorkers as l, testProvider as m, describeProviders as n, setWorkersEnabled as o, runWorker as p, removeProvider as r, unsetRole as s, addProvider as t, psOutput as u, sayToWorker as v, ledgerSummary as w, openFollowPane as x, describeMcp as y };
-//# sourceMappingURL=providers-sXcK5bDZ.mjs.map
+export { ledgerPath as A, checkPaneForWorker as C, ledgerSummary as D, loadStatus as E, readJsonStrict as F, writeJsonAtomic as I, PROVIDER_TAGS as M, WorkersConfigError as N, parseRunnerArgs as O, readWorkersSection as P, describeMcp as S, openPaneForWorker as T, testProvider as _, setClass as a, stopProxy as b, unsetClass as c, followWorkers as d, psOutput as f, runWorker as g, runChain as h, removeProvider as i, workersLogDir as j, eventsPath as k, updateProvider as l, statusLineOutput as m, classTargetText as n, setProviderEnabled as o, replayOutput as p, describeProviders as r, setWorkersEnabled as s, addProvider as t, useProvider as u, DEFAULT_PROXY_PORT as v, openFollowPane as w, sayToWorker as x, ensureProxyRunning as y };
+//# sourceMappingURL=providers-DUshcB-d.mjs.map