@tekmidian/pai 0.36.2 → 0.38.0

package/dist/{program-C-fUghPv.mjs → program-Y0hAiVy8.mjs}

@@ -7,13 +7,14 @@ import { i as indexProject, n as indexAll, t as embedChunks } from "./sync-BWbe8
 import { t as STOP_WORDS } from "./stop-words-Hfu8u22w.mjs";
 import { a as searchMemory, i as populateSlugs } from "./search-Rpk1cSBC.mjs";
 import { n as formatDetection, r as formatDetectionJson, t as detectProject } from "./detect-CdaA48EI.mjs";
-import { _ as findMovedProjects, a as findLatestNote, c as extractAndStoreTriples, f as resolveHome, g as claudeProjectsDir, h as upsertSession, i as applyContinue, l as cmdScan, m as upsertProject, o as findNotesDir$1, p as saveScanConfig, r as appendCheckpointToNote, s as readBodyFile, t as readContextHandoverCache, u as loadScanConfig, v as scanTranscriptFolders, y as transcriptFiles } from "./context-handover-cache-PtNvj_8D.mjs";
+import { _ as findMovedProjects, a as findLatestNote, c as extractAndStoreTriples, f as resolveHome, g as claudeProjectsDir, h as upsertSession, i as applyContinue, l as cmdScan, m as upsertProject, o as findNotesDir$1, p as saveScanConfig, r as appendCheckpointToNote, s as readBodyFile, t as readContextHandoverCache, u as loadScanConfig, v as scanTranscriptFolders, y as transcriptFiles } from "./context-handover-cache-BpUojjsi.mjs";
 import { a as schedulerLogPath, i as paiSocketPath, n as daemonLogPath, r as daemonPidPath } from "./runtime-paths-rni52zHX.mjs";
 import { t as PaiClient } from "./ipc-client-BmypMNYk.mjs";
 import { a as expandHome, c as UNROUTED, i as ensureConfigDir, n as CONFIG_FILE$2, o as loadConfig, s as OWNER_LABEL_PREFIX, t as CONFIG_DIR } from "./config-B64vFg14.mjs";
-import { r as humanDuration, t as createStorageBackend } from "./factory-Bsp7xOpO.mjs";
-import { s as kgQuery } from "./kg-entity-DbOMPdF9.mjs";
-import { _ as scanSessions, a as renderDedupedSessions, c as probeResume, d as callAiBroker, f as fetchLiveSessions, g as resolveSessionByNameOrId, h as fmtAge, i as normalizeName$2, l as restoreTopLevel, m as sendToSession, o as hasConversation, p as revealItermSession, r as buildDeduped, s as launchInDir, t as cmdMain, u as printExitDir } from "./main-resolver-BAbhKpeX.mjs";
+import { r as humanDuration, t as createStorageBackend } from "./factory-DD2T33C9.mjs";
+import { A as ledgerPath, C as checkPaneForWorker, E as loadStatus, F as readJsonStrict, I as writeJsonAtomic, M as PROVIDER_TAGS, N as WorkersConfigError, O as parseRunnerArgs, P as readWorkersSection, S as describeMcp, T as openPaneForWorker, _ as testProvider, a as setClass, b as stopProxy, c as unsetClass, d as followWorkers, f as psOutput, g as runWorker, h as runChain, i as removeProvider, j as workersLogDir, k as eventsPath, l as updateProvider, m as statusLineOutput, n as classTargetText, o as setProviderEnabled, p as replayOutput, r as describeProviders, s as setWorkersEnabled, t as addProvider, u as useProvider, v as DEFAULT_PROXY_PORT, w as openFollowPane, x as sayToWorker, y as ensureProxyRunning } from "./providers-DUshcB-d.mjs";
+import { s as kgQuery } from "./kg-entity-r8duqhi9.mjs";
+import { _ as scanSessions, a as renderDedupedSessions, c as probeResume, d as callAiBroker, f as fetchLiveSessions, g as resolveSessionByNameOrId, h as fmtAge, i as normalizeName$2, l as restoreTopLevel, m as sendToSession, o as hasConversation, p as revealItermSession, r as buildDeduped, s as launchInDir, t as cmdMain, u as printExitDir } from "./main-resolver-DlaLOFBA.mjs";
 import { appendFileSync, chmodSync, copyFileSync, createReadStream, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir, platform, tmpdir } from "node:os";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
@@ -1888,7 +1889,7 @@ function cmdUnregister(db, slug, opts = {}) {
 //#region src/cli/commands/project/projects-index.ts
 function registerProjectsCommands(projectsCmd, getDb) {
 	projectsCmd.command("list", { isDefault: true }).description("Show the unified deduped listing (same as `pai`).\nUse --all to include cold / zero-session / archived projects.").option("--all", "Show all entries including cold / zero-session / archived projects").option("-n, --n <count>", "Max rows to show", "20").action(async (opts) => {
-		const { cmdMain } = await import("./main-resolver-Dxh444GO.mjs");
+		const { cmdMain } = await import("./main-resolver-IhZo4pI0.mjs");
 		await cmdMain(getDb(), void 0, void 0, opts);
 	});
 	projectsCmd.command("list-raw").description("Raw registry listing with slug, path, status, last_active columns").option("--all", "Include archived projects (default: active only)").option("--status <status>", "Filter by status: active | archived").option("--tag <tag>", "Filter by tag").option("--type <type>", "Filter by type").action((opts) => {
@@ -2960,9 +2961,9 @@ function registerStatsCommands(memoryCmd, getDb) {
 //#region src/cli/commands/memory/sources-cmd.ts
 function registerSourcesCommand(memoryCmd) {
 	memoryCmd.command("sources").description("Show what the indexer has taken in: composition by source, which roots\ncontent enters from, the heaviest single files, and how many chunks are\nrewritten per day (which distinguishes a finite backlog from a treadmill).").option("--limit <n>", "Rows per section (default 8)", "8").action(async (opts) => {
-		const { createStorageBackend } = await import("./factory-CrokPMk2.mjs");
+		const { createStorageBackend } = await import("./factory-BXzqRYVZ.mjs");
 		const { loadConfig } = await import("./config-C_ErGddD.mjs");
-		const { cmdMemorySources } = await import("./sources-D8ZdNfvK.mjs");
+		const { cmdMemorySources } = await import("./sources-Bi7--33T.mjs");
 		let backend;
 		try {
 			backend = await createStorageBackend(loadConfig());
@@ -3649,7 +3650,7 @@ function cmdLogs(opts) {
 }
 function registerDaemonCommands(daemonCmd) {
 	daemonCmd.command("serve").description("Start the PAI daemon in the foreground").action(async () => {
-		const { serve } = await import("./daemon-DRdoA489.mjs");
+		const { serve } = await import("./daemon-DsGGiIJM.mjs");
 		const { loadConfig: lc, ensureConfigDir } = await import("./config-C_ErGddD.mjs");
 		ensureConfigDir();
 		await serve(lc());
@@ -4017,86 +4018,6 @@ function registerRestoreCommands(program) {
 	});
 }
 
-//#endregion
-//#region src/config/json-store.ts
-/**
-* json-store.ts — read/write JSON config files without destroying them
-*
-* The failure this exists to prevent:
-*
-*     try { return JSON.parse(read(path)); } catch { return {}; }
-*     ... later ...
-*     write(path, JSON.stringify(ourData));
-*
-* An unreadable file becomes an empty object, and the next write makes that
-* permanent. Silently, exit code 0. This shape appeared three times in this
-* repo against three different files, and twice in AIBroker.
-*
-* The distinction that matters is between *missing* and *unreadable*:
-*
-*   missing     — legitimate first run. Start fresh; writing is safe.
-*   unreadable  — the file exists and we could not parse it. Those bytes are
-*                 the only copy of something. Never overwrite them.
-*
-* Collapsing the second into the first is the bug.
-*
-* NOT everything deserves this guard. For a transient buffer — an undelivered
-* message queue, a cache — starting fresh IS the correct recovery, and
-* refusing to write would disable the feature permanently. Use `writeJsonAtomic`
-* alone there: it still prevents a crash from truncating a good file, without
-* blocking recovery. Reserve `readJsonStrict` for data a user cannot rebuild.
-*/
-/**
-* Read a JSON file, distinguishing "absent" from "damaged".
-*
-* @param path   file to read
-* @param label  how to name it to the user, e.g. "~/.claude.json"
-* @throws if the file exists but cannot be read or parsed
-*/
-function readJsonStrict(path, label = path) {
-	if (!existsSync(path)) return {};
-	let raw;
-	try {
-		raw = readFileSync(path, "utf8");
-	} catch (e) {
-		throw new Error(`Could not read ${label}: ${e instanceof Error ? e.message : String(e)}\nRefusing to continue — writing now would replace its contents with ours alone.`);
-	}
-	try {
-		return JSON.parse(raw);
-	} catch (e) {
-		throw new Error(`${label} exists but is not valid JSON: ${e instanceof Error ? e.message : String(e)}\nRefusing to continue — overwriting it would destroy whatever it holds.\nRepair the file, or move it aside and re-run this command.`);
-	}
-}
-/**
-* Write JSON without risking the existing file.
-*
-* Keeps a `.bak-pai` copy of the previous contents, then writes to a temp file
-* and renames. Rename is atomic within a filesystem, so a crash mid-write
-* leaves the original intact rather than truncated — which is how these files
-* become corrupt in the first place.
-*/
-function writeJsonAtomic(path, data, opts = {}) {
-	const { backup = true, label = path } = opts;
-	const serialized = JSON.stringify(data, null, 2) + "\n";
-	const dir = dirname(path);
-	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-	if (backup && existsSync(path)) try {
-		copyFileSync(path, `${path}.bak-pai`);
-	} catch (e) {
-		throw new Error(`Could not back up ${label}: ${e instanceof Error ? e.message : String(e)}\nRefusing to write without a backup.`);
-	}
-	const tmp = `${path}.tmp-pai-${process.pid}`;
-	try {
-		writeFileSync(tmp, serialized, "utf8");
-		renameSync(tmp, path);
-	} catch (e) {
-		try {
-			if (existsSync(tmp)) unlinkSync(tmp);
-		} catch {}
-		throw new Error(`Failed to write ${label}: ${e instanceof Error ? e.message : String(e)}\nThe original is unchanged.`);
-	}
-}
-
 //#endregion
 //#region src/cli/lib/exit.ts
 /**
@@ -6152,6 +6073,209 @@ async function stepTaskBus(rl) {
 	} };
 }
 
+//#endregion
+//#region src/workers/install.ts
+/**
+* install.ts — `pai worker install`: one command, whole migration.
+*
+* Three things:
+*
+*   1. ~/.claude/settings.json: point the PreToolUse "Agent" hook at
+*      ${PAI_DIR}/Hooks/route-agents-to-worker.mjs, replacing the old
+*      route-agents-to-glm.sh registration if present.
+*   2. ~/.local/bin compatibility shims (glm, glm-run, glm-ps, glm-log) that
+*      exec the pai equivalents, so every existing habit, alias and script
+*      keeps working. Anything already at those paths is moved aside to
+*      <name>.pre-pai once — never deleted.
+*   3. Remove the old route-agents-to-glm.sh from ~/.claude/Hooks (the
+*      settings.json entry is gone, so the file is dead).
+*
+* Idempotent: running it twice changes nothing the second time.
+*/
+const HOOKS_DIR = join(join(homedir(), ".claude"), "Hooks");
+const LOCAL_BIN = join(homedir(), ".local", "bin");
+const NEW_AGENT_HOOK = "${PAI_DIR}/Hooks/route-agents-to-worker.mjs";
+const OLD_AGENT_HOOK_STEM = "route-agents-to-glm";
+/** Absolute path of the pai executable to hard-wire into the shims. */
+function paiPath() {
+	try {
+		return execFileSync("/usr/bin/which", ["pai"], { encoding: "utf8" }).trim() || "pai";
+	} catch {
+		return "pai";
+	}
+}
+function patchAgentHook(lines) {
+	const settings = readSettingsJson();
+	const hooks = typeof settings["hooks"] === "object" && settings["hooks"] !== null ? settings["hooks"] : {};
+	const preToolUse = Array.isArray(hooks["PreToolUse"]) ? hooks["PreToolUse"] : [];
+	let changed = false;
+	let replaced = false;
+	for (const rule of preToolUse) {
+		if (rule["matcher"] !== "Agent") continue;
+		const entries = Array.isArray(rule["hooks"]) ? rule["hooks"] : [];
+		for (const entry of entries) {
+			const cmd = typeof entry["command"] === "string" ? entry["command"] : "";
+			if (cmd === NEW_AGENT_HOOK) replaced = true;
+			if (cmd.includes(OLD_AGENT_HOOK_STEM)) {
+				entry["command"] = NEW_AGENT_HOOK;
+				lines.push(`settings.json: Agent hook migrated to ${NEW_AGENT_HOOK}`);
+				changed = true;
+				replaced = true;
+			}
+		}
+	}
+	if (!replaced) {
+		preToolUse.push({
+			matcher: "Agent",
+			hooks: [{
+				type: "command",
+				command: NEW_AGENT_HOOK
+			}]
+		});
+		lines.push(`settings.json: Agent hook added → ${NEW_AGENT_HOOK}`);
+		changed = true;
+	}
+	if (changed) {
+		hooks["PreToolUse"] = preToolUse;
+		settings["hooks"] = hooks;
+		writeSettingsJson(settings);
+	} else lines.push(`settings.json: Agent hook already current`);
+	return changed;
+}
+const GLM_PS_SHIM = (pai) => `# pai worker shim — replaces the python glm-ps of the same name
+case "\${1-}" in
+  ""|"ps") exec ${pai} worker ps ;;
+  follow|watch|pane|log) exec ${pai} worker "$@" ;;
+  --status) shift; exec ${pai} worker status-line "\${ITERM_SESSION_ID:-}" "\${PWD:-$HOME}" ;;
+  -*) exec ${pai} worker ps "$@" ;;
+  *) exec ${pai} worker replay "$@" ;;
+esac
+`;
+function shim(name, pai) {
+	if (name === "glm-ps") return GLM_PS_SHIM(pai);
+	if (name === "glm-log") return `#!/bin/sh\n# pai worker shim — replaces the shell glm-log of the same name\nexec ${pai} worker log "$@"\n`;
+	if (name === "worker-say") return `#!/bin/sh\n# pai worker shim — say one line to a running worker\nexec ${pai} worker say "$@"\n`;
+	return `#!/bin/sh\n# pai worker shim — replaces the previous ${name} of the same name\nexec ${pai} worker run "$@"\n`;
+}
+function installShims(lines) {
+	const pai = paiPath();
+	let changed = false;
+	for (const name of [
+		"glm",
+		"glm-run",
+		"glm-ps",
+		"glm-log",
+		"worker-say"
+	]) {
+		const path = join(LOCAL_BIN, name);
+		const ours = `# pai worker shim`;
+		let current = null;
+		if (existsSync(path)) try {
+			current = execFileSync("head", [
+				"-c",
+				"64",
+				path
+			], { encoding: "utf8" });
+		} catch {
+			current = null;
+		}
+		if (current !== null && !current.includes(ours)) {
+			const aside = join(LOCAL_BIN, `${name}.pre-pai`);
+			if (!existsSync(aside)) {
+				renameSync(path, aside);
+				lines.push(`${name}: previous version kept as ${name}.pre-pai`);
+			} else {
+				unlinkSync(path);
+				lines.push(`${name}: replaced (${name}.pre-pai already exists)`);
+			}
+			changed = true;
+		} else if (current === null) changed = true;
+		else {
+			lines.push(`${name}: shim already current`);
+			continue;
+		}
+		writeFileSync(path, shim(name, pai), {
+			encoding: "utf8",
+			mode: 493
+		});
+		try {
+			chmodSync(path, 493);
+		} catch {}
+		lines.push(`${name}: shim installed → ${pai} worker …`);
+	}
+	return changed;
+}
+function removeOldHook(lines) {
+	const old = join(HOOKS_DIR, "route-agents-to-glm.sh");
+	if (!existsSync(old)) return false;
+	unlinkSync(old);
+	lines.push(`removed ${OLD_AGENT_HOOK_STEM}.sh (registration migrated above)`);
+	return true;
+}
+function installWorkers() {
+	const lines = [];
+	let changed = patchAgentHook(lines);
+	if (installShims(lines)) changed = true;
+	if (removeOldHook(lines)) changed = true;
+	if (!existsSync(LOCAL_BIN)) lines.push(`note: ${LOCAL_BIN} did not exist; make sure it is on PATH`);
+	return {
+		lines,
+		changed
+	};
+}
+
+//#endregion
+//#region src/cli/commands/setup/steps/17-workers.ts
+/** Step 17: Worker providers — subagents on configured providers. */
+async function stepWorkers(rl) {
+	section("Step 17: Worker Providers (Optional)");
+	const current = readConfigRaw().workers;
+	if (current?.providers && Object.keys(current.providers).length > 0) {
+		if (current.enabled !== false) {
+			console.log(c.ok("Worker providers already configured. Running install to refresh shims…"));
+			for (const l of installWorkers().lines) line$1(`  ${l}`);
+		}
+		return { workers: current };
+	}
+	line$1();
+	line$1("  PAI can run every subagent (worker) on a provider you configure —");
+	line$1("  a non-Anthropic endpoint via its Anthropic-compatible API.");
+	line$1();
+	line$1("  `pai worker run` is the runner; ps / follow / replay watch the runs;");
+	line$1("  the Agent tool is denied and rewritten to it once providers exist.");
+	line$1();
+	line$1("  PAI works fully without this — Agent subagents then just run as before.");
+	line$1();
+	if (!await promptYesNo(rl, "Configure a worker provider now?", false)) {
+		line$1();
+		console.log(c.ok("Skipping worker providers."));
+		console.log(c.dim("  Add later: pai worker providers add <name> … — see docs/worker.md"));
+		return { workers: {
+			enabled: false,
+			providers: {},
+			classes: {}
+		} };
+	}
+	line$1();
+	line$1("  Add the provider after setup finishes (this step only prepares the");
+	line$1("  wiring — shims, hook registration, log dir):");
+	line$1();
+	line$1(c.dim("    pai worker providers add glm \\"));
+	line$1(c.dim("      --base-url https://api.example.com/api/anthropic \\"));
+	line$1(c.dim("      --key-file ~/.config/example/api_key \\"));
+	line$1(c.dim("      --model example-4.7 --fast-model example-4.7-flash"));
+	line$1();
+	line$1("  The first provider turns workers on and seeds the classes.");
+	line$1();
+	const r = installWorkers();
+	for (const l of r.lines) line$1(`  ${l}`);
+	return { workers: {
+		enabled: false,
+		providers: {},
+		classes: {}
+	} };
+}
+
 //#endregion
 //#region src/cli/commands/setup/index.ts
 async function runSetup() {
@@ -6188,10 +6312,12 @@ async function runSetup() {
 		const mcpRegistered = await stepMcp(rl);
 		await stepDirectories(rl);
 		const taskConfig = await stepTaskBus(rl);
+		const workersConfig = await stepWorkers(rl);
 		const allUpdates = {
 			...storageConfig,
 			...embeddingConfig,
-			...taskConfig
+			...taskConfig,
+			...workersConfig
 		};
 		mergeConfig(allUpdates);
 		line$1();
@@ -7102,7 +7228,7 @@ async function cmdExplore(note, opts) {
 	const depth = parseInt(opts.depth ?? "3", 10);
 	const direction = opts.direction ?? "both";
 	const mode = opts.mode ?? "all";
-	const { zettelExplore } = await import("./zettelkasten-CvjmMghT.mjs");
+	const { zettelExplore } = await import("./zettelkasten-vo7psPdT.mjs");
 	const result = zettelExplore(getFedDb(), {
 		startNote: note,
 		depth,
@@ -7167,7 +7293,7 @@ async function cmdHealth(opts) {
 	const projectPath = opts.project;
 	const recentDays = parseInt(opts.days ?? "30", 10);
 	const includeTypes = opts.include ? opts.include.split(",").map((s) => s.trim()) : void 0;
-	const { zettelHealth } = await import("./zettelkasten-CvjmMghT.mjs");
+	const { zettelHealth } = await import("./zettelkasten-vo7psPdT.mjs");
 	const result = zettelHealth(getFedDb(), {
 		scope,
 		projectPath,
@@ -7238,7 +7364,7 @@ async function cmdSurprise(note, opts) {
 	const limit = parseInt(opts.limit ?? "10", 10);
 	const minSimilarity = parseFloat(opts.minSimilarity ?? "0.3");
 	const minGraphDistance = parseInt(opts.minDistance ?? "3", 10);
-	const { zettelSurprise } = await import("./zettelkasten-CvjmMghT.mjs");
+	const { zettelSurprise } = await import("./zettelkasten-vo7psPdT.mjs");
 	const db = getFedDb();
 	console.log();
 	console.log(header("  PAI Zettel Surprise"));
@@ -7293,7 +7419,7 @@ async function cmdSuggest(note, opts) {
 	const vaultProjectId = parseInt(opts.vaultProjectId, 10);
 	const limit = parseInt(opts.limit ?? "5", 10);
 	const excludeLinked = opts.excludeLinked !== false;
-	const { zettelSuggest } = await import("./zettelkasten-CvjmMghT.mjs");
+	const { zettelSuggest } = await import("./zettelkasten-vo7psPdT.mjs");
 	const db = getFedDb();
 	console.log();
 	console.log(header("  PAI Zettel Suggest"));
@@ -7346,7 +7472,7 @@ async function cmdConverse(question, opts) {
 	const vaultProjectId = parseInt(opts.vaultProjectId, 10);
 	const depth = parseInt(opts.depth ?? "2", 10);
 	const limit = parseInt(opts.limit ?? "15", 10);
-	const { zettelConverse } = await import("./zettelkasten-CvjmMghT.mjs");
+	const { zettelConverse } = await import("./zettelkasten-vo7psPdT.mjs");
 	const db = getFedDb();
 	console.log();
 	console.log(header("  PAI Zettel Converse"));
@@ -7409,7 +7535,7 @@ async function cmdThemes(opts) {
 	const minClusterSize = parseInt(opts.minSize ?? "3", 10);
 	const maxThemes = parseInt(opts.maxThemes ?? "10", 10);
 	const similarityThreshold = parseFloat(opts.threshold ?? "0.65");
-	const { zettelThemes } = await import("./zettelkasten-CvjmMghT.mjs");
+	const { zettelThemes } = await import("./zettelkasten-vo7psPdT.mjs");
 	const db = getFedDb();
 	console.log();
 	console.log(header("  PAI Zettel Themes"));
@@ -8984,7 +9110,7 @@ async function escalate(task, headline, detail, state, now, opts) {
 	state.alarmedAt[task.id] = now;
 	let delivered = false;
 	try {
-		const { routeNotification } = await import("./router-BMkOb62X.mjs");
+		const { routeNotification } = await import("./router-1zi8jiNF.mjs");
 		const { loadConfig } = await import("./config-C_ErGddD.mjs");
 		delivered = (await routeNotification({
 			event: "error",
@@ -11601,9 +11727,9 @@ function cmdActive(db, opts) {
 	], rows));
 }
 async function cmdAutoRoute(opts) {
-	const { autoRoute, formatAutoRoute, formatAutoRouteJson } = await import("./auto-route-Byf8ENXj.mjs");
+	const { autoRoute, formatAutoRoute, formatAutoRouteJson } = await import("./auto-route-DM7GhJ8y.mjs");
 	const { openRegistry } = await import("./db-XEwJbuGO.mjs");
-	const { createStorageBackend } = await import("./factory-CrokPMk2.mjs");
+	const { createStorageBackend } = await import("./factory-BXzqRYVZ.mjs");
 	const { loadConfig } = await import("./config-C_ErGddD.mjs");
 	const config = loadConfig();
 	const registryDb = openRegistry();
@@ -12412,6 +12538,40 @@ function listProjectTranscripts(cwd, projectsDir) {
 	collect(join(projectDir, "sessions"));
 	return paths;
 }
+/** Placeholder model id the platform writes on synthetic assistant turns. */
+const SYNTHETIC_MODEL = "<synthetic>";
+function modelFamily(model) {
+	if (typeof model !== "string" || model === "" || model === SYNTHETIC_MODEL) return "unknown";
+	return model.startsWith("claude-") ? "claude" : "foreign";
+}
+/**
+* The family of the LAST assistant model in a transcript — scanned from the
+* end so a long transcript costs one read and a few lines of parsing.
+* Unreadable or model-less transcripts are "unknown", never "foreign":
+* the callers that skip work on "foreign" must not skip it on doubt.
+*/
+function transcriptModelFamily(path) {
+	let raw;
+	try {
+		raw = readFileSync(path, "utf-8");
+	} catch {
+		return "unknown";
+	}
+	const lines = raw.split("\n");
+	for (let i = lines.length - 1; i >= 0; i--) {
+		const line = lines[i];
+		if (!line.includes("\"model\"")) continue;
+		try {
+			const entry = JSON.parse(line);
+			if (entry.type !== "assistant") continue;
+			const model = entry.message?.model;
+			if (typeof model === "string" && model !== SYNTHETIC_MODEL) return modelFamily(model);
+		} catch {
+			continue;
+		}
+	}
+	return "unknown";
+}
 /**
 * Every DISTINCT compact_boundary sample found across ALL of a project's
 * transcripts (live + archived), newest first by the event's OWN timestamp
@@ -12428,6 +12588,8 @@ function readCompactBoundarySamples(cwd, projectsDir) {
 		} catch {
 			continue;
 		}
+		let lastModel = null;
+		let foreignDiscards = 0;
 		for (const line of raw.split("\n")) {
 			if (!line.trim()) continue;
 			let entry;
@@ -12436,11 +12598,20 @@ function readCompactBoundarySamples(cwd, projectsDir) {
 			} catch {
 				continue;
 			}
+			if (entry.type === "assistant") {
+				const model = entry.message?.model;
+				if (typeof model === "string" && model !== SYNTHETIC_MODEL) lastModel = model;
+				continue;
+			}
 			if (entry.type !== "system" || entry.subtype !== "compact_boundary") continue;
 			const preTokens = entry.compactMetadata?.preTokens;
 			if (typeof preTokens !== "number" || !Number.isFinite(preTokens)) continue;
 			const timestampMs = entry.timestamp ? Date.parse(entry.timestamp) : NaN;
 			if (!Number.isFinite(timestampMs)) continue;
+			if (modelFamily(lastModel) === "foreign") {
+				foreignDiscards++;
+				continue;
+			}
 			const key = entry.uuid ?? `${timestampMs}:${preTokens}`;
 			if (!byKey.has(key)) byKey.set(key, {
 				preTokens,
@@ -12449,6 +12620,7 @@ function readCompactBoundarySamples(cwd, projectsDir) {
 				uuid: entry.uuid
 			});
 		}
+		if (foreignDiscards > 0) console.error(`[context-fill] ignored ${foreignDiscards} compaction sample(s) from a non-Claude transcript (model=${lastModel}): ${path}`);
 	}
 	return [...byKey.values()].sort((a, b) => b.timestampMs - a.timestampMs);
 }
@@ -12592,6 +12764,32 @@ function isImmediate(usedTokens, thresholds) {
 	return usedTokens >= thresholds.immediateTokens;
 }
 
+//#endregion
+//#region src/hooks/ts/lib/worker-session.ts
+/**
+* Worker-session detection.
+*
+* A disposable headless worker (a `claude -p` run started by an orchestrating
+* session, possibly against a different model provider with a different
+* context window) shares the project directory and the hook configuration
+* with the real session that spawned it. Left alone, the hooks treat it as a
+* session in its own right: they inject project context into it, create and
+* rename a numbered session note for it, autosave it, and enqueue a
+* model-written handover for it. Its compactions also land in the project's
+* transcript folder, where they are indistinguishable from a real session's
+* and drag the measured compaction trigger down (observed 2026-09-17: two
+* workers compacting at ~151k tokens pulled a project's trigger from ~784k
+* to ~151k, and the real session's handover fired at ~50k tokens).
+*
+* The launcher marks such sessions with `PAI_WORKER=1`. Every hook that does
+* per-session bookkeeping returns immediately when this predicate is true.
+* Deliberately NOT guarded: the security validator (a worker's shell
+* commands must still be checked) and observability capture.
+*/
+function isWorkerSession(env = process.env) {
+	return env.PAI_WORKER === "1";
+}
+
 //#endregion
 //#region src/session/context-handover-trigger.ts
 /**
@@ -12705,6 +12903,14 @@ const NOTHING = {
 * either alone would have.
 */
 async function checkAndEnqueueContextHandover(input, deps = defaultDeps) {
+	if (isWorkerSession()) {
+		console.error(`[context-handover-trigger] session ${input.sessionId}: worker session (PAI_WORKER=1) — no handover.`);
+		return NOTHING;
+	}
+	if (input.transcriptPath && transcriptModelFamily(input.transcriptPath) === "foreign") {
+		console.error(`[context-handover-trigger] session ${input.sessionId}: transcript written by a non-Claude model — no handover.`);
+		return NOTHING;
+	}
 	let state = deps.loadState(input.sessionId);
 	if (ALL_THRESHOLDS.every((t) => state.confirmed.includes(t))) return NOTHING;
 	let confirmedThisCheck = [];
@@ -13371,6 +13577,549 @@ function registerSessionCommands(sessionCmd, getDb) {
 	});
 }
 
+//#endregion
+//#region src/workers/agents.ts
+/**
+* agents.ts — run agent definitions (~/.claude/agents/<name>.md) as workers.
+*
+* The file format is the Claude Code agent one: YAML front matter (`model`,
+* `tools`, `description`) followed by a Markdown body that is the agent's
+* system prompt. `pai worker run --agent <name>` loads it and maps it onto
+* the worker runner:
+*
+*   - body    → --append-system-prompt (prepended, so an explicit caller
+*               flag still wins);
+*   - tools   → --allowedTools;
+*   - model   → a task class (haiku→simple, sonnet→implement, opus→complex),
+*               unless --class is given.
+*/
+/** Directory the agent library lives in. */
+function agentsDir() {
+	return join(homedir(), ".claude", "agents");
+}
+function agentPath(name) {
+	return join(agentsDir(), `${name}.md`);
+}
+/** `key: value` (bare) or `key: [a, b]` / `key:\n  - a\n  - b` (list). */
+function parseFrontMatter(text) {
+	const out = {};
+	let key = "";
+	for (const raw of text.split("\n")) {
+		const listItem = /^\s+-\s+(.*)$/.exec(raw);
+		if (listItem && key) {
+			const cur = out[key];
+			const item = listItem[1].trim().replace(/^["']|["']$/g, "");
+			out[key] = Array.isArray(cur) ? [...cur, item] : [item];
+			continue;
+		}
+		const kv = /^([A-Za-z0-9_-]+):\s*(.*)$/.exec(raw);
+		if (!kv) continue;
+		key = kv[1];
+		const val = kv[2].trim();
+		if (!val) out[key] = [];
+		else if (val.startsWith("[") && val.endsWith("]")) out[key] = val.slice(1, -1).split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+		else out[key] = val.replace(/^["']|["']$/g, "");
+	}
+	return out;
+}
+/** Parse an agent file's text (front matter + body). Throws on empty body. */
+function parseAgentFile(name, text, path) {
+	const m = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(text);
+	if (!m) throw new Error(`${path}: expected YAML front matter (--- … ---) before the agent body`);
+	const fm = parseFrontMatter(m[1]);
+	const body = m[2].trim();
+	if (!body) throw new Error(`${path}: the agent body (after the front matter) is empty`);
+	const def = {
+		name,
+		body,
+		path
+	};
+	if (typeof fm.model === "string" && fm.model) def.model = fm.model;
+	if (Array.isArray(fm.tools) && fm.tools.length) def.tools = fm.tools;
+	if (typeof fm.description === "string" && fm.description) def.description = fm.description;
+	return def;
+}
+/** Load ~/.claude/agents/<name>.md; the error names the library when missing. */
+function loadAgent(name) {
+	const path = agentPath(name);
+	let text;
+	try {
+		text = readFileSync(path, "utf8");
+	} catch {
+		throw new Error(`no agent named "${name}" at ${path}. The agent library lives in ~/.claude/agents/<name>.md and runs on workers.`);
+	}
+	return parseAgentFile(name, text, path);
+}
+/** Map an agent's front-matter model to a worker class. */
+function modelToClass(model) {
+	if (!model) return void 0;
+	const m = model.toLowerCase();
+	if (m.includes("haiku")) return "simple";
+	if (m.includes("sonnet")) return "implement";
+	if (m.includes("opus")) return "complex";
+}
+/** Extra claude args the definition contributes (before the caller's own). */
+function agentClaudeArgs(def) {
+	const args = [];
+	if (def.tools?.length) args.push("--allowedTools", def.tools.join(","));
+	args.push("--append-system-prompt", def.body);
+	return args;
+}
+/** `<agent>: <first 50 chars of prompt>` — the default label for a run. */
+function agentLabel(name, prompt) {
+	return `${name}: ${prompt ?? "(no prompt)"}`.slice(0, name.length + 2 + 50);
+}
+
+//#endregion
+//#region src/cli/commands/worker/providers.ts
+function fail$1(e) {
+	const msg = e instanceof Error ? e.message : String(e);
+	console.error(err("pai worker: ") + msg);
+	process.exitCode = 1;
+}
+/** `--env K=V` (repeatable) → record. Throws on a value without "=". */
+function collectEnv(pairs) {
+	const out = {};
+	for (const p of pairs ?? []) {
+		const eq = p.indexOf("=");
+		if (eq <= 0) throw new WorkersConfigError(`--env expects NAME=VALUE, got "${p}"`);
+		out[p.slice(0, eq)] = p.slice(eq + 1);
+	}
+	return out;
+}
+function parseIntArg$1(v) {
+	const n = parseInt(v, 10);
+	if (Number.isNaN(n) || n <= 0) throw new WorkersConfigError(`expected a positive number, got "${v}"`);
+	return n;
+}
+function parseCostTier(v) {
+	const n = parseInt(v, 10);
+	if (!Number.isInteger(n) || n < 1 || n > 5) throw new WorkersConfigError(`cost tier must be an integer 1 (cheapest) … 5 (most expensive), got "${v}"`);
+	return n;
+}
+/** `--tags a,b` (repeatable) → validated tag list. */
+function collectTags(vals) {
+	const out = [];
+	for (const v of vals ?? []) for (const t of v.split(",").map((s) => s.trim()).filter(Boolean)) {
+		if (!PROVIDER_TAGS.includes(t)) throw new WorkersConfigError(`"${t}" is not a tag (from: ${PROVIDER_TAGS.join(", ")})`);
+		if (!out.includes(t)) out.push(t);
+	}
+	return out;
+}
+/** Positional target + constraint flags → a ClassTarget for setClass. */
+function buildClassTarget(target, opts) {
+	const hasConstraints = opts.provider !== void 0 || opts.mcp !== void 0 || opts.maxCostTier !== void 0 || opts.requireTags !== void 0 || opts.order !== void 0;
+	if (target !== void 0 && !hasConstraints) return target;
+	const obj = {};
+	if (target !== void 0) obj.provider = target.split("/")[0];
+	if (opts.provider !== void 0) obj.provider = opts.provider;
+	if (opts.mcp !== void 0) obj.mcp = opts.mcp.split(",").map((s) => s.trim()).filter(Boolean);
+	if (opts.maxCostTier !== void 0) obj.maxCostTier = opts.maxCostTier;
+	if (opts.requireTags !== void 0) obj.requireTags = opts.requireTags;
+	if (opts.order !== void 0) obj.order = opts.order.split(",").map((s) => s.trim()).filter(Boolean);
+	if (target !== void 0 && target.includes("/") && obj.provider) {
+		const alias = target.split("/")[1];
+		if (alias && alias !== "default") throw new WorkersConfigError(`a provider alias ("${alias}") cannot be combined with constraint flags — use the plain "<target>" form for pinning`);
+	}
+	if (!Object.keys(obj).length) throw new WorkersConfigError("give a target (provider, provider/fast) or a constraint (--max-cost-tier, --require-tags, …)");
+	return obj;
+}
+function registerWorkerProviderCommands(providersCmd) {
+	providersCmd.description("Providers: list (default), add, remove, use, enable, disable, test").action(() => {
+		const { workers } = readWorkersSection();
+		console.log();
+		for (const line of describeProviders(workers)) console.log(`  ${line}`);
+		console.log();
+		console.log(dim$1(`  workers are ${workers.enabled ? "on" : "off"} — pai worker ${workers.enabled ? "off" : "on"}`));
+		console.log();
+	});
+	providersCmd.command("add <name>").description("Add a provider; the first one also turns workers on and seeds classes.\nExample: pai worker providers add glm --base-url https://…/anthropic \\\n           --key-file ~/.config/zai/api_key --model glm-5.3 --fast-model glm-5.3-flash\nOpenAI-protocol: --protocol openai --upstream-url https://…/v1 (runs via the PAI proxy).\nCodex (ChatGPT plan): --engine codex — runs through the Codex CLI.").option("--base-url <url>", "Anthropic-compatible API base URL (required unless --protocol openai)").requiredOption("--model <model>", "Default model id for this provider").option("--key-file <path>", "File holding the API token (0600); omit for token \"local\"").option("--fast-model <model>", "Cheaper model for spotchecks and routing").option("--env <name=value>", "Extra env for runs (repeatable)", (v, acc) => [...acc, v], []).option("--note <text>", "Human note shown in `providers list`").option("--protocol <proto>", "anthropic (default) or openai — openai runs through the local PAI proxy").option("--upstream-url <url>", "Chat Completions base URL (required for --protocol openai)").option("--engine <engine>", "claude (default) or codex — codex runs `codex exec --json`").option("--context-window <tokens>", "Context window for the meter (default 200000; init event overrides)", parseIntArg$1).option("--quota-probe <url>", "URL whose JSON first number is the quota percent (0-100)").option("--cost-tier <1-5>", "Cost tier 1 (cheapest) … 5 (most expensive; default 3)", parseCostTier).option("--tags <tags>", "Capability tags, comma-separated (from: " + PROVIDER_TAGS.join(", ") + ")", (v, acc) => [...acc, v], []).action((name, opts) => {
+		try {
+			const protocol = opts.protocol;
+			const engine = opts.engine;
+			if (protocol && protocol !== "anthropic" && protocol !== "openai") throw new WorkersConfigError(`--protocol must be anthropic or openai, got "${protocol}"`);
+			if (engine && engine !== "claude" && engine !== "codex") throw new WorkersConfigError(`--engine must be claude or codex, got "${engine}"`);
+			if (protocol !== "openai" && !opts.baseUrl) throw new WorkersConfigError("--base-url is required (only --protocol openai goes without it)");
+			const tags = collectTags(opts.tags);
+			addProvider({
+				name,
+				baseUrl: opts.baseUrl ?? "",
+				keyFile: opts.keyFile ?? null,
+				model: opts.model,
+				fastModel: opts.fastModel,
+				env: collectEnv(opts.env),
+				note: opts.note,
+				...protocol ? { protocol } : {},
+				...opts.upstreamUrl ? { upstreamUrl: opts.upstreamUrl } : {},
+				...engine ? { engine } : {},
+				...opts.contextWindow ? { contextWindow: opts.contextWindow } : {},
+				quotaProbe: opts.quotaProbe,
+				...opts.costTier !== void 0 ? { costTier: opts.costTier } : {},
+				...tags.length ? { tags } : {}
+			});
+			const { workers } = readWorkersSection();
+			console.log(ok$1(`provider ${name} added`));
+			if (workers.active === name) console.log(`  active: ${name} — workers ${workers.enabled ? "on" : "off"}`);
+			for (const line of describeProviders(workers)) console.log(dim$1(`  ${line}`));
+		} catch (e) {
+			fail$1(e);
+		}
+	});
+	providersCmd.command("update <name>").description("Change cost tier and tags of a provider (routing constraints use these)").option("--cost-tier <1-5>", "Cost tier 1 (cheapest) … 5 (most expensive)", parseCostTier).option("--tags <tags>", "Capability tags, comma-separated (from: " + PROVIDER_TAGS.join(", ") + "); --tags '' clears", (v, acc) => [...acc, v], []).action((name, opts) => {
+		try {
+			if (opts.costTier === void 0 && opts.tags === void 0) throw new WorkersConfigError("nothing to update — pass --cost-tier and/or --tags");
+			const tags = opts.tags === void 0 ? void 0 : collectTags(opts.tags);
+			updateProvider(name, {
+				...opts.costTier !== void 0 ? { costTier: opts.costTier } : {},
+				...tags !== void 0 ? { tags } : {}
+			});
+			console.log(ok$1(`provider ${name} updated`));
+			const { workers } = readWorkersSection();
+			for (const line of describeProviders(workers)) console.log(dim$1(`  ${line}`));
+		} catch (e) {
+			fail$1(e);
+		}
+	});
+	providersCmd.command("remove <name>").description("Remove a provider and any classes pointing at it").action((name) => {
+		try {
+			removeProvider(name);
+			console.log(ok$1(`provider ${name} removed`));
+		} catch (e) {
+			fail$1(e);
+		}
+	});
+	providersCmd.command("use <name>").description("Make this provider the active one for runs without --provider/--class").action((name) => {
+		try {
+			useProvider(name);
+			console.log(ok$1(`active provider: ${name}`));
+		} catch (e) {
+			fail$1(e);
+		}
+	});
+	providersCmd.command("enable <name>").description("Enable a provider (also clears its cooldown)").action((name) => {
+		try {
+			setProviderEnabled(name, true);
+			console.log(ok$1(`provider ${name} enabled`));
+		} catch (e) {
+			fail$1(e);
+		}
+	});
+	providersCmd.command("disable <name>").description("Disable a provider (auto-routing skips it; --provider still works)").action((name) => {
+		try {
+			setProviderEnabled(name, false);
+			console.log(ok$1(`provider ${name} disabled`));
+		} catch (e) {
+			fail$1(e);
+		}
+	});
+	providersCmd.command("test [name]").description("One-word pong probe through a provider (default: the active one)").action(async (name) => {
+		try {
+			const { workers } = readWorkersSection();
+			const pname = name ?? workers.active ?? "";
+			if (!pname || !workers.providers[pname]) throw new WorkersConfigError(name ? `no provider named "${name}"` : "no active provider — name one explicitly");
+			console.log(dim$1(`  probing ${pname} (${workers.providers[pname].models.default}) …`));
+			const r = await testProvider(pname, workers.providers[pname], workersLogDir(workers));
+			const head = `${r.provider} ${r.model}  ${(r.latencyMs / 1e3).toFixed(1)}s`;
+			if (r.skipped) {
+				console.log(dim$1(`  ${head}  ${r.skipped}`));
+				console.log(`  reply: ${r.result.slice(0, 200)}`);
+				return;
+			}
+			console.log(r.ok ? ok$1(`  ${head}`) : err(`  ${head}`));
+			console.log(`  reply: ${r.result.slice(0, 200)}`);
+			process.exitCode = r.ok ? 0 : 1;
+		} catch (e) {
+			fail$1(e);
+		}
+	});
+}
+function printClasses() {
+	const { workers } = readWorkersSection();
+	const entries = Object.entries(workers.classes);
+	if (!entries.length) {
+		console.log(dim$1("  no classes set — runs use the active provider (or auto routing)"));
+		return;
+	}
+	for (const [cls, target] of entries) console.log(`  ${cls.padEnd(12)} ${classTargetText(target)}`);
+}
+function registerClassSubcommands(classesCmd) {
+	classesCmd.command("list").description("List classes and their targets (default action)").action(() => printClasses());
+	classesCmd.command("set <class> [target]").description("Point a class at a provider (or provider/fast), or give only constraints:\nclasses set research --max-cost-tier 2 --require-tags long-context,reasoning").option("--provider <name>", "Pin the class to this provider (object form)").option("--mcp <names>", "MCP servers/sets for runs of this class (comma-separated)").option("--max-cost-tier <1-5>", "Auto-routing considers only providers up to this cost tier", parseCostTier).option("--require-tags <tags>", "Auto-routing needs these tags (comma-separated)", (v) => v.split(",").map((s) => s.trim()).filter(Boolean)).option("--order <providers>", "Per-class routing order overriding workers.routing.order (comma-separated)").action((cls, target, opts) => {
+		try {
+			const built = buildClassTarget(target, opts);
+			setClass(cls, built);
+			console.log(ok$1(`class ${cls} → ${classTargetText(built)}`));
+		} catch (e) {
+			fail$1(e);
+		}
+	});
+	classesCmd.command("unset <class>").description("Remove a class (runs then use the active provider)").action((cls) => {
+		try {
+			unsetClass(cls);
+			console.log(ok$1(`class ${cls} removed`));
+		} catch (e) {
+			fail$1(e);
+		}
+	});
+}
+/** `pai worker classes` — class → target assignment (roles is the old name). */
+function registerWorkerClassCommands(workerCmd) {
+	registerClassSubcommands(workerCmd.command("classes").description("Classes: which provider serves draft / implement / review / …").action(() => printClasses()));
+	registerClassSubcommands(workerCmd.command("roles", { hidden: true }).description("Alias of `classes` (roles was renamed to classes)").action(() => printClasses()));
+}
+
+//#endregion
+//#region src/cli/commands/worker/index.ts
+function currentLogDir() {
+	const { workers } = readWorkersSection();
+	return workersLogDir(workers);
+}
+function fail(e) {
+	const msg = e instanceof Error ? e.message : String(e);
+	console.error(err("pai worker: ") + msg);
+	process.exitCode = 1;
+}
+function registerWorkerCommands(workerCmd) {
+	workerCmd.command("run").description("Run one claude-code worker through the configured provider.\nUnknown options are passed to claude verbatim (e.g. -p, --allowedTools);\n--output-format/--verbose are handled here.\n--chain draft,implement[,review] runs a spec-first pipeline;\n--agent <name> runs an agent definition from ~/.claude/agents.").allowUnknownOption(true).option("--provider <name>", "Provider to run on (default: active, else routing order)").option("--class <name>", "Use the provider of this class (draft, implement, review, research, spotcheck, simple, complex, image)").option("--role <name>", "Alias of --class (roles were renamed to classes)").option("--chain <stages>", "Comma-separated stage classes, e.g. draft,implement or draft,implement,review").option("--agent <name>", "Run the agent definition ~/.claude/agents/<name>.md on a worker").option("--model <model>", "Override the provider's model for this run").option("--label <text>", "Short task label shown in ps / follow / status line").option("--mcp <names>", "MCP servers/sets this worker may use (comma-separated; see `pai worker mcp`)").option("--no-pane", "Do not open a follow pane for this worker").argument("[args...]", "claude arguments, e.g. -p '<task>' --allowedTools 'Read,Edit,Bash'").action(async (args, opts) => {
+		try {
+			const className = opts.class ?? opts.role;
+			let claudeArgs = args;
+			let label = opts.label;
+			let agentClass;
+			if (opts.agent) {
+				const def = loadAgent(opts.agent);
+				claudeArgs = [...agentClaudeArgs(def), ...args];
+				agentClass = modelToClass(def.model);
+				if (!label) label = agentLabel(opts.agent, parseRunnerArgs(args).prompt);
+			}
+			if (opts.chain) {
+				const brief = parseRunnerArgs(claudeArgs).prompt;
+				if (!brief) throw new Error("--chain needs the task as -p '<brief>'");
+				const rc = await runChain({
+					stages: opts.chain.split(","),
+					className: className ?? agentClass,
+					providerFlag: opts.provider,
+					modelFlag: opts.model,
+					label,
+					noPane: opts.pane === false,
+					mcpFlag: opts.mcp,
+					brief,
+					claudeArgs
+				});
+				process.exitCode = rc;
+				return;
+			}
+			const rc = await runWorker({
+				providerFlag: opts.provider,
+				className: className ?? agentClass,
+				modelFlag: opts.model,
+				label,
+				mcpFlag: opts.mcp,
+				noPane: opts.pane === false,
+				claudeArgs
+			});
+			process.exitCode = rc;
+		} catch (e) {
+			fail(e);
+		}
+	});
+	workerCmd.command("ps").description("List workers of this session (RUNNING + FINISHED); --all for every worker").option("--all", "Show workers of all sessions, not just this terminal's").action((opts) => {
+		try {
+			console.log(psOutput(currentLogDir(), opts.all === true));
+		} catch (e) {
+			fail(e);
+		}
+	});
+	workerCmd.command("follow [id]").description("Live transcript of one worker, or of this session's running workers").option("--all", "Follow workers of all sessions").option("--auto-exit [secs]", "Exit secs after the workers end (pane mode; default from config)").action(async (id, opts) => {
+		try {
+			const { workers } = readWorkersSection();
+			const autoExit = opts.autoExit === void 0 || opts.autoExit === false ? 0 : opts.autoExit === true ? workers.pane.autoExitSecs : Number(opts.autoExit);
+			await followWorkers(currentLogDir(), id ?? null, opts.all === true, autoExit);
+		} catch (e) {
+			fail(e);
+		}
+	});
+	workerCmd.command("replay <id>").description("Print the transcript of one finished or running worker").option("--tail <n>", "Only the last n rendered lines", parseIntArg).action((id, opts) => {
+		try {
+			console.log(replayOutput(currentLogDir(), id, process.stdout.isTTY === true, opts.tail));
+		} catch (e) {
+			fail(e);
+		}
+	});
+	workerCmd.command("watch").description("ps refreshed every 2 seconds (plain `watch`, colors kept)").action(() => {
+		const proc = spawn("watch", [
+			"-n",
+			"2",
+			"pai worker ps --all"
+		], { stdio: "inherit" });
+		proc.on("error", (e) => fail(/* @__PURE__ */ new Error(`cannot run watch: ${e.message}`)));
+		proc.on("close", (code) => {
+			process.exitCode = code ?? 1;
+		});
+	});
+	workerCmd.command("pane [id]").description("Open the follow pane for a worker (or one shared pane for this session)").option("--check", "Only report whether the pane is open, plus the profile file's path, font, and the hosting window's bounds").action(async (id, opts) => {
+		try {
+			const { workers } = readWorkersSection();
+			const logDir = currentLogDir();
+			const term = process.env.ITERM_SESSION_ID ?? "";
+			if (id) {
+				const msg = opts.check ? await checkPaneForWorker(id, workers.pane.fontSize, term) : await openPaneForWorker(logDir, workers, id, term);
+				console.log(msg);
+			} else console.log(await openFollowPane(logDir, workers, term, opts.check === true));
+		} catch (e) {
+			fail(e);
+		}
+	});
+	workerCmd.command("log [what]").description("all = ledger, tail = last ledger lines, <id> = raw event stream, none = list").action((what) => {
+		try {
+			const logDir = currentLogDir();
+			const ledger = ledgerPath(logDir);
+			if (what === "all") {
+				console.log(existsSync(ledger) ? readFileSync(ledger, "utf8") : dim$1("(no ledger yet)"));
+				return;
+			}
+			if (what === "tail") {
+				if (!existsSync(ledger)) {
+					console.log(dim$1("(no ledger yet)"));
+					return;
+				}
+				const lines = readFileSync(ledger, "utf8").trim().split("\n");
+				console.log(lines.slice(-20).join("\n"));
+				return;
+			}
+			if (what) {
+				const path = eventsPath(logDir, what);
+				if (!existsSync(path)) {
+					fail(/* @__PURE__ */ new Error(`no event log for ${what}`));
+					return;
+				}
+				const lines = readFileSync(path, "utf8").trim().split("\n");
+				console.log(lines.slice(-30).join("\n"));
+				return;
+			}
+			if (!existsSync(logDir)) {
+				console.log(dim$1("(no workers yet)"));
+				return;
+			}
+			for (const f of readdirSync(logDir).filter((x) => x.endsWith(".jsonl")).sort()) {
+				const st = statSync(`${logDir}/${f}`);
+				const mb = (st.size / 1024 / 1024).toFixed(1);
+				console.log(`  ${f.replace(".jsonl", "")}  ${mb} MB  ${st.mtime.toISOString().slice(0, 19).replace("T", " ")}`);
+			}
+		} catch (e) {
+			fail(e);
+		}
+	});
+	workerCmd.command("say <id> <text>").description("Send one message to a running worker (forwarded to its open stdin)").action(async (id, text) => {
+		try {
+			await sayToWorker(currentLogDir(), id, text);
+			console.log("ok");
+		} catch (e) {
+			fail(e);
+		}
+	});
+	workerCmd.command("resume <id> <text>").description("Continue a finished worker on the same provider: claude --resume <session>").option("--print-id", "Print the new worker id on its own line (pane follow handoff)").option("--no-pane", "Do not open a follow pane for the resumed worker").action(async (id, text, opts) => {
+		try {
+			const old = loadStatus(currentLogDir(), id);
+			if (!old) {
+				fail(/* @__PURE__ */ new Error(`no worker named "${id}"`));
+				return;
+			}
+			if (!old.claudeSession) {
+				fail(/* @__PURE__ */ new Error(`worker ${id} recorded no Claude session id — it predates resume support or ran through an engine that does not expose one`));
+				return;
+			}
+			let newId = "";
+			const rc = await runWorker({
+				providerFlag: old.provider,
+				modelFlag: old.model,
+				label: `↩ ${old.label}`,
+				noPane: opts.pane === false,
+				claudeArgs: [
+					"--resume",
+					old.claudeSession,
+					"-p",
+					text
+				],
+				onWorkerStart: (wid) => {
+					newId = wid;
+				}
+			});
+			if (opts.printId === true && newId) console.log(newId);
+			process.exitCode = rc;
+		} catch (e) {
+			fail(e);
+		}
+	});
+	workerCmd.command("proxy [stop]").description("The local Anthropic↔OpenAI proxy (loopback only); started on demand by `run`,\n`proxy` starts/verifies it, `proxy stop` stops it again").option("--port <n>", `Port to listen on (default ${DEFAULT_PROXY_PORT})`, parseIntArg).action(async (stop, opts) => {
+		try {
+			const logDir = currentLogDir();
+			if (stop === "stop") {
+				console.log(stopProxy(logDir));
+				return;
+			}
+			if (stop) {
+				fail(/* @__PURE__ */ new Error(`unknown proxy argument "${stop}" (expected: stop)`));
+				return;
+			}
+			const url = await ensureProxyRunning(opts.port ?? DEFAULT_PROXY_PORT, logDir);
+			console.log(`proxy listening on ${url} — point openai providers at ${url}/<provider>`);
+		} catch (e) {
+			fail(e);
+		}
+	});
+	workerCmd.command("mcp [list]").description("MCP servers workers may load via --mcp / roles, and the configured sets").action((what) => {
+		if (what && what !== "list") {
+			fail(/* @__PURE__ */ new Error(`unknown mcp argument "${what}" (expected: list)`));
+			return;
+		}
+		try {
+			const { workers } = readWorkersSection();
+			console.log(describeMcp(workers));
+		} catch (e) {
+			fail(e);
+		}
+	});
+	workerCmd.command("status-line [term] [cwd]").description("One-line worker summary for a status bar (empty when none in scope).\nCalled by statusline-command.sh with ITERM_SESSION_ID and the pane cwd.").action((term, cwd) => {
+		try {
+			const out = statusLineOutput(currentLogDir(), term ?? process.env.ITERM_SESSION_ID ?? "", cwd ?? process.cwd());
+			if (out) console.log(out);
+		} catch (e) {
+			fail(e);
+		}
+	});
+	workerCmd.command("on").description("Route Agent-tool subagents to workers (default when a provider exists)").action(() => {
+		try {
+			setWorkersEnabled(true);
+			console.log("workers on — the Agent hook now denies and suggests `pai worker run`");
+		} catch (e) {
+			fail(e);
+		}
+	});
+	workerCmd.command("off").description("Stop routing: Agent tool runs on Anthropic again").action(() => {
+		try {
+			setWorkersEnabled(false);
+			console.log("workers off — Agent-tool subagents run on Anthropic");
+		} catch (e) {
+			fail(e);
+		}
+	});
+	workerCmd.command("install").description("Migrate: Agent hook in settings.json, ~/.local/bin glm* shims, old script cleanup").action(() => {
+		try {
+			const r = installWorkers();
+			for (const line of r.lines) console.log(`  ${line}`);
+		} catch (e) {
+			fail(e);
+		}
+	});
+	registerWorkerProviderCommands(workerCmd.command("providers").description("Providers: list, add, remove, use, enable, disable, test"));
+	registerWorkerClassCommands(workerCmd);
+}
+function parseIntArg(v) {
+	const n = parseInt(v, 10);
+	return Number.isNaN(n) ? 0 : n;
+}
+
 //#endregion
 //#region src/cli/commands/session-cleanup/types.ts
 const TEMPLATE_INDICATORS = [
@@ -13735,7 +14484,7 @@ async function countVectorDbPaths(oldPaths) {
 	if (oldPaths.length === 0) return 0;
 	try {
 		const { loadConfig } = await import("./config-C_ErGddD.mjs");
-		const { PostgresBackend } = await import("./postgres-BVme6qX0.mjs");
+		const { PostgresBackend } = await import("./postgres--BjPtLa0.mjs");
 		const config = loadConfig();
 		if (config.storageBackend !== "postgres") return 0;
 		const pgBackend = new PostgresBackend(config.postgres ?? {});
@@ -13756,7 +14505,7 @@ async function updateVectorDbPaths(moves) {
 	if (moves.length === 0) return 0;
 	try {
 		const { loadConfig } = await import("./config-C_ErGddD.mjs");
-		const { PostgresBackend } = await import("./postgres-BVme6qX0.mjs");
+		const { PostgresBackend } = await import("./postgres--BjPtLa0.mjs");
 		const config = loadConfig();
 		if (config.storageBackend !== "postgres") return 0;
 		const pgBackend = new PostgresBackend(config.postgres ?? {});
@@ -15099,6 +15848,7 @@ Examples:
 	const sessionCmd = program.command("session").description("Session management: list, info, checkpoint, handover, cleanup, slug, tag, route.\nShort forms: `pai pause`, `pai end`, `pai resume <name>`.");
 	registerSessionCommands(sessionCmd, getDb);
 	registerSessionCleanupCommand(sessionCmd, getDb);
+	registerWorkerCommands(program.command("worker").description("Run subagents on configured worker providers: run, ps, follow, replay,\npane, log, status-line, providers, roles, on, off, install"));
 	program.command("sessions").description("Alias for `pai` — show the unified deduped listing.").option("--all", "Show all entries including cold / zero-session / archived projects").option("-n, --n <count>", "Max candidates for history search", "20").action(async (opts) => {
 		await cmdMain(getDb(), void 0, void 0, opts);
 	});
@@ -15280,4 +16030,4 @@ claude() {
 
 //#endregion
 export { drainStdio as n, buildProgram as t };
-//# sourceMappingURL=program-C-fUghPv.mjs.map
+//# sourceMappingURL=program-Y0hAiVy8.mjs.map