@tekmidian/pai 0.39.0 → 0.40.0

package/dist/{providers-FYkZjn_C.mjs → fallback-CdXv-Np0.mjs}

@@ -1,7 +1,10 @@
-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 { a as WorkersConfigError, b as readJsonStrict, c as expandHome, d as parseWorkersConfig, f as providerCostTier, g as writeWorkersSection, h as resolveModelCapability, l as isModelCapability, m as readWorkersSection, n as MODEL_CAPABILITIES, p as providerKeyPath, r as PROVIDER_TAGS, t as DEFAULT_LOG_DIR, u as keysDir, x as writeJsonAtomic } from "./config-Dl8lT4Lu.mjs";
+import { _ as workersLogDir, a as clearCooldown, c as probeQuota, f as eventsPath, l as quotaSkipThreshold, u as resolveTarget } from "./server-BOuAOj9b.mjs";
+import { C as ageOf, E as contextPercent, N as shortText, O as loadStatuses, S as UNLABELED, T as contextLabel, b as sessionTag, c as renderReport, f as readInbox, m as workerDepth, p as sayToWorker, s as parseWorkerReport, v as currentTabKey, w as alive, x as workerInScope, y as resolveSession } from "./chain-DhVHVnmT.mjs";
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, relative } from "node:path";
+import { execFileSync, spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 
 //#region src/workers/chatui.ts
@@ -158,17 +161,23 @@ function wrapText(text, width) {
 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`;
+/**
+* The separator row between the transcript and the prompt: cleared, then —
+* when the pane's width is known — a dim rule of `cols` box-drawing `─`
+* filling the row. `cols` 0 (unknown) keeps the row blank; `dim` is the
+* pane's colour helper, identity when colours are off.
+*/
+function chatBlankRow(rows, cols = 0, dim = (s) => s) {
+	const rule = cols > 0 ? dim("─".repeat(cols)) : "";
+	return `\x1b[${Math.max(1, rows - 2)};1H\x1b[K` + rule;
 }
 /**
-* Enter the chat layout: clear the pane, set the scroll region, blank the
+* Enter the chat layout: clear the pane, set the scroll region, draw 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`;
+function chatEnter(rows, cols = 0, dim = (s) => s) {
+	return "\x1B[2J" + chatScrollRegion(rows) + chatBlankRow(rows, cols, dim) + `\x1b[${Math.max(1, rows - 1)};3H`;
 }
 /** Leave it: reset the scroll region, show the cursor, drop to the last row. */
 function chatLeave(rows) {
@@ -358,7 +367,7 @@ function fmtElapsed(secs) {
 }
 /**
 * 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>`
+* `[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`.
 */
@@ -366,7 +375,7 @@ 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}%`;
+		const label = contextLabel(s);
 		parts.push(pct > 85 ? c("red", label) : pct > 70 ? c("yellow", label) : label);
 	}
 	parts.push(`turns ${s.turns}`, `tools ${s.tools}`, fmtElapsed(s.elapsed));
@@ -392,19 +401,16 @@ function blankBetween(prev, e) {
 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).
+* The context meter `ctx 84k/200k (42%)` (contextLabel, shared with the
+* chat status row), 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}%)`;
+	const label = contextLabel(s);
 	if (pct > 85) return c("red", label);
 	if (pct > 70) return c("yellow", label);
 	return label;
@@ -552,28 +558,49 @@ function renderTable(c, statuses, scopeLabel, now = /* @__PURE__ */ new Date(),
 	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.
+* The step of a statusline row: what the worker is doing as a verb, never a
+* raw command. A Bash line trims to its first word (`grep -n -A4 "x" src/` →
+* `grep …` — no `Bash:` prefix, no flags, no quotes); the file tools keep
+* their `Edit: button.ts` shape; free text (what the worker last said) is
+* only shortened. Always ≤ 24 chars.
+*/
+function stepOf(last) {
+	const s = String(last ?? "").trim();
+	if (s.startsWith("Bash: ")) {
+		const cmd = s.slice(6).trim();
+		const verb = cmd.split(/\s+/)[0] ?? "";
+		return shortText(cmd.length > verb.length ? `${verb} …` : verb, 24);
+	}
+	return shortText(s, 24);
+}
+/**
+* The statusline bar: `provider ▶N` then one row per running spawned worker —
+* `name · age · step` — and today's ✓/✗ tail. The chat pane contributes
+* nothing but its provider: its age, state and inbox live in `pai worker ps`,
+* not here. Rows are flat (the ↳ depth is ps territory) and oldest first;
+* `#id` joins a name only when two running workers share one label, so ids
+* stay rare enough to read.
 */
-function renderStatusLine(mine, now = /* @__PURE__ */ new Date(), c = makeColor(true), all = mine, inbox = {}) {
+function renderStatusLine(mine, now = /* @__PURE__ */ new Date()) {
 	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 isChat = (s) => s.origin === "chat" || !s.origin && (s.label === UNLABELED || s.label === "(no prompt)") && s.turns === 0;
+	const chat = mine.find((s) => isChat(s) && s.state === "running" && alive(s.pid));
+	const running = mine.filter((s) => !isChat(s) && s.state === "running" && alive(s.pid)).sort((a, b) => a.started.localeCompare(b.started));
 	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}` : "");
+	const rows = running.slice(0, 3).map((s) => {
+		return `${`${running.some((o) => o !== s && o.label === s.label) ? `#${s.id.slice(-4)} ` : ""}${s.label.slice(0, 26)}`} · ${ageOf(s.started, now)} · ${stepOf(s.last)}`;
 	});
-	if (parts.length) head += "  " + parts.join(" | ");
+	let head;
+	if (chat) head = chat.provider;
+	else {
+		const providers = new Set(running.map((s) => s.provider));
+		head = providers.size === 1 ? [...providers][0] : "workers";
+	}
+	if (running.length) head += ` ▶${running.length}`;
+	if (rows.length) head += " | " + rows.join(" | ");
 	if (doneToday.length) head += `   ✓${ok} ✗${bad} today`;
 	return head;
 }
@@ -676,7 +703,7 @@ function applyEvent(c, s, e, cwd, tag, offMin, wrapWidth) {
 	}
 	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;
+	const lines = blankBetween(s.prev, e) ? [gutter ? gutter.barCont : "", ...body] : body;
 	return {
 		lines,
 		day: day && day !== s.lastDay ? day : null,
@@ -807,13 +834,19 @@ async function followWorkers(logDir, target, showAll, autoExit, env = process.en
 	const columns = () => typeof out_.columns === "number" ? out_.columns : null;
 	let fill = 0;
 	const regionRows = () => Math.max(1, rows - 3);
+	const retained = [];
+	const RETAIN_CAP = 500;
 	/** 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) => {
+	const out = (line, keep = true) => {
 		if (!chat) {
 			out_.write(line + "\n");
 			return;
 		}
+		if (keep) {
+			retained.push(line);
+			if (retained.length > RETAIN_CAP) retained.splice(0, retained.length - RETAIN_CAP);
+		}
 		const r = chatInsertLine(line, fill, regionRows());
 		out_.write(r.seq);
 		fill = r.fill;
@@ -1030,9 +1063,17 @@ async function followWorkers(logDir, target, showAll, autoExit, env = process.en
 			}
 			if (!redrew) drawPrompt();
 		};
+		const silent = {
+			write: () => true,
+			on: () => silent,
+			once: () => silent,
+			off: () => silent,
+			removeListener: () => silent,
+			emit: () => false
+		};
 		rlIn = createInterface({
 			input: in_,
-			output: { write: () => true },
+			output: silent,
 			terminal: terminalIn
 		});
 		rlIn.on("line", handleChatLine);
@@ -1049,13 +1090,14 @@ async function followWorkers(logDir, target, showAll, autoExit, env = process.en
 		rlIn.on("close", () => {
 			aborted = true;
 		});
-		out_.write(chatEnter(rows));
+		out_.write(chatEnter(rows, columns() ?? 0, (s) => c("dim", s)));
 		drawPrompt();
 		if (terminalIn) in_.on("keypress", () => drawPrompt());
 		onResize = () => {
 			if (typeof out_.rows === "number") rows = out_.rows;
 			fill = 0;
-			out_.write(chatScrollRegion(rows) + chatBlankRow(rows));
+			out_.write("\x1B[2J" + chatScrollRegion(rows) + chatBlankRow(rows, columns() ?? 0, (s) => c("dim", s)));
+			for (const ln of retained.slice(-regionRows())) out(ln, false);
 			drawPrompt();
 		};
 		out_.on?.("resize", onResize);
@@ -1200,14 +1242,13 @@ 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) => {
+function statusLineOutput(logDir, term, cwd, claudeSession = "", now = /* @__PURE__ */ new Date()) {
+	return renderStatusLine(loadStatuses(logDir).filter((s) => {
 		const sameScope = term && workerInScope(s, term);
+		const spawnedHere = claudeSession && s.spawnerSession === claudeSession;
 		const sameDir = cwd && s.cwd.startsWith(cwd);
-		return sameScope || !term && sameDir;
-	});
-	return renderStatusLine(mine, now, makeColor(false), statuses, inboxCounts(logDir, mine));
+		return sameScope || spawnedHere || !term && sameDir;
+	}), now);
 }
 
 //#endregion
@@ -1315,6 +1356,32 @@ function useProvider(name) {
 	writeWorkersSection(raw, workers);
 	return workers;
 }
+/**
+* The provider a model command targets: the named one, else the active one.
+* "auto" and an unset active both ask for an explicit name.
+*/
+function resolveProviderName(workers, name) {
+	const target = name ?? workers.active ?? "";
+	if (workers.providers[target]) return target;
+	if (!target) throw new WorkersConfigError("no active provider — name one explicitly");
+	if (target === "auto") throw new WorkersConfigError("active is \"auto\" — name a provider explicitly");
+	throw new WorkersConfigError(`no provider named "${target}". Configured: ${Object.keys(workers.providers).join(", ") || "(none)"}`);
+}
+/**
+* Set a provider's model id for a capability — default, fast, image, …
+* (`pai worker model`, MCP worker_model).
+*/
+function setProviderModel(name, capability, model, configPath) {
+	if (!isModelCapability(capability)) throw new WorkersConfigError(`"${capability}" is not a model capability (from: ${MODEL_CAPABILITIES.join(", ")})`);
+	const id = model.trim();
+	if (!id) throw new WorkersConfigError(`a ${capability} model id must not be empty`);
+	const { raw, workers } = readWorkersSection(configPath);
+	const p = workers.providers[name];
+	if (!p) throw new WorkersConfigError(`no provider named "${name}". Configured: ${Object.keys(workers.providers).join(", ") || "(none)"}`);
+	p.models[capability] = id;
+	writeWorkersSection(raw, workers, configPath);
+	return workers;
+}
 function setProviderEnabled(name, enabled) {
 	const { raw, workers } = readWorkersSection();
 	const p = workers.providers[name];
@@ -1335,8 +1402,10 @@ function setClass(name, target) {
 		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`);
+		if (alias) {
+			if (!isModelCapability(alias)) throw new WorkersConfigError(`unknown model alias "${alias}" — providers expose: ${MODEL_CAPABILITIES.join(", ")}`);
+			if (alias !== "default" && !p.models[alias]) throw new WorkersConfigError(`provider "${provider}" has no ${alias} 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)"}`);
 	}
@@ -1368,6 +1437,28 @@ function classTargetText(target) {
 		...target.order?.length ? [`order [${target.order.join(",")}]`] : []
 	].join(" ");
 }
+/**
+* `default X  fast Y  image Z` — every model capability on one line, unset
+* ones shown as "(none)" (they resolve to the default model).
+*/
+function modelPrefsText(p) {
+	return MODEL_CAPABILITIES.map((c) => `${c} ${p.models[c] ?? "(none)"}`).join("  ");
+}
+/**
+* Compact model listing for `pai worker model` / worker_model get: the active
+* provider, then one line per provider with all its capability preferences.
+*/
+function describeModels(workers) {
+	const names = Object.keys(workers.providers);
+	if (!names.length) return ["no providers configured — add one with `pai worker providers add <name> …`"];
+	const lines = [`active provider: ${workers.active ?? "(none)"}`];
+	for (const name of names) {
+		const p = workers.providers[name];
+		const active = workers.active === name ? "  [active]" : "";
+		lines.push(`${name}${active}  ${modelPrefsText(p)}`);
+	}
+	return lines;
+}
 /** Human-readable provider listing (quota probe included when configured). */
 function describeProviders(workers) {
 	const lines = [];
@@ -1384,7 +1475,7 @@ function describeProviders(workers) {
 		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(`    ${modelPrefsText(p)}${quotaNote}`);
 		lines.push(`    ${tierTags}`);
 		if (p.keyFile) lines.push(`    key file ${expandHome(p.keyFile)}`);
 		else lines.push(`    no key file (token "local")`);
@@ -1401,5 +1492,274 @@ function describeProviders(workers) {
 }
 
 //#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
+//#region src/workers/fallback.ts
+/**
+* fallback.ts — machine-wide Claude Code fallback to a worker provider.
+*
+* When the Anthropic plan runs out, `pai worker fallback on <provider>`
+* points EVERY new Claude Code process on this machine at that provider:
+* interactive sessions, task-bus sessions, the daemon's headless summarizer.
+* It writes the provider's base URL, token (read from its key file at switch
+* time — so the token then sits in settings.json until `off`), the three
+* DEFAULT_*_MODEL pins, its extra env (API_TIMEOUT_MS …) plus tool search on
+* and nonessential traffic off into the `env` block of ~/.claude/settings.json,
+* and pins the top-level `model` to the provider's default model.
+*
+* What settings.json carried before the switch is saved under
+* `workers.fallback.saved` in ~/.config/pai/config.json; `fallback off`
+* restores it exactly and removes the added keys. Both files are written
+* atomically; nothing else in them is touched. While fallback is on the
+* Agent hook keeps routing subagents to workers, unchanged — those runs set
+* their own env per provider and are unaffected.
+*
+* Running Claude Code processes keep the provider they started with until
+* restarted; `fallback status` lists them and points at the note `on` leaves
+* in the workers log dir (FALLBACK-ACTIVE.md).
+*
+* CLAUDE_SETTINGS_PATH overrides the settings.json location (dry runs against
+* a copy); the config path is injectable for tests the same way.
+*/
+/** settings.json location; CLAUDE_SETTINGS_PATH points it at a copy for dry runs. */
+function fallbackSettingsPath() {
+	return process.env.CLAUDE_SETTINGS_PATH ?? join(homedir(), ".claude", "settings.json");
+}
+/** The note `on` writes so a human landing in the log dir sees the switch. */
+function fallbackNotePath(logDir) {
+	return join(logDir, "FALLBACK-ACTIVE.md");
+}
+/**
+* The env block fallback writes: the provider's endpoint and token, model
+* pins (fast model as haiku, default as sonnet and opus — the same mapping
+* buildRunEnv uses), the provider's own env, and the two fallback constants.
+*/
+function fallbackEnv(provider) {
+	let token = "local";
+	const keyPath = providerKeyPath(provider);
+	if (keyPath) {
+		token = readFileSync(keyPath, "utf8").trim();
+		if (!token) throw new WorkersConfigError(`key file is empty: ${keyPath}`);
+	}
+	return {
+		ANTHROPIC_BASE_URL: provider.baseUrl,
+		ANTHROPIC_AUTH_TOKEN: token,
+		ANTHROPIC_DEFAULT_OPUS_MODEL: provider.models.default,
+		ANTHROPIC_DEFAULT_SONNET_MODEL: provider.models.default,
+		ANTHROPIC_DEFAULT_HAIKU_MODEL: resolveModelCapability(provider, "fast"),
+		...provider.env,
+		ENABLE_TOOL_SEARCH: "true",
+		CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1"
+	};
+}
+function assertFallbackCapable(name, p) {
+	if (p.protocol === "openai") throw new WorkersConfigError(`provider "${name}" speaks the openai protocol and only works through the live PAI proxy — fallback needs an anthropic-protocol provider every process can reach directly.`);
+	if (p.engine === "codex") throw new WorkersConfigError(`provider "${name}" runs through the Codex CLI — fallback switches Claude Code itself and needs a claude-engine provider.`);
+	if (!p.baseUrl) throw new WorkersConfigError(`provider "${name}" has no baseUrl — fallback cannot point at it.`);
+}
+/** The env block of a parsed settings.json record, or null when absent. */
+function envBlockOf(settings) {
+	return typeof settings.env === "object" && settings.env !== null ? settings.env : null;
+}
+/** Apply a saved state to a parsed settings.json record (inverse of the switch). */
+function restoreSettings(settings, saved) {
+	const keys = Object.keys(saved.env);
+	if (saved.envExisted) {
+		const env = { ...typeof settings.env === "object" && settings.env !== null ? settings.env : {} };
+		for (const k of keys) {
+			const v = saved.env[k];
+			if (v === null) delete env[k];
+			else env[k] = v;
+		}
+		settings.env = env;
+	} else delete settings.env;
+	if (saved.model === null) delete settings.model;
+	else settings.model = saved.model;
+	return keys;
+}
+function writeFallbackNote(logDir, r) {
+	const path = fallbackNotePath(logDir);
+	if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
+	writeFileSync(path, [
+		`# Fallback active`,
+		``,
+		`- switched: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ")} UTC`,
+		`- provider: ${r.provider} — every NEW Claude Code process on this machine runs on it`,
+		`- settings.json: env got ${r.envKeys.join(", ")}; top-level model pinned to ${r.model}`,
+		`- turn off: pai worker fallback off (restores settings.json exactly)`,
+		``,
+		`## Running sessions`,
+		``,
+		`restart this session in its project directory; the new process uses ${r.provider}; keep the same AIBroker name`,
+		``
+	].join("\n"), "utf8");
+	return path;
+}
+/**
+* Switch every new Claude Code process to a worker provider.
+*
+* Write order: the saved state lands in the pai config BEFORE settings.json
+* is touched, so a crash between the two writes leaves `off` able to restore
+* (and `on` re-applies idempotently, healing the gap).
+*/
+function fallbackOn(providerFlag, paths = {}) {
+	const settingsPath = paths.settingsPath ?? fallbackSettingsPath();
+	const { raw, workers } = readWorkersSection(paths.configPath);
+	const logDir = workersLogDir(workers);
+	const { providerName, provider } = resolveTarget(workers, logDir, { flagProvider: providerFlag });
+	assertFallbackCapable(providerName, provider);
+	const env = fallbackEnv(provider);
+	const envKeys = Object.keys(env);
+	const settings = readJsonStrict(settingsPath, settingsPath);
+	const prev = workers.fallback;
+	if (prev && prev.provider === providerName) {
+		settings.env = {
+			...envBlockOf(settings) ?? {},
+			...env
+		};
+		settings.model = provider.models.default;
+		writeJsonAtomic(settingsPath, settings, { label: settingsPath });
+		return {
+			provider: providerName,
+			alreadyOn: true,
+			envKeys,
+			model: provider.models.default
+		};
+	}
+	if (prev) restoreSettings(settings, prev.saved);
+	const envBlock = envBlockOf(settings);
+	const saved = {
+		env: {},
+		model: typeof settings.model === "string" ? settings.model : null,
+		envExisted: envBlock !== null
+	};
+	for (const k of envKeys) saved.env[k] = envBlock && typeof envBlock[k] === "string" ? envBlock[k] : null;
+	workers.fallback = {
+		provider: providerName,
+		saved,
+		on: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	writeWorkersSection(raw, workers, paths.configPath);
+	settings.env = {
+		...envBlock ?? {},
+		...env
+	};
+	settings.model = provider.models.default;
+	writeJsonAtomic(settingsPath, settings, { label: settingsPath });
+	const r = {
+		provider: providerName,
+		alreadyOn: false,
+		envKeys,
+		model: provider.models.default
+	};
+	writeFallbackNote(logDir, r);
+	return r;
+}
+/** Restore settings.json exactly and clear the switch. Errors when not on. */
+function fallbackOff(paths = {}) {
+	const settingsPath = paths.settingsPath ?? fallbackSettingsPath();
+	const { raw, workers } = readWorkersSection(paths.configPath);
+	const fb = workers.fallback;
+	if (!fb) throw new WorkersConfigError("fallback is not on — nothing to restore");
+	const settings = readJsonStrict(settingsPath, settingsPath);
+	const envKeys = restoreSettings(settings, fb.saved);
+	writeJsonAtomic(settingsPath, settings, { label: settingsPath });
+	workers.fallback = null;
+	writeWorkersSection(raw, workers, paths.configPath);
+	try {
+		const note = fallbackNotePath(workersLogDir(workers));
+		if (existsSync(note)) unlinkSync(note);
+	} catch {}
+	return {
+		provider: fb.provider,
+		envKeys
+	};
+}
+/** Running Claude Code processes: the AIBroker managers registry when it has
+* entries, else `ps`. Informational — sessions keep their provider until
+* restarted whatever this shows. */
+function listClaudeSessions() {
+	try {
+		const regPath = join(homedir(), ".aibroker", "managers.json");
+		if (existsSync(regPath)) {
+			const reg = JSON.parse(readFileSync(regPath, "utf8"));
+			const names = Object.keys(reg);
+			if (names.length) return {
+				source: "aibroker",
+				lines: names.map((name) => {
+					const rec = typeof reg[name] === "object" && reg[name] !== null ? reg[name] : {};
+					const bits = [name];
+					for (const field of [
+						"session",
+						"cwd",
+						"pid"
+					]) {
+						const v = rec[field];
+						if (typeof v === "string" || typeof v === "number") bits.push(`${field} ${v}`);
+					}
+					return bits.join("  ");
+				})
+			};
+		}
+	} catch {}
+	try {
+		return {
+			source: "ps",
+			lines: execFileSync("/bin/ps", ["-eo", "pid=,etime=,command="], {
+				encoding: "utf8",
+				timeout: 1e4
+			}).split("\n").map((l) => l.trim()).filter(Boolean).map((l) => {
+				const m = l.match(/^\d+\s+\S+\s+(.*)$/);
+				return m ? m[1] : "";
+			}).filter((cmd) => {
+				const first = cmd.split(/\s+/)[0] ?? "";
+				return first === "claude" || first.endsWith("/claude");
+			}).map((cmd) => cmd.length > 100 ? cmd.slice(0, 97) + "…" : cmd).slice(0, 20)
+		};
+	} catch {
+		return {
+			source: "ps",
+			lines: []
+		};
+	}
+}
+function fallbackStatus(paths = {}) {
+	const { workers } = readWorkersSection(paths.configPath);
+	const fb = workers.fallback;
+	const sessions = listClaudeSessions();
+	if (!fb) return {
+		on: false,
+		provider: null,
+		onAt: null,
+		notePath: null,
+		sessionsSource: sessions.source,
+		sessions: sessions.lines
+	};
+	const notePath = fallbackNotePath(workersLogDir(workers));
+	return {
+		on: true,
+		provider: fb.provider,
+		onAt: fb.on,
+		notePath,
+		sessionsSource: sessions.source,
+		sessions: sessions.lines
+	};
+}
+/** Human-readable status block for the CLI and the MCP tool. */
+function fallbackStatusText(s) {
+	const lines = [];
+	if (!s.on) {
+		lines.push("fallback: off — new Claude Code processes run on the Anthropic login");
+		lines.push("turn on with: pai worker fallback on [provider]");
+	} else {
+		lines.push(`fallback: on — provider ${s.provider} (since ${s.onAt})`);
+		lines.push("every NEW Claude Code process runs on it; turn off with: pai worker fallback off");
+		if (s.notePath) lines.push(`note: ${s.notePath}${existsSync(s.notePath) ? "" : " (missing)"}`);
+	}
+	lines.push("");
+	lines.push(s.sessions.length ? `running Claude Code sessions (${s.sessionsSource}; they keep their current provider until restarted):` : `no running Claude Code sessions detected (${s.sessionsSource})`);
+	lines.push(...s.sessions.length ? s.sessions.map((l) => `  ${l}`) : []);
+	return lines;
+}
+
+//#endregion
+export { statusLineOutput as S, updateProvider as _, addProvider as a, psOutput as b, describeProviders as c, resolveProviderName as d, setClass as f, unsetClass as g, setWorkersEnabled as h, fallbackStatusText as i, modelPrefsText as l, setProviderModel as m, fallbackOn as n, classTargetText as o, setProviderEnabled as p, fallbackStatus as r, describeModels as s, fallbackOff as t, removeProvider as u, useProvider as v, replayOutput as x, followWorkers as y };
+//# sourceMappingURL=fallback-CdXv-Np0.mjs.map