@tekmidian/pai 0.37.0 → 0.39.0

package/dist/providers-FYkZjn_C.mjs

@@ -0,0 +1,1405 @@
+import { A as contextPercent, B as workersLogDir, C as quotaSkipThreshold, D as workerInScope, E as sessionTag, G as keysDir, H as PROVIDER_TAGS, J as readWorkersSection, K as parseWorkersConfig, L as shortText, M as loadStatuses, O as ageOf, R as eventsPath, S as probeQuota, T as resolveSession, U as WorkersConfigError, V as DEFAULT_LOG_DIR, W as expandHome, Y as writeWorkersSection, _ as workerDepth, d as renderReport, g as sayToWorker, h as readInbox, k as alive, q as providerCostTier, u as parseWorkerReport, w as currentTabKey, x as clearCooldown } from "./chain-CTtHligI.mjs";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, writeFileSync } from "node:fs";
+import { basename, relative } from "node:path";
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+
+//#region src/workers/chatui.ts
+/** 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-3). */
+function chatScrollRegion(rows) {
+	return `\x1b[1;${Math.max(1, rows - 3)}r`;
+}
+/** Clear the blank separator row between the transcript and the prompt. */
+function chatBlankRow(rows) {
+	return `\x1b[${Math.max(1, rows - 2)};1H\x1b[K`;
+}
+/**
+* Enter the chat layout: clear the pane, set the scroll region, blank the
+* separator row and park the cursor at column 3 of the prompt row (rows-1,
+* right after `› `). The ticker owns row `rows`.
+*/
+function chatEnter(rows) {
+	return "\x1B[2J" + chatScrollRegion(rows) + chatBlankRow(rows) + `\x1b[${Math.max(1, rows - 1)};3H`;
+}
+/** 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 and park the cursor back on the prompt
+* row at `parkCol` (default right after `› `): a ticker refresh never leaves
+* the cursor on the bottom row.
+*/
+function chatTickerRow(text, rows, parkCol = 3) {
+	return `7\x1b[${Math.max(1, rows)};1H\x1b[K` + text + `\x1b[${Math.max(1, rows - 1)};${Math.max(1, parkCol)}H`;
+}
+/**
+* The prompt row: the fixed `› ` prefix, then the input buffer — or, while
+* the buffer is empty, the dim placeholder behind the same prefix. The
+* cursor parks right after the buffer (`cursorAt` chars in, for a cursor
+* mid-draft), so typed text always starts at the column the placeholder
+* occupied, never glued to a hint.
+*/
+function chatPromptRow(rows, buffer = "", dim = (s) => s, cursorAt) {
+	const rowN = Math.max(1, rows - 1);
+	const body = buffer !== "" ? buffer : dim(CHAT_HINT);
+	const col = 3 + Math.max(0, Math.min(cursorAt ?? buffer.length, buffer.length));
+	return `\x1b[${rowN};1H\x1b[K› ` + body + `\x1b[${rowN};${col}H`;
+}
+/**
+* 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
+/**
+* render.ts — turn worker events into the lines a human reads.
+*
+* Ports the glm-ps transcript rendering: the gutter rules (dim `>` for reads
+* and searches, `$` for shell, magenta `~` + red/green diff for edits, green
+* `+` for writes), Read-result trimming (first 3 lines then a count), and the
+* result footer. Colors are applied only when the output is a TTY, so MCP
+* tool output stays plain text.
+*/
+const CODES = {
+	dim: "2",
+	bold: "1",
+	red: "31",
+	green: "32",
+	yellow: "33",
+	blue: "34",
+	mag: "35",
+	cyan: "36"
+};
+function makeColor(enabled) {
+	return (name, s) => enabled ? `\x1b[${CODES[name]}m${s}\x1b[0m` : s;
+}
+/** Path relative to cwd when it lies inside it, otherwise unchanged. */
+function relPath(path, cwd) {
+	if (!path || !cwd) return path;
+	let r;
+	try {
+		r = relative(cwd, path);
+	} catch {
+		return path;
+	}
+	return r.startsWith("..") ? path : r;
+}
+/** Minimal line diff for Edit previews: common prefix/suffix, one hunk. */
+function unifiedDiffLines(oldStr, newStr) {
+	const oldL = oldStr.split("\n");
+	const newL = newStr.split("\n");
+	let start = 0;
+	while (start < oldL.length && start < newL.length && oldL[start] === newL[start]) start++;
+	let endOld = oldL.length;
+	let endNew = newL.length;
+	while (endOld > start && endNew > start && oldL[endOld - 1] === newL[endNew - 1]) {
+		endOld--;
+		endNew--;
+	}
+	const out = [];
+	for (let i = start; i < endOld; i++) out.push("-" + oldL[i]);
+	for (let i = start; i < endNew; i++) out.push("+" + newL[i]);
+	return out;
+}
+/**
+* `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; 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, offMin) {
+	if (!e._ts) return null;
+	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),
+		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;
+}
+/** `4m12s` — the runtime shape the status row shows. */
+function fmtElapsed(secs) {
+	const s = Math.max(0, Math.floor(secs));
+	return `${Math.floor(s / 60)}m${String(s % 60).padStart(2, "0")}s`;
+}
+/**
+* The chat pane's status row (always visible while following):
+* `[glm/glm-5.3] ctx 84k/200k 42% · turns 12 · tools 7 · 4m12s · ⋯ 7s · <intent> · <tool>`
+* — context yellow past 70 %, red past 85 %, dropped when unknown; once the
+* worker finished, the ticker part is replaced by `✓ done` / `✗ failed`.
+*/
+function chatStatusRow(c, s) {
+	const parts = [];
+	const pct = contextPercent(s);
+	if (pct !== null) {
+		const label = `ctx ${fmtK(s.contextTokens ?? 0)}/${fmtK(s.contextWindow ?? 0)} ${pct}%`;
+		parts.push(pct > 85 ? c("red", label) : pct > 70 ? c("yellow", label) : label);
+	}
+	parts.push(`turns ${s.turns}`, `tools ${s.tools}`, fmtElapsed(s.elapsed));
+	if (s.state && s.state !== "running") parts.push(s.state === "done" ? c("green", "✓ done") : c("red", "✗ failed"));
+	else {
+		parts.push(`⋯ ${Math.max(0, Math.floor(s.idle ?? 0))}s`);
+		for (const p of [s.intent, s.tool]) if (p && p.trim()) parts.push(p.trim());
+	}
+	return `[${s.provider}/${s.model}] ${parts.join(" · ")}`;
+}
+/**
+* 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" || prev.type === "handoff";
+}
+/** 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);
+}
+/**
+* The context meter `ctx 84k/200k (42%)`, yellow from 70 %, red from 85 %.
+* null when the numbers are missing or below `minPct` (the table only shows
+* it past 60; the pane liveness line always shows it).
+*/
+function contextMeter(c, s, minPct = 0) {
+	const pct = contextPercent(s);
+	if (pct === null || pct <= minPct) return null;
+	const label = `ctx ${fmtK(s.contextTokens ?? 0)}/${fmtK(s.contextWindow ?? 0)} (${pct}%)`;
+	if (pct > 85) return c("red", label);
+	if (pct > 70) return c("yellow", label);
+	return label;
+}
+function renderToolUse(c, prefix, name, inp, cwd) {
+	const i = typeof inp === "object" && inp !== null ? inp : {};
+	const get = (k) => typeof i[k] === "string" ? i[k] : "";
+	if (name === "Read") return [`${prefix}${c("dim", ">")} Reading ${relPath(get("file_path"), cwd)}`];
+	if (name === "Grep" || name === "Glob") return [`${prefix}${c("dim", ">")} Searching ${c("cyan", get("pattern"))} in ${relPath(get("path") || ".", cwd)}`];
+	if (name === "Bash") return [`${prefix}${c("dim", "$")} ${shortText(get("command"), 160)}`];
+	if (name === "Edit") {
+		const out = [`${prefix}${c("mag", "~")} Editing ${relPath(get("file_path"), cwd)}`];
+		for (const line of unifiedDiffLines(get("old_string"), get("new_string"))) if (line.startsWith("-")) out.push(`${prefix}    ${c("red", line)}`);
+		else if (line.startsWith("+")) out.push(`${prefix}    ${c("green", line)}`);
+		else out.push(`${prefix}    ${c("dim", line)}`);
+		return out;
+	}
+	if (name === "Write") {
+		const n = get("content").split("\n").length;
+		return [`${prefix}${c("green", "+")} Writing ${relPath(get("file_path"), cwd)} (${n} lines)`];
+	}
+	if (name === "WebSearch" || name === "WebFetch") return [`${prefix}${c("dim", ">")} ${name} ${shortText(get("query") || get("url"), 100)}`];
+	return [`${prefix}${c("dim", ">")} ${name} ${shortText(JSON.stringify(i), 120)}`];
+}
+/** Render one stream-json event; `tools` maps tool_use_id → tool name. */
+function renderEvent(c, prefix, e, cwd, tools, gutter) {
+	const out = [];
+	if (e.type === "system" && e.subtype === "init") out.push(`${prefix}${c("dim", `worker started · model ${e.model ?? "?"} · cwd ${basename(e.cwd || cwd || "")}`)}`);
+	else if (e.type === "operator") {
+		if (e.handoff) return out;
+		for (const ln of String(e.text ?? "").split("\n")) out.push(`${prefix}${c("cyan", "» " + ln)}`);
+	} else if (e.type === "handoff") for (const ln of String(e.text ?? "").split("\n")) out.push(`${prefix}${c("mag", `◆ from ${e.from ?? "?"} · ${e.kind ?? "?"}: ${ln}`)}`);
+	else if (e.type === "assistant") {
+		for (const b of e.message?.content ?? []) if (b.type === "text" && (b.text ?? "").trim()) for (const ln of (b.text ?? "").trim().split("\n")) out.push(`${prefix}${ln}`);
+		else if (b.type === "tool_use") out.push(...renderToolUse(c, prefix, b.name ?? "?", b.input, cwd));
+	} else if (e.type === "user") for (const b of e.message?.content ?? []) {
+		if (b.type !== "tool_result") continue;
+		let content = b.content ?? "";
+		if (Array.isArray(content)) content = content.map((x) => typeof x === "object" && x !== null && "text" in x ? String(x.text ?? "") : "").join("\n");
+		const text = String(content);
+		const isError = b.is_error === true;
+		if (!isError && tools[b.tool_use_id ?? ""] === "Read") {
+			const lines = text.split("\n");
+			for (const ln of lines.slice(0, 3)) out.push(`${prefix}${c("dim", ln)}`);
+			if (lines.length > 3) out.push(`${prefix}${c("dim", `    … ${lines.length} lines`)}`);
+		} else if (isError) out.push(`${prefix}    ${c("red", "! " + shortText(text, 200))}`);
+		else if (text.trim()) out.push(`${prefix}    ${c("dim", shortText(text, 120))}`);
+	}
+	else if (e.type === "result") {
+		const mark = !e.is_error ? c("green", "✓ done") : c("red", "✗ failed");
+		out.push(`${prefix}${mark} · ${e.num_turns ?? "?"} turns · ${Math.floor((e.duration_ms ?? 0) / 1e3)}s`);
+		const report = parseWorkerReport(String(e.result ?? ""));
+		if (report) out.push(...renderReport(c, prefix, report, cwd));
+		else for (const ln of String(e.result ?? "").trim().split("\n")) out.push(`${prefix}  ${ln}`);
+	}
+	if (!gutter) return out;
+	return out.map((ln, i) => (i === 0 ? gutter.first : gutter.cont) + ln);
+}
+/** Transcript header: id, provider, label, session name, project dir. */
+function headerLine(c, s) {
+	const bits = [s.provider ? `[${s.provider}]` : "", sessionTag(s)].filter(Boolean).join(" ");
+	const sep = bits ? `  ${bits}` : "";
+	return c("bold", `━━ ${s.id}${sep}  ${s.label}  (${basename(s.cwd)})`);
+}
+/** The 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) as a forest: a worker whose parent
+* is another worker renders indented under it (`├`/`└` connectors); a parent
+* that is not a worker is a chain id and gets its old `chain <id>` header.
+* `⎇` marks an unmerged worktree branch, `◆N` an inbox with N handoffs.
+*/
+function renderTable(c, statuses, scopeLabel, now = /* @__PURE__ */ new Date(), inbox = {}) {
+	const running = [];
+	const done = [];
+	for (const s of statuses) if (s.state === "running" && alive(s.pid)) running.push(s);
+	else {
+		if (s.state === "running") s.state = "lost";
+		done.push(s);
+	}
+	const isWorker = (id) => statuses.some((s) => s.id === id);
+	const chainOf = (s) => s.parent && !isWorker(s.parent) ? s.parent : null;
+	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 rowPrefix = (depth, last) => depth <= 0 ? "  " : "  " + "│ ".repeat(depth - 1) + (last ? "└ " : "├ ");
+	const rowCont = (depth, last) => depth <= 0 ? "      " : "  " + "│ ".repeat(depth - 1) + (last ? "  " : "│ ");
+	const branchMark = (s) => s.branch && !s.merged ? "  " + c("yellow", "⎇" + (s.commits ? String(s.commits) : "")) : "";
+	const inboxMark = (s) => inbox[s.id] ? " " + c("mag", `◆${inbox[s.id]}`) : "";
+	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 (let i = 0; i < running.length; i++) {
+		const s = running[i];
+		const chain = chainOf(s);
+		if (chain) {
+			const prev = running[i - 1];
+			if (!prev || chainOf(prev) !== chain) {
+				const stages = running.filter((x) => chainOf(x) === chain);
+				lines.push(`  ${c("bold", `chain ${chain}`)}  ${chainLabelOf(stages)}`);
+			}
+		}
+		const last = !!chain && (i + 1 >= running.length || chainOf(running[i + 1]) !== chain);
+		const depth = workerDepth(statuses, s.id);
+		const subLast = !chain && (i + 1 >= running.length || running[i + 1].parent !== s.parent);
+		const meter = contextMeter(c, s, 60);
+		const p = chain ? "  " : rowPrefix(depth, subLast);
+		const q = chain ? "      " : rowCont(depth, subLast);
+		lines.push(treeLine(`${p}${c("cyan", s.id)}${inboxMark(s)} [${s.provider}]  ${ageOf(s.started, now).padStart(4)} old  turns ${String(s.turns).padStart(2)}  tools ${String(s.tools).padStart(2)}  ${basename(s.cwd)}${branchMark(s)}${meter ? "  " + meter : ""}`, chain, last));
+		lines.push(treeLine(`${q}task: ${s.label}`, chain, last));
+		lines.push(treeLine(`${q}now:  ${c("yellow", s.last)}  (${ageOf(s.updated, now)} ago)`, chain, last));
+	}
+	lines.push("");
+	lines.push(c("bold", "FINISHED (last 8)"));
+	const doneSlice = done.slice(-8);
+	for (let i = 0; i < doneSlice.length; i++) {
+		const s = doneSlice[i];
+		const chain = chainOf(s);
+		if (chain) {
+			const prev = doneSlice[i - 1];
+			if (!prev || chainOf(prev) !== chain) {
+				const stages = doneSlice.filter((x) => chainOf(x) === chain);
+				lines.push(`  ${c("bold", `chain ${chain}`)}  ${chainLabelOf(stages)}`);
+			}
+		}
+		const last = !!chain && (i + 1 >= doneSlice.length || chainOf(doneSlice[i + 1]) !== chain);
+		const depth = workerDepth(statuses, s.id);
+		const subLast = !chain && (i + 1 >= doneSlice.length || doneSlice[i + 1].parent !== s.parent);
+		const col = s.state === "done" ? "green" : "red";
+		const tag = sessionTag(s);
+		lines.push(treeLine(`${chain ? "  " : rowPrefix(depth, subLast)}${s.id}${inboxMark(s)} [${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)}${branchMark(s)}  ${s.label}`, chain, last));
+	}
+	lines.push("");
+	lines.push(c("dim", "worker follow        live transcript of running workers"));
+	lines.push(c("dim", "worker <id>          replay one worker"));
+	lines.push(c("dim", scopeLabel));
+	return lines.join("\n");
+}
+/**
+* One-line status-bar summary (same shape glm-ps --status printed). Sub-workers
+* render after their parent with a `↳` prefix (`all` carries the whole forest
+* so depth is right even when only some workers are this session's);
+* `◆N` marks an inbox with N handoffs.
+*/
+function renderStatusLine(mine, now = /* @__PURE__ */ new Date(), c = makeColor(true), all = mine, inbox = {}) {
+	if (!mine.length) return "";
+	const running = mine.filter((s) => s.state === "running" && alive(s.pid)).sort((a, b) => workerDepth(all, a.id) - workerDepth(all, b.id));
+	const today = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+	const doneToday = mine.filter((s) => s.state !== "running" && s.started.startsWith(today));
+	const ok = doneToday.filter((s) => s.state === "done").length;
+	const bad = doneToday.length - ok;
+	const providers = new Set(running.map((s) => s.provider));
+	let head = `${providers.size === 1 ? [...providers][0] : "workers"} ▶${running.length}`;
+	const parts = running.slice(0, 3).map((s) => {
+		const meter = contextMeter(c, s, 60);
+		const depth = workerDepth(all, s.id);
+		const lead = depth > 0 ? "  ".repeat(depth - 1) + "↳ " : "";
+		const box = inbox[s.id] ? ` ◆${inbox[s.id]}` : "";
+		return `${lead}${s.id.slice(-4)} ${s.label.slice(0, 26)} ${ageOf(s.started, now)} · ${s.last.slice(0, 30)}${box}` + (meter ? ` ${meter}` : "");
+	});
+	if (parts.length) head += "  " + parts.join(" | ");
+	if (doneToday.length) head += `   ✓${ok} ✗${bad} today`;
+	return head;
+}
+
+//#endregion
+//#region src/workers/viewer.ts
+/**
+* viewer.ts — ps / follow / replay / status line over the worker logDir.
+*
+* Scoping: workers launched from this terminal's AIBroker session (or, as the
+* fallback, its iTerm tab) unless --all or an explicit worker id is given.
+* Outside iTerm, everything degrades to "all workers" — the Python behaviour.
+*
+* Transcripts render with a `HH:MM:SS │ ` gutter (2g): dim, taken from the
+* `_ts` stamp on every mirrored event (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);
+	const scoped = showAll || !term ? statuses : statuses.filter((s) => workerInScope(s, term));
+	const scopeLabel = showAll || !term ? "scope: all workers" : resolveSession(term) ? `scope: session ${resolveSession(term).name}` : `scope: tab ${currentTabKey(env)} (this iTerm tab)`;
+	const inbox = inboxCounts(logDir, scoped);
+	return renderTable(c, scoped, scopeLabel, /* @__PURE__ */ new Date(), inbox);
+}
+/** Handoffs waiting in each listed worker's inbox: id → count. */
+function inboxCounts(logDir, statuses) {
+	const out = {};
+	for (const s of statuses) {
+		const n = readInbox(logDir, s.id).length;
+		if (n) out[s.id] = n;
+	}
+	return out;
+}
+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);
+	if (!existsSync(path)) throw new Error(`no event log for ${wid}`);
+	const c = makeColor(color);
+	const st = loadStatuses(logDir).find((s) => s.id === wid) ?? {
+		id: wid,
+		label: "",
+		cwd: "",
+		provider: ""
+	};
+	const wrapWidth = typeof process.stdout.columns === "number" ? process.stdout.columns : null;
+	const out = [headerLine(c, st)];
+	const raw = readFileSync(path, "utf8");
+	const lines = tailLines !== void 0 ? raw.split("\n").slice(-tailLines) : raw.split("\n");
+	const handoffs = readInbox(logDir, wid).map((h) => ({
+		type: "handoff",
+		from: h.from,
+		kind: h.kind,
+		text: h.text,
+		_ts: h._ts
+	}));
+	let state = initialFollowState("");
+	const events = [];
+	for (const line of lines) {
+		if (!line.trim()) continue;
+		let e;
+		try {
+			e = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		events.push(e);
+	}
+	const stamp = (e) => {
+		const t = e._ts ? Date.parse(e._ts) : NaN;
+		return Number.isNaN(t) ? 0 : t;
+	};
+	const merged = [...events, ...handoffs].sort((a, b) => stamp(a) - stamp(b));
+	for (const e of merged) {
+		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");
+}
+/**
+* The follow exit decision for one worker: it is over once its result event
+* was rendered, or once its status left "running" while its pid is gone — a
+* worker killed without writing a result still ends. A status never read
+* (undefined) means "not over": follow keeps waiting for the first event.
+*/
+function workerEnded(resultRendered, state, pidAlive) {
+	return resultRendered || state !== void 0 && state !== "running" && !pidAlive;
+}
+/**
+* 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.
+* 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, io) {
+	const c = makeColor(color);
+	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 handles = /* @__PURE__ */ new Map();
+	const seenHeader = /* @__PURE__ */ new Set();
+	const finished = /* @__PURE__ */ new Set();
+	const inboxSeen = /* @__PURE__ */ new Map();
+	const states = /* @__PURE__ */ new Map();
+	const started = Date.now();
+	let idleSince = null;
+	let aborted = false;
+	let lastEventAt = Date.now();
+	let meterStatus = null;
+	const onInt = () => {
+		aborted = true;
+	};
+	process.once("SIGINT", onInt);
+	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 - 3);
+	/** 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 statusRowOf = (st, secs) => {
+		const fin = finished.has(st.id);
+		const startedAt = Date.parse((st.started ?? "").replace(" ", "T"));
+		const elapsed = fin && st.secs !== null ? st.secs : Number.isNaN(startedAt) ? 0 : Math.floor((Date.now() - startedAt) / 1e3);
+		return {
+			provider: st.provider,
+			model: st.model,
+			contextTokens: st.contextTokens,
+			contextWindow: st.contextWindow,
+			turns: st.turns,
+			tools: st.tools,
+			elapsed,
+			idle: secs,
+			intent: ticker.intent,
+			tool: ticker.tool,
+			state: fin ? st.state === "running" ? "done" : st.state : null
+		};
+	};
+	const writeLiveness = () => {
+		if (!tty) return;
+		const secs = Math.max(0, Math.floor((Date.now() - lastEventAt) / 1e3));
+		if (chat) {
+			const text = meterStatus ? chatStatusRow(c, statusRowOf(meterStatus, secs)) : tickerText(secs, ticker.intent, ticker.tool);
+			out_.write(chatTickerRow(text, rows, promptCursorCol()));
+		} else {
+			const meter = meterStatus ? contextMeter(c, meterStatus) : null;
+			out_.write("\r\x1B[K");
+			out_.write(tickerText(secs, ticker.intent, ticker.tool, meter));
+		}
+	};
+	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();
+		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 = 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 && /^\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();
+			} else noteLine(c("red", `» resume failed (rc=${rc})`));
+		});
+	};
+	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 rlIn = null;
+	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;
+	};
+	/** Column the prompt row's cursor parks at: right after the draft's cursor. */
+	const promptCursorCol = () => {
+		const line = rlIn?.line ?? "";
+		const cur = rlIn?.cursor;
+		return 3 + Math.max(0, Math.min(typeof cur === "number" ? cur : line.length, line.length));
+	};
+	/**
+	* The pane owns the prompt row's rendering: `› `, the buffer — or the dim
+	* placeholder while the buffer is empty — and the cursor parked after it.
+	*/
+	const drawPrompt = () => {
+		if (!chat) return;
+		const line = rlIn?.line ?? "";
+		const cur = rlIn?.cursor;
+		out_.write(chatPromptRow(rows, line, (s) => c("dim", s), cur));
+	};
+	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) => {
+			const act = parseChatLine(raw);
+			let redrew = false;
+			switch (act.kind) {
+				case "message":
+					if (!act.text) break;
+					handleOperatorLine(act.text);
+					drawPrompt();
+					redrew = true;
+					echoOperator(act.text);
+					break;
+				case "resume":
+					if (!act.text) {
+						out(c("dim", "usage: /resume <text>"));
+						break;
+					}
+					if (target !== null) resumeTarget(act.text, target);
+					drawPrompt();
+					redrew = true;
+					echoOperator(act.text);
+					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;
+			}
+			if (!redrew) drawPrompt();
+		};
+		rlIn = createInterface({
+			input: in_,
+			output: { write: () => true },
+			terminal: terminalIn
+		});
+		rlIn.on("line", handleChatLine);
+		rlIn.on("SIGINT", () => {
+			if ((rlIn?.line ?? "").trim() === "") aborted = true;
+			else {
+				rlIn?.write(null, {
+					ctrl: true,
+					name: "u"
+				});
+				drawPrompt();
+			}
+		});
+		rlIn.on("close", () => {
+			aborted = true;
+		});
+		out_.write(chatEnter(rows));
+		drawPrompt();
+		if (terminalIn) in_.on("keypress", () => drawPrompt());
+		onResize = () => {
+			if (typeof out_.rows === "number") rows = out_.rows;
+			fill = 0;
+			out_.write(chatScrollRegion(rows) + chatBlankRow(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;
+			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);
+				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 multi = handles.size > 1 || target === null;
+			let progressed = false;
+			for (const [wid, h] of [...handles.entries()]) {
+				const st = statuses.get(wid) ?? {
+					id: wid,
+					label: "",
+					cwd: "",
+					provider: ""
+				};
+				const buffer = Buffer.alloc(65536);
+				for (;;) {
+					let n;
+					try {
+						n = readSync(h.fd, buffer, 0, buffer.length, null);
+					} catch {
+						n = 0;
+					}
+					if (n <= 0) break;
+					h.buf += buffer.toString("utf8", 0, n);
+				}
+				const lines = h.buf.split("\n");
+				h.buf = lines.pop() ?? "";
+				for (const line of lines) {
+					if (!line.trim()) continue;
+					progressed = true;
+					let e;
+					try {
+						e = JSON.parse(line);
+					} catch {
+						continue;
+					}
+					emitEvent(e, wid, st, multi);
+				}
+				if (workerEnded(finished.has(wid), st.state, alive(st.pid))) {
+					if (!finished.has(wid)) {
+						eraseLiveness();
+						out(`${multi ? c("cyan", wid.slice(-4)) + c("dim", " ┃ ") : "  "}${c("red", "✗ " + (st.state || "ended"))} · ${st.last ?? ""}`);
+						finished.add(wid);
+					}
+					closeSync(h.fd);
+					handles.delete(wid);
+				}
+			}
+			for (const wid of [...handles.keys()]) {
+				const st = statuses.get(wid) ?? {
+					id: wid,
+					label: "",
+					cwd: "",
+					provider: ""
+				};
+				const msgs = readInbox(logDir, wid);
+				const seenN = inboxSeen.get(wid) ?? 0;
+				if (msgs.length > seenN) {
+					for (const m of msgs.slice(seenN)) emitEvent({
+						type: "handoff",
+						from: m.from,
+						kind: m.kind,
+						text: m.text,
+						_ts: m._ts
+					}, wid, st, multi);
+					inboxSeen.set(wid, msgs.length);
+					progressed = true;
+				}
+			}
+			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 && !holdAutoExit(promptText())) {
+						writeLiveness();
+						await sleep(250);
+					}
+					if (aborted || target !== lingerOn || holdAutoExit(promptText())) continue;
+					eraseLiveness();
+					out(c("dim", "closing"));
+					return;
+				}
+				if (rlIn === null) return;
+			}
+			if (autoExit && !target) {
+				if (runningIds().length) idleSince = null;
+				else if (idleSince === null) idleSince = Date.now();
+				else if (Date.now() - started >= 3e4 && Date.now() - idleSince >= autoExit * 1e3) {
+					eraseLiveness();
+					out(c("dim", "closing"));
+					return;
+				}
+			}
+			if (!progressed) {
+				writeLiveness();
+				await sleep(500);
+			}
+		}
+	} 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 {}
+	}
+}
+function sleep(ms) {
+	return new Promise((r) => setTimeout(r, ms));
+}
+/** Workers of this terminal for the status bar; "" when there are none. */
+function statusLineOutput(logDir, term, cwd, now = /* @__PURE__ */ new Date()) {
+	const statuses = loadStatuses(logDir);
+	const mine = statuses.filter((s) => {
+		const sameScope = term && workerInScope(s, term);
+		const sameDir = cwd && s.cwd.startsWith(cwd);
+		return sameScope || !term && sameDir;
+	});
+	return renderStatusLine(mine, now, makeColor(false), statuses, inboxCounts(logDir, mine));
+}
+
+//#endregion
+//#region src/workers/providers.ts
+/**
+* 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
+* section, and writes it back atomically — the file is shared with everything
+* else PAI runs, so a torn write is not an option.
+*
+* Keys are never stored in the config and never accepted inline from the CLI:
+* only file paths. (The MCP `add` tool additionally accepts a raw `key`, which
+* it immediately parks in ~/.config/pai/keys/<name>, mode 0600, storing only
+* the path — a chat is not a place to leave a credential lying around.)
+*/
+function addProvider(input) {
+	if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(input.name)) throw new WorkersConfigError(`provider name "${input.name}" may only contain letters, digits, - and _`);
+	if (input.protocol === "openai" && !input.upstreamUrl) throw new WorkersConfigError("protocol \"openai\" needs the upstreamUrl (the Chat Completions base, e.g. \"https://api.openai.com/v1\") — the PAI proxy translates to it.");
+	if (!input.baseUrl && input.protocol !== "openai") throw new WorkersConfigError("baseUrl is required");
+	let keyFile = input.keyFile ?? null;
+	if (input.key !== void 0) {
+		const dir = keysDir();
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		const path = `${dir}/${input.name}`;
+		writeFileSync(path, input.key.trim() + "\n", {
+			encoding: "utf8",
+			mode: 384
+		});
+		try {
+			chmodSync(path, 384);
+		} catch {}
+		keyFile = path;
+	}
+	const { raw, workers } = readWorkersSection();
+	const provider = {
+		enabled: true,
+		protocol: input.protocol ?? "anthropic",
+		baseUrl: input.baseUrl,
+		keyFile,
+		models: input.fastModel ? {
+			default: input.model,
+			fast: input.fastModel
+		} : { default: input.model },
+		env: input.env ?? {},
+		...input.note ? { note: input.note } : {},
+		...input.upstreamUrl ? { upstreamUrl: input.upstreamUrl } : {},
+		...input.engine && input.engine !== "claude" ? { engine: input.engine } : {},
+		...input.quotaProbe ? { quotaProbe: input.quotaProbe } : {},
+		...input.contextWindow ? { contextWindow: input.contextWindow } : {},
+		...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;
+		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: 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 [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;
+}
+function useProvider(name) {
+	const { raw, workers } = readWorkersSection();
+	if (!workers.providers[name]) throw new WorkersConfigError(`no provider named "${name}". Configured: ${Object.keys(workers.providers).join(", ") || "(none)"}`);
+	workers.active = name;
+	writeWorkersSection(raw, workers);
+	return workers;
+}
+function setProviderEnabled(name, enabled) {
+	const { raw, workers } = readWorkersSection();
+	const p = workers.providers[name];
+	if (!p) throw new WorkersConfigError(`no provider named "${name}"`);
+	p.enabled = enabled;
+	writeWorkersSection(raw, workers);
+	if (enabled) clearCooldown(workersLogDir(parseWorkersConfig(raw.workers)), name);
+	return workers;
+}
+/**
+* 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();
+	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 unsetClass(name) {
+	const { raw, workers } = readWorkersSection();
+	if (!(name in workers.classes)) throw new WorkersConfigError(`no class named "${name}"`);
+	delete workers.classes[name];
+	writeWorkersSection(raw, workers);
+	return workers;
+}
+function setWorkersEnabled(enabled) {
+	const { raw, workers } = readWorkersSection();
+	workers.enabled = 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 = [];
+	const names = Object.keys(workers.providers);
+	if (!names.length) {
+		lines.push(`no providers configured. Add one with:`);
+		lines.push(`  pai worker providers add <name> --base-url <url> --key-file <path> --model <model>`);
+		return lines;
+	}
+	for (const name of names) {
+		const p = workers.providers[name];
+		const flags = [p.enabled ? "enabled" : "disabled", workers.active === name ? "active" : null].filter(Boolean);
+		const quota = p.quotaProbe ? probeQuota(p) : null;
+		const quotaNote = quota === null ? "" : `  quota ${quota}% (skip at ${quotaSkipThreshold(p)})`;
+		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}`);
+		if (p.protocol === "openai") lines.push(`    via PAI proxy ← ${p.upstreamUrl ?? "(upstreamUrl missing)"}`);
+		if (p.engine === "codex") lines.push(`    engine codex (runs through the Codex CLI)`);
+	}
+	const setNames = Object.keys(workers.mcpSets);
+	if (setNames.length) lines.push(`mcp sets: ${setNames.map((s) => `${s}=[${workers.mcpSets[s].join(",")}]`).join("  ")}`);
+	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 { setClass as a, unsetClass as c, followWorkers as d, psOutput as f, removeProvider as i, 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 };
+//# sourceMappingURL=providers-FYkZjn_C.mjs.map