@tekmidian/pai 0.59.0 → 0.60.1

package/dist/{factory-C9wGUe30.mjs → factory-DW7BCJJT.mjs}

@@ -1,3 +1,3 @@
-import { a as getStorageBackend, i as getRegistryBackend, n as createRegistryBackend, r as createStorageBackend, t as closeStorage } from "./factory-DiuntvwG.mjs";
+import { a as getStorageBackend, i as getRegistryBackend, n as createRegistryBackend, r as createStorageBackend, t as closeStorage } from "./factory-EUUhSSoq.mjs";
 
 export { createStorageBackend, getRegistryBackend };

package/dist/{factory-DiuntvwG.mjs → factory-EUUhSSoq.mjs}

@@ -85,8 +85,8 @@ const ESCALATE_AFTER_ATTEMPTS = 5;
 /** Tell the user the backend is down, through whatever channels are configured. */
 async function notifyBackendDown(attempts, lastError) {
 	try {
-		const { routeNotification } = await import("./router-BXOf_e9e.mjs");
-		const { loadConfig } = await import("./config-DCYWFaEi.mjs");
+		const { routeNotification } = await import("./router-C5hPk9YP.mjs");
+		const { loadConfig } = await import("./config-DjXq_W42.mjs");
 		await routeNotification({
 			event: "error",
 			title: "PAI: storage backend unreachable",
@@ -97,8 +97,8 @@ async function notifyBackendDown(attempts, lastError) {
 /** And say when it comes back, so the alert is not left hanging. */
 async function notifyBackendRecovered(attempts, since) {
 	try {
-		const { routeNotification } = await import("./router-BXOf_e9e.mjs");
-		const { loadConfig } = await import("./config-DCYWFaEi.mjs");
+		const { routeNotification } = await import("./router-C5hPk9YP.mjs");
+		const { loadConfig } = await import("./config-DjXq_W42.mjs");
 		const mins = since ? Math.max(1, Math.round((Date.now() - since) / 6e4)) : null;
 		await routeNotification({
 			event: "completion",
@@ -121,7 +121,6 @@ async function retryConnect(attempt, waitForever, label) {
 		const result = await attempt();
 		if ("backend" in result) {
 			if (attemptN > 1) process.stderr.write(`[pai-daemon] Connected to ${label} (after ${attemptN} attempts).\n`);
-			else process.stderr.write(`[pai-daemon] Connected to ${label}.\n`);
 			clearBackendOutage();
 			if (escalated) notifyBackendRecovered(attemptN, outageSince);
 			return result.backend;
@@ -210,7 +209,7 @@ function registerBeforeExit() {
 */
 async function getStorageBackend() {
 	if (!storagePromise) storagePromise = (async () => {
-		const { loadConfig } = await import("./config-DCYWFaEi.mjs");
+		const { loadConfig } = await import("./config-DjXq_W42.mjs");
 		registerBeforeExit();
 		return await createStorageBackend(loadConfig());
 	})();
@@ -219,7 +218,7 @@ async function getStorageBackend() {
 /** Returns the process-wide RegistryBackend, creating it on first call. Same synchronous-caching requirement as getStorageBackend(). */
 async function getRegistryBackend() {
 	if (!registryPromise) registryPromise = (async () => {
-		const { loadConfig } = await import("./config-DCYWFaEi.mjs");
+		const { loadConfig } = await import("./config-DjXq_W42.mjs");
 		registerBeforeExit();
 		return await createRegistryBackend(loadConfig());
 	})();
@@ -247,4 +246,4 @@ async function closeStorage() {
 
 //#endregion
 export { getStorageBackend as a, getRegistryBackend as i, createRegistryBackend as n, getBackendOutage as o, createStorageBackend as r, humanDuration as s, closeStorage as t };
-//# sourceMappingURL=factory-DiuntvwG.mjs.map
+//# sourceMappingURL=factory-EUUhSSoq.mjs.map

package/dist/factory-EUUhSSoq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory-EUUhSSoq.mjs","names":[],"sources":["../src/storage/outage.ts","../src/storage/factory.ts"],"sourcesContent":["/**\n * outage.ts — is the storage backend actually reachable right now?\n *\n * The daemon retries a dead backend forever, which is correct: a Postgres\n * container that is down will usually come back, and giving up would lose the\n * work queue. What was wrong is that it did so in complete silence.\n *\n * Observed 2026-07-26: the container was down for roughly two days. The daemon\n * logged \"Postgres unavailable\" 144 times over 36 minutes, the work queue backed\n * up, session notes for the whole period were never written — and\n * `pai daemon status` reported \"Index: idle\" throughout. The one command anyone\n * would run to check said everything was fine.\n *\n * So the outage is recorded where the status command can see it, and escalated\n * once through the notification channels that were already configured and\n * already unused for this.\n */\n\nexport interface BackendOutage {\n  backend: string;\n  /** When the current run of failures began. */\n  since: number;\n  /** Consecutive failed attempts so far. */\n  attempts: number;\n  lastError: string;\n}\n\nlet current: BackendOutage | null = null;\n\n/** Record that the backend is currently unreachable. */\nexport function setBackendOutage(outage: BackendOutage): void {\n  current = outage;\n}\n\n/**\n * Record that the backend answered.\n *\n * Called on every successful connection, including the first — so a daemon that\n * never had a problem reports none, and one that recovered stops reporting an\n * outage that has ended.\n */\nexport function clearBackendOutage(): void {\n  current = null;\n}\n\n/** The current outage, or null when the backend is answering. */\nexport function getBackendOutage(): BackendOutage | null {\n  return current;\n}\n\n/**\n * Human-readable elapsed time, for a status line rather than a log.\n *\n * Exported because the status command needs the duration on its own, to colour\n * it separately from the rest of the sentence. Without this it kept a second\n * copy of the same rounding, which is how two renderings of one outage drift.\n */\nexport function humanDuration(ms: number): string {\n  const mins = Math.max(1, Math.round(ms / 60_000));\n  return mins < 60 ? `${mins} min` : `${(mins / 60).toFixed(1)} h`;\n}\n\n/** Human-readable duration, for a status line rather than a log. */\nexport function describeOutage(o: BackendOutage, now = Date.now()): string {\n  return `${o.backend} unreachable for ${humanDuration(now - o.since)}, ${o.attempts} attempts — ${o.lastError}`;\n}\n","/**\n * Storage backend factory.\n *\n * Reads the daemon config and returns the appropriate StorageBackend.\n *\n * When Postgres is the configured backend we NEVER silently fall back to\n * SQLite — doing so would split the corpus across two databases. Instead:\n *  - Daemon (waitForPostgres: true) retries Postgres forever with capped\n *    backoff until it comes up (handles the boot race where launchd starts\n *    the daemon before Docker Desktop / Postgres is ready).\n *  - CLI / one-shot callers (default) retry a few times, then throw a clear\n *    error rather than returning a wrong/empty SQLite database.\n */\n\nimport type { PaiDaemonConfig } from \"../daemon/config.js\";\nimport type { StorageBackend } from \"./interface.js\";\nimport type { RegistryBackend } from \"./registry-interface.js\";\nimport { setBackendOutage, clearBackendOutage } from \"./outage.js\";\n\nexport interface StorageBackendOptions {\n  /**\n   * When true, retry Postgres indefinitely instead of giving up. Used by the\n   * long-lived daemon so a not-yet-ready Postgres at boot is tolerated.\n   * Defaults to false (one-shot CLI behaviour: bounded retries, then throw).\n   */\n  waitForPostgres?: boolean;\n}\n\n/** Backoff schedule (ms) for the bounded CLI retry path. */\nconst CLI_RETRY_DELAYS_MS = [500, 1_000, 2_000];\n\n/** Backoff cap (ms) for the daemon's infinite retry path. */\nconst DAEMON_RETRY_CAP_MS = 15_000;\n\n/**\n * Create and return the configured StorageBackend.\n *\n * Auto-behaviour:\n *  - storageBackend = \"sqlite\"   → SQLiteBackend always\n *  - storageBackend = \"postgres\" → PostgresBackend (retried; never falls back)\n */\nexport async function createStorageBackend(\n  config: PaiDaemonConfig,\n  opts: StorageBackendOptions = {}\n): Promise<StorageBackend> {\n  if (config.storageBackend === \"postgres\") {\n    return await getSharedPostgresBackend(config, opts.waitForPostgres ?? false);\n  }\n\n  // Default: SQLite\n  return createSQLiteBackend();\n}\n\n/**\n * Attempt a single Postgres connection (ensure DB + test). Returns the live\n * backend on success, or an error string describing why it failed.\n */\nasync function attemptPostgres(\n  config: PaiDaemonConfig\n): Promise<{ backend: StorageBackend } | { error: string }> {\n  const { PostgresBackend } = await import(\"./postgres.js\");\n  const pgConfig = config.postgres ?? {};\n\n  let backend: InstanceType<typeof PostgresBackend> | null = null;\n  try {\n    // Ensure the per-user database exists and has the schema applied.\n    await PostgresBackend.ensureDatabase(pgConfig);\n\n    backend = new PostgresBackend(pgConfig);\n    const err = await backend.testConnection();\n    if (err) {\n      await backend.close().catch(() => {});\n      return { error: err };\n    }\n    return { backend };\n  } catch (e) {\n    if (backend) await backend.close().catch(() => {});\n    return { error: e instanceof Error ? e.message : String(e) };\n  }\n}\n\n/**\n * Consecutive failures before the outage is escalated to the user.\n *\n * Not the first failure: a container restarting, or the daemon starting before\n * Docker is up, recovers within a few seconds and is not worth a notification.\n * By the fifth attempt the backoff has already spent tens of seconds, which is\n * long enough that something is actually wrong.\n */\nconst ESCALATE_AFTER_ATTEMPTS = 5;\n\n/** Tell the user the backend is down, through whatever channels are configured. */\nasync function notifyBackendDown(attempts: number, lastError: string): Promise<void> {\n  try {\n    const { routeNotification } = await import(\"../notifications/router.js\");\n    const { loadConfig } = await import(\"../daemon/config.js\");\n    await routeNotification(\n      {\n        event: \"error\",\n        title: \"PAI: storage backend unreachable\",\n        message:\n          `Postgres has not answered in ${attempts} attempts (${lastError}). ` +\n          `Indexing, session notes and the work queue are stalled until it returns. ` +\n          `Check the container, then \\`pai daemon status\\`.`,\n      },\n      loadConfig().notifications\n    );\n  } catch {\n    // A notification that cannot be sent must never take the daemon down with\n    // it — the daemon retrying is still the useful behaviour here.\n  }\n}\n\n/** And say when it comes back, so the alert is not left hanging. */\nasync function notifyBackendRecovered(\n  attempts: number,\n  since: number | null\n): Promise<void> {\n  try {\n    const { routeNotification } = await import(\"../notifications/router.js\");\n    const { loadConfig } = await import(\"../daemon/config.js\");\n    const mins = since ? Math.max(1, Math.round((Date.now() - since) / 60_000)) : null;\n    await routeNotification(\n      {\n        event: \"completion\",\n        title: \"PAI: storage backend back\",\n        message:\n          `Postgres answered after ${attempts} attempts` +\n          (mins ? `, ${mins} min down` : \"\") +\n          `. The queue will drain on its own.`,\n      },\n      loadConfig().notifications\n    );\n  } catch {\n    /* same reasoning as above */\n  }\n}\n\n/**\n * Shared retry loop: attempt a connection, back off, escalate, repeat — used\n * by both the federation and registry Postgres connectors so the retry/outage\n * behaviour (§6, \"never falls back to SQLite silently\") stays in one place.\n */\nasync function retryConnect<T>(\n  attempt: () => Promise<{ backend: T } | { error: string }>,\n  waitForever: boolean,\n  label: string\n): Promise<T> {\n  let attemptN = 0;\n  let outageSince: number | null = null;\n  let escalated = false;\n\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    attemptN++;\n    const result = await attempt();\n    if (\"backend\" in result) {\n      if (attemptN > 1) process.stderr.write(`[pai-daemon] Connected to ${label} (after ${attemptN} attempts).\\n`);\n      // An outage that ended must stop being reported, or the status command\n      // trades one wrong answer for another.\n      clearBackendOutage();\n      if (escalated) void notifyBackendRecovered(attemptN, outageSince);\n      return result.backend;\n    }\n\n    const lastError = result.error;\n\n    if (!waitForever && attemptN > CLI_RETRY_DELAYS_MS.length) {\n      // Bounded CLI path exhausted — fail loudly, never silently use SQLite.\n      throw new Error(\n        `${label} unreachable after ${attemptN} attempts: ${lastError}. ` +\n          `Is Docker Desktop / Postgres running? Refusing to fall back to SQLite ` +\n          `(would split the corpus). Start Postgres and retry.`\n      );\n    }\n\n    const delayMs = waitForever\n      ? Math.min(DAEMON_RETRY_CAP_MS, 1_000 * 2 ** Math.min(attemptN - 1, 4))\n      : CLI_RETRY_DELAYS_MS[attemptN - 1];\n\n    process.stderr.write(\n      `[pai-daemon] ${label} unavailable (${lastError}). ` +\n        `Retry ${attemptN}${waitForever ? \"\" : `/${CLI_RETRY_DELAYS_MS.length + 1}`} ` +\n        `in ${delayMs}ms...\\n`\n    );\n\n    // Publish the outage so `pai daemon status` can report it. Without this the\n    // daemon retries silently forever and status still reads \"idle\" — which is\n    // what happened for two days in July: 144 retries over 36 minutes, session\n    // notes never written, and the one command anyone would run to check\n    // reporting that everything was fine.\n    setBackendOutage({\n      backend: label,\n      since: outageSince ?? (outageSince = Date.now()),\n      attempts: attemptN,\n      lastError: String(lastError),\n    });\n\n    // And escalate once, out loud, rather than only into a log nobody tails.\n    // Once — not per retry — because a notification that repeats every few\n    // seconds is filtered within a minute and stops being a signal at all.\n    if (waitForever && attemptN === ESCALATE_AFTER_ATTEMPTS && !escalated) {\n      escalated = true;\n      void notifyBackendDown(attemptN, String(lastError));\n    }\n\n    await new Promise((r) => setTimeout(r, delayMs));\n  }\n}\n\nasync function connectPostgres(\n  config: PaiDaemonConfig,\n  waitForever: boolean\n): Promise<StorageBackend> {\n  return retryConnect(() => attemptPostgres(config), waitForever, \"PostgreSQL backend\");\n}\n\n/**\n * The process's one Postgres connection: storage and registry share a\n * single pg Pool (one connection budget) instead of each opening their own.\n * Whichever of createStorageBackend()/createRegistryBackend() runs first\n * creates it via connectPostgres()'s retry/outage handling; the other\n * reuses its pool through PostgresBackend.getPool(). Reset by closeStorage().\n */\nlet pgBackendPromise: Promise<StorageBackend> | null = null;\n\nfunction getSharedPostgresBackend(\n  config: PaiDaemonConfig,\n  waitForever: boolean\n): Promise<StorageBackend> {\n  if (!pgBackendPromise) {\n    pgBackendPromise = connectPostgres(config, waitForever);\n  }\n  return pgBackendPromise;\n}\n\nasync function createSQLiteBackend(): Promise<StorageBackend> {\n  const { openFederation } = await import(\"./sqlite/federation-db.js\");\n  const { SQLiteBackend } = await import(\"./sqlite.js\");\n  const db = openFederation();\n  return new SQLiteBackend(db);\n}\n\n/**\n * Create and return the configured RegistryBackend (projects, sessions,\n * tags, aliases, links, compaction_log). Same auto-behaviour and same\n * never-fall-back-to-SQLite rule as createStorageBackend().\n */\nexport async function createRegistryBackend(\n  config: PaiDaemonConfig,\n  opts: StorageBackendOptions = {}\n): Promise<RegistryBackend> {\n  if (config.storageBackend === \"postgres\") {\n    // Reuses the storage backend's pool (getSharedPostgresBackend) rather\n    // than opening a second one against the same database.\n    const storage = await getSharedPostgresBackend(config, opts.waitForPostgres ?? false);\n    const { PostgresRegistryBackend } = await import(\"./registry-postgres.js\");\n    const pool = (storage as unknown as { getPool: () => import(\"pg\").Pool }).getPool();\n    return new PostgresRegistryBackend(pool);\n  }\n  return createSQLiteRegistryBackend();\n}\n\nasync function createSQLiteRegistryBackend(): Promise<RegistryBackend> {\n  const { openRegistry } = await import(\"./sqlite/registry-db.js\");\n  const { SQLiteRegistryBackend } = await import(\"./registry-sqlite.js\");\n  const db = openRegistry();\n  return new SQLiteRegistryBackend(db);\n}\n\n/**\n * Process-wide backend accessors.\n *\n * Callers across the codebase must get their StorageBackend/RegistryBackend\n * from here rather than constructing SQLite or Postgres directly — this is\n * the one place that decides which backend a process uses, and the one place\n * that closes it on exit.\n */\n\nlet storagePromise: Promise<StorageBackend> | null = null;\nlet registryPromise: Promise<RegistryBackend> | null = null;\nlet beforeExitRegistered = false;\n\nfunction registerBeforeExit(): void {\n  if (beforeExitRegistered) return;\n  beforeExitRegistered = true;\n  process.once(\"beforeExit\", () => {\n    void closeStorage();\n  });\n}\n\n/**\n * Returns the process-wide StorageBackend, creating it on first call.\n *\n * The whole body up to and including the `storagePromise = (async () =>\n * ...)()` assignment must run synchronously (no `await` before it) — two\n * calls issued in the same tick (e.g. `Promise.all([get(), get()])`) must\n * both observe the same cached promise rather than each racing to create\n * their own backend.\n */\nexport async function getStorageBackend(): Promise<StorageBackend> {\n  if (!storagePromise) {\n    storagePromise = (async () => {\n      const { loadConfig } = await import(\"../daemon/config.js\");\n      registerBeforeExit();\n      return await createStorageBackend(loadConfig());\n    })();\n  }\n  return storagePromise;\n}\n\n/** Returns the process-wide RegistryBackend, creating it on first call. Same synchronous-caching requirement as getStorageBackend(). */\nexport async function getRegistryBackend(): Promise<RegistryBackend> {\n  if (!registryPromise) {\n    registryPromise = (async () => {\n      const { loadConfig } = await import(\"../daemon/config.js\");\n      registerBeforeExit();\n      return await createRegistryBackend(loadConfig());\n    })();\n  }\n  return registryPromise;\n}\n\n/** Closes any backends created via getStorageBackend()/getRegistryBackend(). Idempotent. */\nexport async function closeStorage(): Promise<void> {\n  const pending = [storagePromise, registryPromise];\n  const pg = pgBackendPromise;\n  storagePromise = null;\n  registryPromise = null;\n  pgBackendPromise = null;\n  for (const p of pending) {\n    if (!p) continue;\n    try {\n      const backend = await p;\n      // Postgres backends share one pool owned by pgBackendPromise (closed\n      // below) — closing them here too would end() it twice.\n      if (backend.backendType === \"postgres\") continue;\n      await backend.close();\n    } catch {\n      // A backend that never connected has nothing to close.\n    }\n  }\n  if (pg) {\n    try {\n      await (await pg).close();\n    } catch {\n      // Never connected — nothing to close.\n    }\n  }\n}\n\n/** Test-only: clear the process-wide cache without closing (tests own their own lifecycle). */\nexport function __resetStorageForTests(): void {\n  storagePromise = null;\n  registryPromise = null;\n  pgBackendPromise = null;\n}\n"],"mappings":"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"}

package/dist/{fallback-B_2ozQHw.mjs → fallback-CjdakQVu.mjs}

@@ -1,7 +1,7 @@
-import { _ as writeYamlFileAtomic, d as readMainConfigRaw, f as writeMainConfigRaw, l as paiConfigFilePath, m as migrateMainConfigToYaml, n as CONFIG_FILE, r as DEFAULTS, s as loadConfig, u as paiConfigYamlFilePath, v as readJsonStrict, y as writeJsonAtomic } from "./config-D1omG_UU.mjs";
-import { C as providerCostTier, D as resolveModelCapability, E as resolveCapability, L as workersYamlPath, O as resolveProviderKey, S as nativeAnthropicProvider, T as readWorkersSection, _ as expandHome, a as DEFAULT_CACHE_KEEPALIVE_SECS, b as keysDir, c as DEFAULT_ROUTING, d as PROVIDER_TAGS, k as writeWorkersSection, l as DEFAULT_TREE, o as DEFAULT_LOG_DIR, p as WorkersConfigError, r as ANTHROPIC_NATIVE, s as DEFAULT_PANE, u as MODEL_CAPABILITIES, x as maskKey, y as isModelCapability } from "./run-env-DyTWgZC9.mjs";
-import { A as contextLabel, D as UNLABELED, G as shortText, I as loadStatuses, M as elapsedOf, N as isChatPane, O as ageOf, P as isLive, T as appendLedger, b as sessionTag, d as workerDepth, h as currentTabKey, j as contextPercent, k as alive, l as readInbox, o as parseWorkerReport, s as renderReport, u as sayToWorker, v as resolveSession, x as workerInScope } from "./run-XaA-UPdW.mjs";
-import { a as clearCooldown, c as probeQuota, d as resolveTarget, h as ledgerPath, l as quotaSkipThreshold, m as eventsPath, v as workersLogDir } from "./server-CzqHGbKt.mjs";
+import { _ as writeYamlFileAtomic, d as readMainConfigRaw, f as writeMainConfigRaw, l as paiConfigFilePath, m as migrateMainConfigToYaml, n as CONFIG_FILE, r as DEFAULTS, s as loadConfig, u as paiConfigYamlFilePath, v as readJsonStrict, y as writeJsonAtomic } from "./config-CQCmH_gV.mjs";
+import { C as providerCostTier, D as resolveModelCapability, E as resolveCapability, L as workersYamlPath, O as resolveProviderKey, S as nativeAnthropicProvider, T as readWorkersSection, _ as expandHome, a as DEFAULT_CACHE_KEEPALIVE_SECS, b as keysDir, c as DEFAULT_ROUTING, d as PROVIDER_TAGS, k as writeWorkersSection, l as DEFAULT_TREE, o as DEFAULT_LOG_DIR, p as WorkersConfigError, r as ANTHROPIC_NATIVE, s as DEFAULT_PANE, u as MODEL_CAPABILITIES, x as maskKey, y as isModelCapability } from "./run-env-CEHTeIUM.mjs";
+import { A as UNLABELED, C as workerInScope, F as elapsedOf, I as isChatPane, J as shortText, L as isLive, M as alive, N as contextLabel, O as appendLedger, P as contextPercent, S as sessionTag, _ as currentTabKey, b as resolveSession, d as workerDepth, g as markControlsHeld, h as clickrControlsArgv, j as ageOf, l as readInbox, o as parseWorkerReport, s as renderReport, u as sayToWorker, z as loadStatuses } from "./run-FeM1_UVa.mjs";
+import { a as clearCooldown, c as probeQuota, d as resolveTarget, h as ledgerPath, l as quotaSkipThreshold, m as eventsPath, v as workersLogDir } from "./server-CekGOJcp.mjs";
 import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join, relative, resolve } from "node:path";
@@ -251,6 +251,7 @@ const CHAT_HELP = [
 	"/quit            close this pane",
 	"/resume <text>   continue the finished worker with <text>",
 	"/status          one-line worker status",
+	"your controls    exclusive clickr control to this worker (my controls takes it back)",
 	"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). */
@@ -454,11 +455,14 @@ function chatInsertLine(line, fill, regionRows) {
 		fill: Math.min(fill + 1, regionRows)
 	};
 }
+const CONTROLS_LINE = /^(your|my) controls\.?$/i;
 /**
 * 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.
+* with empty text so the caller can print its usage); "your controls" /
+* "my controls" is the same `pai worker controls <id> you|me` action, never
+* forwarded to the worker as a normal chat line; anything else, including
+* any other `/word`, is a message for the worker.
 */
 function parseChatLine(raw) {
 	const text = raw.trim();
@@ -469,6 +473,11 @@ function parseChatLine(raw) {
 		kind: "resume",
 		text: text.slice(7).trim()
 	};
+	const controls = text.match(CONTROLS_LINE);
+	if (controls) return {
+		kind: "controls",
+		who: controls[1].toLowerCase() === "your" ? "you" : "me"
+	};
 	return {
 		kind: "message",
 		text
@@ -1239,6 +1248,25 @@ async function followWorkers(logDir, target, showAll, autoExit, env = process.en
 			} else noteLine(c("red", `» resume failed (rc=${rc})`));
 		});
 	};
+	const spawnControls = io?.spawnControls ?? ((id, who, pid) => spawn("clickr", clickrControlsArgv(id, who, pid), { stdio: [
+		"ignore",
+		"pipe",
+		"pipe"
+	] }));
+	const controlsTarget = (id, who) => {
+		const pid = loadStatuses(logDir).find((s) => s.id === id)?.pid;
+		const child = spawnControls(id, who, pid);
+		let errText = "";
+		child.stderr?.on("data", (chunk) => {
+			errText += chunk.toString("utf8");
+		});
+		child.on("close", (rc) => {
+			if (rc === 0) {
+				if (who === "you") markControlsHeld(logDir, id);
+				noteLine(c("dim", `» controls → ${who === "you" ? `${id} (exclusive; needs clickr with --agent support)` : "operator"}`));
+			} else noteLine(c("red", `» controls failed (rc=${rc})${errText.trim() ? `: ${errText.trim()}` : ""}`));
+		});
+	};
 	const handleOperatorLine = makeOperatorInput({
 		target: () => target,
 		say: (id, text) => sayToWorker(logDir, id, text),
@@ -1313,6 +1341,10 @@ async function followWorkers(logDir, target, showAll, autoExit, env = process.en
 					redrew = true;
 					echoOperator(act.text);
 					break;
+				case "controls":
+					if (target !== null) controlsTarget(target, act.who);
+					else out(c("dim", "no target worker for controls"));
+					break;
 				case "help":
 					for (const ln of CHAT_HELP) out(c("dim", ln));
 					break;
@@ -1669,12 +1701,51 @@ function removeProvider(name, configPath) {
 	writeWorkersSection(raw, workers, configPath);
 	return workers;
 }
+/**
+* Point a class target at `name`, keeping every other field. Only touches
+* targets that already pin a provider — a constraint-only object (no
+* `provider`) only narrows auto-routing and is left alone. A string target's
+* `/alias` is dropped (falling back to `name`'s default model) when `name`
+* has no such model configured — the class must move to `name` either way,
+* since leaving it on the old provider is exactly the bug this fixes.
+*/
+function repointClassTarget(target, name, providers) {
+	if (typeof target === "string") {
+		const [provider, alias] = target.split("/");
+		if (provider === name) return null;
+		if (alias && name !== ANTHROPIC_NATIVE && alias !== "default" && !providers[name]?.models[alias]) return name;
+		return alias ? `${name}/${alias}` : name;
+	}
+	if (!target.provider || target.provider === name) return null;
+	return {
+		...target,
+		provider: name
+	};
+}
+/**
+* Make `name` the active provider. Unless `name` is "auto", also re-points
+* every class whose target pins a provider (string or `{provider: …}`) at
+* it — a class pinned to a provider otherwise wins over `active` at run time
+* (routing.ts resolveTarget), so leaving classes untouched would make `use`
+* silently do nothing for any class already pinned elsewhere.
+*/
 function useProvider(name, configPath) {
 	const { raw, workers } = readWorkersSection(configPath);
-	if (name !== ANTHROPIC_NATIVE && !workers.providers[name]) throw new WorkersConfigError(`no provider named "${name}". Configured: ${Object.keys(workers.providers).join(", ") || "(none)"}`);
+	if (name !== ANTHROPIC_NATIVE && name !== "auto" && !workers.providers[name]) throw new WorkersConfigError(`no provider named "${name}". Configured: ${Object.keys(workers.providers).join(", ") || "(none)"}`);
 	workers.active = name;
+	let repointed = 0;
+	if (name !== "auto") for (const [cls, target] of Object.entries(workers.classes)) {
+		const next = repointClassTarget(target, name, workers.providers);
+		if (next !== null) {
+			workers.classes[cls] = next;
+			repointed++;
+		}
+	}
 	writeWorkersSection(raw, workers, configPath);
-	return workers;
+	return {
+		workers,
+		repointed
+	};
 }
 /**
 * The provider a model command targets: the named one, else the active one.
@@ -2135,4 +2206,4 @@ function fallbackStatusText(s) {
 
 //#endregion
 export { getConfigValueOp as A, psOutput as C, resolveSpecPath as D, readSpecPrompt as E, setConfigValueOp as M, unsetConfigValueOp as N, MainConfigOpsError as O, followWorkers as S, statusLineOutput as T, setWorkersEnabled as _, addProvider as a, updateProvider as b, describeModels as c, removeProvider as d, resolveProviderName as f, setProviderModel as g, setProviderEnabled as h, fallbackStatusText as i, listConfigOp as j, formatConfigGetOutput as k, describeProviders as l, setClass as m, fallbackOn as n, classTargetText as o, setCapabilityPreference as p, fallbackStatus as r, describeCapabilities as s, fallbackOff as t, modelPrefsText as u, unsetCapabilityPreference as v, replayOutput as w, useProvider as x, unsetClass as y };
-//# sourceMappingURL=fallback-B_2ozQHw.mjs.map
+//# sourceMappingURL=fallback-CjdakQVu.mjs.map