@chibitek/chibi 0.1.154 → 0.1.157

package/dist-server/server/app-installers.js

@@ -1,6 +1,6 @@
 // Download and install the two desktop apps the setup wizard offers, after
 // the person clicks: Ollama (free local AI) and Podman (a separate computer
-// for bots). macOS only; elsewhere the wizard links to the vendor's page.
+// for bots). Ollama installs on macOS, Windows and Linux; Podman on macOS.
 //
 // Every download is the vendor's own GitHub release asset, found through
 // GitHub's release API, and is checked three ways before anything runs:
@@ -12,16 +12,22 @@
 // ollama.com/download redirects to the same GitHub release asset.
 //
 // Ollama is unpacked with ditto, moved to /Applications (or ~/Applications
-// when /Applications is not writable), and opened. Podman's package needs an
+// when /Applications is not writable), and opened. On Windows its signed
+// OllamaSetup.exe (Authenticode signer O=Ollama Inc., the check Ollama's own
+// install.ps1 makes) runs silently into %LOCALAPPDATA%\Programs\Ollama, no
+// administrator needed. On Linux, where Ollama ships no signature, the
+// SHA-256 alone gates the tarball, unpacked into ~/.local (no sudo, no
+// service): ~/.local/bin/ollama, started as `ollama serve`. Podman's package needs an
 // administrator's approval, so Atomic opens it in Apple's Installer app,
 // which asks for it; nobody types a command.
 import { createHash } from "node:crypto";
-import { accessSync, constants, createWriteStream, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync } from "node:fs";
+import { accessSync, constants, createReadStream, createWriteStream, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { execFileCommand } from "./procs.js";
+import { createZstdDecompress } from "node:zlib";
+import { execFileCommand, spawnCommand } from "./procs.js";
 export const APP_INSTALLERS = Object.freeze({
     ollama: { repo: "ollama/ollama", asset: () => "Ollama-darwin.zip", teamId: "3MU9H2V9Y9", kind: "zip-app", appName: "Ollama.app" },
     podman: {
@@ -58,7 +64,7 @@ export function runTool(command, args, timeoutMs = 120_000) {
 export async function latestReleaseAsset(spec, arch, fetchImpl = fetch, signal) {
     const name = spec.asset(arch);
     if (!name)
-        throw new AppInstallError("unsupported", `No ${spec.repo} installer is published for ${arch} Macs.`);
+        throw new AppInstallError("unsupported", `No ${spec.repo} installer is published for ${arch} computers.`);
     let response;
     try {
         response = await fetchImpl(`https://api.github.com/repos/${spec.repo}/releases/latest`, {
@@ -166,10 +172,104 @@ function writableDir(dir) {
         return false;
     }
 }
+/** Ollama's release asset on Windows and Linux. */
+export const OLLAMA_WINDOWS_ASSET = "OllamaSetup.exe";
+export const ollamaLinuxAsset = (arch) => (arch === "x64" ? "ollama-linux-amd64.tar.zst" : arch === "arm64" ? "ollama-linux-arm64.tar.zst" : null);
+/** Where Atomic's Ollama lives off macOS: the per-user Windows install, or
+ * the ~/.local unpack on Linux. */
+export function ollamaBinaryHere(platform = process.platform, env = process.env) {
+    if (platform === "win32")
+        return join(env.LOCALAPPDATA || join(homedir(), "AppData", "Local"), "Programs", "Ollama", "ollama.exe");
+    if (platform === "linux")
+        return join(homedir(), ".local", "bin", "ollama");
+    return null;
+}
+/** The Windows installer is signed by Ollama Inc. (Authenticode, valid). */
+export async function verifyWindowsSignature(file, run = runTool) {
+    const script = `$s = Get-AuthenticodeSignature -LiteralPath '${file.replace(/'/g, "''")}'; "$($s.Status)|$($s.SignerCertificate.Subject)"`;
+    let stdout;
+    try {
+        ({ stdout } = await run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script]));
+    }
+    catch (error) {
+        throw new AppInstallError("verify", `Windows could not check the installer's signature: ${String(error)}`);
+    }
+    const [status, subject = ""] = stdout.trim().split("|");
+    if (status !== "Valid" || !/(^|, )O=Ollama Inc\.(,|$)/.test(subject)) {
+        throw new AppInstallError("verify", `The installer is not signed by Ollama Inc. (${status}: ${subject}).`);
+    }
+}
+async function installOllamaWindows(deps, run) {
+    const asset = await latestReleaseAsset({ ...APP_INSTALLERS.ollama, asset: () => OLLAMA_WINDOWS_ASSET }, deps.arch ?? process.arch, deps.fetch, deps.signal);
+    const work = mkdtempSync(join(tmpdir(), "atomic-ollama-"));
+    try {
+        const setup = join(work, asset.name);
+        await downloadAsset(asset, setup, deps);
+        deps.onProgress?.({ phase: "verifying" });
+        await verifyWindowsSignature(setup, run);
+        deps.onProgress?.({ phase: "installing" });
+        // Per-user install; the installer opens the Ollama app when it is done.
+        await run(setup, ["/VERYSILENT", "/NORESTART", "/SUPPRESSMSGBOXES"]).catch((error) => {
+            throw new AppInstallError("install", `The Ollama installer stopped: ${String(error)}`);
+        });
+        deps.onProgress?.({ phase: "starting" });
+        return { appPath: ollamaBinaryHere("win32"), version: asset.version };
+    }
+    finally {
+        rmSync(work, { recursive: true, force: true });
+    }
+}
+async function installOllamaLinux(deps, run) {
+    const asset = await latestReleaseAsset({ ...APP_INSTALLERS.ollama, asset: ollamaLinuxAsset }, deps.arch ?? process.arch, deps.fetch, deps.signal);
+    const work = mkdtempSync(join(tmpdir(), "atomic-ollama-"));
+    try {
+        const packed = join(work, asset.name);
+        await downloadAsset(asset, packed, deps);
+        deps.onProgress?.({ phase: "installing" });
+        const tar = join(work, "ollama.tar");
+        await pipeline(createReadStream(packed), createZstdDecompress(), createWriteStream(tar), { signal: deps.signal });
+        rmSync(packed, { force: true });
+        const prefix = join(homedir(), ".local");
+        mkdirSync(prefix, { recursive: true });
+        await run("tar", ["-xf", tar, "-C", prefix]).catch((error) => {
+            throw new AppInstallError("install", `Could not unpack Ollama into ${prefix}: ${String(error)}`);
+        });
+        deps.onProgress?.({ phase: "starting" });
+        startOllamaApp("linux");
+        return { appPath: ollamaBinaryHere("linux"), version: asset.version };
+    }
+    catch (error) {
+        if (error instanceof AppInstallError)
+            throw error;
+        throw new AppInstallError(deps.signal?.aborted ? "cancelled" : "install", error instanceof Error ? error.message : String(error));
+    }
+    finally {
+        rmSync(work, { recursive: true, force: true });
+    }
+}
+/** Start the installed Ollama the way each OS runs it: the app on macOS and
+ * Windows (it starts its own server), `ollama serve` on Linux. Returns at
+ * once; callers wait for it to answer. */
+export function startOllamaApp(platform = process.platform, run = runTool) {
+    if (platform === "darwin") {
+        void run("/usr/bin/open", ["-a", "Ollama"]).catch(() => undefined);
+        return;
+    }
+    const binary = ollamaBinaryHere(platform);
+    const command = platform === "win32" && binary ? join(binary, "..", "ollama app.exe") : existsSync(binary ?? "") ? binary : "ollama";
+    const child = spawnCommand(command, platform === "win32" ? [] : ["serve"], { detached: true, stdio: "ignore", windowsHide: true });
+    child.on("error", () => undefined);
+    child.unref();
+}
 /** Download, verify, install and open Ollama. Resolves with where it went. */
 export async function installOllamaApp(deps = {}) {
-    if ((deps.platform ?? process.platform) !== "darwin")
-        throw new AppInstallError("unsupported", "Atomic installs Ollama for you on macOS only.");
+    const platform = deps.platform ?? process.platform;
+    if (platform === "win32" || platform === "linux") {
+        deps.onProgress?.({ phase: "finding" });
+        return (platform === "win32" ? installOllamaWindows : installOllamaLinux)(deps, deps.run ?? ((command, args) => runTool(command, args, 15 * 60_000)));
+    }
+    if (platform !== "darwin")
+        throw new AppInstallError("unsupported", `Atomic cannot install Ollama on ${platform}.`);
     const spec = APP_INSTALLERS.ollama;
     const run = deps.run ?? runTool;
     deps.onProgress?.({ phase: "finding" });

package/dist-server/server/cli-help.js

@@ -0,0 +1,74 @@
+export const USAGE = `chibi — your team of AI bots, ready in a few steps
+
+  chibi                               set up once, then open your workspace
+  chibi setup [--data-dir DIR]
+  chibi start [the same options as serve]
+  chibi serve [--port 8799] [--data-dir DIR] [--label NAME]
+                    [--public-url https://host] [--tailscale | --tunnel | --domain HOST] [--no-pair]
+  chibi pair  [--label NAME] [--client] [--phone ios|android]
+                    [--public-url https://host]
+  chibi sessions [revoke ID]
+  chibi status
+  chibi login [--email you@example.com]
+  chibi logout
+  chibi command --bot ID|--group ID --thread ID --text "/goal status" [--port 8799]
+  chibi goal --bot ID --thread ID --text "--tokens 100000 objective"
+  chibi access list | add EMAIL [--chat-only] | remove EMAIL
+  chibi service install [--domain HOST | --tunnel | --tailscale] [--port N] [--data-dir DIR] | uninstall
+  chibi browser install [--with-deps] | status
+  chibi fleet init --domain HOST [--operator USER] | create NAME --admin EMAIL [--member EMAIL] [--brand FILE]
+                    [--anthropic-key-file FILE] [--cap USD] [--license-key KEY] [--memory 1G]
+                  | list | users NAME add|remove EMAIL [--chat-only] | suspend NAME | resume NAME
+                  | delete NAME --yes [--keep-data] | upgrade   (all take --dry-run)
+                  | agent [--socket PATH] [--group USER]   (root; installed by init --operator)
+
+setup   choose AI access and optional phone access; keep existing bots and chats
+start   same as chibi: use your saved settings and open the workspace
+serve   starts the server without prompts and prints a pairing link + QR code
+pair    mints a pairing code against a running server (--client: chat only)
+sessions lists paired devices; "sessions revoke ID" signs one out
+status  what the server says about itself
+login   signs this machine in to an Atomic account (an emailed code)
+        and reserves its public address for --tunnel
+logout  releases that address and signs out
+access  who may sign in with an emailed code at /pair: an address or
+        @domain; --chat-only gives chat and approvals without settings.
+        Takes effect at once, no restart.
+service keep the server running across reboots: writes a systemd unit
+        (Linux) or a launchd agent (macOS) for the same serve options and
+        prints the commands that install it. Install the package
+        permanently first (npm install -g @chibitek/chibi).
+browser install: the bots' browser engine (agent-browser, pinned) into the
+        data dir, and Chrome for Testing into the user's browser cache.
+        --with-deps also installs
+        the Linux libraries Chrome needs (run as root once). Then run
+        browser install as the user running serve, from that user's home.
+        status: what the current user and data directory have.
+fleet   many client workspaces on one Linux server, each its own account,
+        service, data folder, brand, sign-in list and keys at NAME.HOST
+        behind the system Caddy. Plans are printed unless run as root;
+        --dry-run always prints. Install the package permanently first.
+        init --operator USER also installs the fleet agent, a root service
+        on a Unix socket only USER may open, so the workspace running as
+        USER manages the others from Settings → Workspaces.
+
+--tailscale  serve over your tailnet: Tailscale terminates HTTPS and the
+             link uses this machine's MagicDNS name (needs Tailscale signed in
+             and HTTPS certificates enabled for the tailnet)
+--tunnel     serve at a public HTTPS address through a Cloudflare tunnel
+             from a hosted control plane (set OMB_CONTROL_PLANE_URL; Atomic
+             ships none). Run \`chibi login\` once on this machine first.
+--domain     serve at https://HOST on your own domain: a pinned Caddy is
+             downloaded once and run alongside the server, and gets the
+             certificate itself. Point the domain's DNS at this machine and
+             open ports 80 and 443.
+
+--no-open   do not open a browser window
+--no-pair   skip phone setup and do not print a pairing code
+--local     start locally this time, ignoring saved remote-access settings
+--quiet     skip the welcome banner (it never shows when output is piped;
+            NO_COLOR=1 shows it without color)
+
+Install once with \`npm install -g @chibitek/chibi\`, then type \`chibi\`.
+Or run without a global install: \`npx @chibitek/chibi\`. Node 24+ is required.
+`;

package/dist-server/server/cli.js

@@ -1,3 +1,5 @@
+import { USAGE } from "./cli-help.js";
+export { USAGE } from "./cli-help.js";
 // `chibi` on the command line: run the server anywhere and pair devices
 // to it. One implementation for three homes — `npx @chibitek/chibi` (the npm
 // package), `node dist-server/cli.js` (the container image) and
@@ -47,7 +49,7 @@ import { defaultSetupIo, SetupCancelled } from "./cli-prompts.js";
 import { normalizePhoneOrigin, phonePairingInstructions, runPhoneSetup } from "./cli-phone-setup.js";
 import { cleanupTunnelOrigin, createTunnelAccount, createTunnelOrigin, describeTunnelAccount, describeTunnelState, ensureCloudflared, FLEET_CREDENTIAL_ENV, fleetAccess, fleetCredential, guardianEntry, startTunnel, tunnelAccess, } from "./tunnel.js";
 const HERE = dirname(fileURLToPath(import.meta.url));
-export const COMMANDS = ["setup", "start", "serve", "pair", "sessions", "status", "login", "logout", "access", "service", "browser", "fleet", "help", "--help", "-h"];
+export const COMMANDS = ["command", "goal", "setup", "start", "serve", "pair", "sessions", "status", "login", "logout", "access", "service", "browser", "fleet", "help", "--help", "-h"];
 export function parseArgs(argv, env = process.env) {
     const implicitStart = !argv.length || (argv[0].startsWith("--") && argv[0] !== "--help");
     const [command = "start", ...rest] = implicitStart ? ["start", ...argv] : argv;
@@ -76,7 +78,15 @@ export function parseArgs(argv, env = process.env) {
             return v;
         };
         try {
-            if (arg === "--port")
+            if ((options.command === "command" || options.command === "goal") && arg === "--bot")
+                options.botId = value();
+            else if ((options.command === "command" || options.command === "goal") && arg === "--group")
+                options.groupId = value();
+            else if ((options.command === "command" || options.command === "goal") && arg === "--thread")
+                options.threadId = value();
+            else if ((options.command === "command" || options.command === "goal") && arg === "--text")
+                options.commandText = value();
+            else if (arg === "--port")
                 options.port = Number(value());
             else if (arg === "--data-dir")
                 options.dataDir = resolve(value());
@@ -182,6 +192,8 @@ export function parseArgs(argv, env = process.env) {
         return { error: "--public-url must start with http:// or https://" };
     if (options.tailscale && options.tunnel)
         return { error: "choose one of --tailscale (your tailnet) and --tunnel (a public address)" };
+    if ((options.command === "command" || options.command === "goal") && (Boolean(options.botId) === Boolean(options.groupId) || !options.threadId || !options.commandText))
+        return { error: "command and goal require exactly one of --bot ID or --group ID, plus --thread ID --text TEXT" };
     if (options.command === "access" && !options.accessAction)
         return { error: "access needs one of: list, add EMAIL [--chat-only], remove EMAIL" };
     if (options.command === "service" && !options.serviceAction)
@@ -204,78 +216,6 @@ export function parseArgs(argv, env = process.env) {
     }
     return options;
 }
-export const USAGE = `chibi — your team of AI bots, ready in a few steps
-
-  chibi                               set up once, then open your workspace
-  chibi setup [--data-dir DIR]
-  chibi start [the same options as serve]
-  chibi serve [--port 8799] [--data-dir DIR] [--label NAME]
-                    [--public-url https://host] [--tailscale | --tunnel | --domain HOST] [--no-pair]
-  chibi pair  [--label NAME] [--client] [--phone ios|android]
-                    [--public-url https://host]
-  chibi sessions [revoke ID]
-  chibi status
-  chibi login [--email you@example.com]
-  chibi logout
-  chibi access list | add EMAIL [--chat-only] | remove EMAIL
-  chibi service install [--domain HOST | --tunnel | --tailscale] [--port N] [--data-dir DIR] | uninstall
-  chibi browser install [--with-deps] | status
-  chibi fleet init --domain HOST [--operator USER] | create NAME --admin EMAIL [--member EMAIL] [--brand FILE]
-                    [--anthropic-key-file FILE] [--cap USD] [--license-key KEY] [--memory 1G]
-                  | list | users NAME add|remove EMAIL [--chat-only] | suspend NAME | resume NAME
-                  | delete NAME --yes [--keep-data] | upgrade   (all take --dry-run)
-                  | agent [--socket PATH] [--group USER]   (root; installed by init --operator)
-
-setup   choose AI access and optional phone access; keep existing bots and chats
-start   same as chibi: use your saved settings and open the workspace
-serve   starts the server without prompts and prints a pairing link + QR code
-pair    mints a pairing code against a running server (--client: chat only)
-sessions lists paired devices; "sessions revoke ID" signs one out
-status  what the server says about itself
-login   signs this machine in to an Atomic account (an emailed code)
-        and reserves its public address for --tunnel
-logout  releases that address and signs out
-access  who may sign in with an emailed code at /pair: an address or
-        @domain; --chat-only gives chat and approvals without settings.
-        Takes effect at once, no restart.
-service keep the server running across reboots: writes a systemd unit
-        (Linux) or a launchd agent (macOS) for the same serve options and
-        prints the commands that install it. Install the package
-        permanently first (npm install -g @chibitek/chibi).
-browser install: the bots' browser engine (agent-browser, pinned) into the
-        data dir, and Chrome for Testing into the user's browser cache.
-        --with-deps also installs
-        the Linux libraries Chrome needs (run as root once). Then run
-        browser install as the user running serve, from that user's home.
-        status: what the current user and data directory have.
-fleet   many client workspaces on one Linux server, each its own account,
-        service, data folder, brand, sign-in list and keys at NAME.HOST
-        behind the system Caddy. Plans are printed unless run as root;
-        --dry-run always prints. Install the package permanently first.
-        init --operator USER also installs the fleet agent, a root service
-        on a Unix socket only USER may open, so the workspace running as
-        USER manages the others from Settings → Workspaces.
-
---tailscale  serve over your tailnet: Tailscale terminates HTTPS and the
-             link uses this machine's MagicDNS name (needs Tailscale signed in
-             and HTTPS certificates enabled for the tailnet)
---tunnel     serve at a public HTTPS address through a Cloudflare tunnel
-             from a hosted control plane (set OMB_CONTROL_PLANE_URL; Atomic
-             ships none). Run \`chibi login\` once on this machine first.
---domain     serve at https://HOST on your own domain: a pinned Caddy is
-             downloaded once and run alongside the server, and gets the
-             certificate itself. Point the domain's DNS at this machine and
-             open ports 80 and 443.
-
---no-open   do not open a browser window
---no-pair   skip phone setup and do not print a pairing code
---local     start locally this time, ignoring saved remote-access settings
---quiet     skip the welcome banner (it never shows when output is piped;
-            NO_COLOR=1 shows it without color)
-
-Install once with \`npm install -g @chibitek/chibi\`, then type \`chibi\`.
-Or run without a global install: \`npx @chibitek/chibi\`. Node 24+ is required.
-`;
 export function defaultIo() {
     return {
         log: (line) => console.log(line),
@@ -1232,6 +1172,24 @@ export async function main(argv = process.argv.slice(2)) {
         console.log(`\n${welcomeBanner(options)}\n`);
     }
     switch (options.command) {
+        case "command":
+        case "goal": {
+            const text = options.command === "goal" ? `/goal ${options.commandText}` : options.commandText;
+            const roomGoal = options.groupId ? /^\/goal(?:\s+([\s\S]*))?$/.exec(text ?? "") : null;
+            if (roomGoal && (!roomGoal[1]?.trim() || (roomGoal[1].startsWith("--") || /^(status|pause|resume|stop|help)(?:\s|$)/.test(roomGoal[1])))) {
+                console.error("Room goals accept an objective. Personal goal controls and budgets require --bot.");
+                return 2;
+            }
+            const result = await api(options.port, `/api/${options.groupId ? "groups" : "bots"}/${encodeURIComponent(options.groupId ?? options.botId)}/messages`, {
+                method: "POST", body: JSON.stringify({ threadId: options.threadId, text: roomGoal ? roomGoal[1] : text, ...(roomGoal ? { mode: "goal" } : {}), sendId: randomBytes(16).toString("hex") }),
+            });
+            if (result.status >= 400) {
+                console.error(result.body.error ?? `Server returned ${result.status}`);
+                return 1;
+            }
+            console.log(options.json ? JSON.stringify(result.body) : result.body.goalSummary ?? JSON.stringify(result.body));
+            return 0;
+        }
         case "setup":
         case "start":
             return runOnboardingCommand(options);

package/dist-server/server/device-routing.js

@@ -0,0 +1,60 @@
+// Device routing for approval requests (docs/specs/remote-approval/spec.md).
+//
+// The server tracks which user endpoint is live — the desktop's event
+// stream or a paired phone's — and an approval request routes to the live
+// user device. A remote session (no live desktop stream) routes to the
+// phone automatically. It never broadcasts: the target is one device kind,
+// picked here, and every client learns it from the stream's hello frame.
+/** Where an approval goes. The desktop wins whenever it is live, so a
+ * person sitting at the Mac is never interrupted on the phone; a remote
+ * session routes to the phone; nothing live still answers "phone" with
+ * live: false, so the ask is queued for the one device that can travel to
+ * the person rather than broadcast. */
+export function pickApprovalRoute(liveness) {
+    if (liveness.desktop > 0)
+        return { device: "desktop", live: true };
+    if (liveness.phone > 0)
+        return { device: "phone", live: true };
+    return { device: "phone", live: false };
+}
+/** The server's count of live user streams by device kind. Written by the
+ * SSE route's add/remove, read when an approval is raised or a client
+ * asks. Counts, never identities: routing is about which kind of device is
+ * present, not who is watching. */
+export class DeviceRouteRegistry {
+    liveness = { desktop: 0, phone: 0 };
+    /** A stream opened. `kind` is the connection's auth kind: loopback is
+     * the desktop app on this machine; a paired session is a phone. */
+    streamOpened(kind) {
+        if (kind === "loopback")
+            this.liveness.desktop += 1;
+        else if (kind === "session")
+            this.liveness.phone += 1;
+    }
+    streamClosed(kind) {
+        if (kind === "loopback")
+            this.liveness.desktop = Math.max(0, this.liveness.desktop - 1);
+        else if (kind === "session")
+            this.liveness.phone = Math.max(0, this.liveness.phone - 1);
+    }
+    route() {
+        return pickApprovalRoute(this.liveness);
+    }
+    counts() {
+        return { ...this.liveness };
+    }
+}
+/** End one stream: drop it from the fan-out set, end the response, and
+ * tell approval routing the device went away. Every removal path goes
+ * through here so the routing counts cannot drift from the stream set. */
+export function removeStream(clients, registry, client) {
+    if (!clients.delete(client))
+        return;
+    registry.streamClosed(client.authKind);
+    try {
+        client.res.end();
+    }
+    catch {
+        /* already gone */
+    }
+}

package/dist-server/server/drivers/claude.js

@@ -1615,6 +1615,8 @@ export const ClaudeDriver = {
                 // A settled turn owns no retry budget. Retained CLI sessions may run
                 // many later turns on this thread, and each must start fresh.
                 retryState.delete(threadId);
+                if (t.authFailed)
+                    closeSession(threadId, "sign-in required");
                 emit({ ...base(threadId, t.turnId), type: "turn.completed", ok, stopReason, cost, ...(usage ? { usage } : {}) });
                 if (session.child.exitCode === null && !session.closing)
                     armIdle(threadId);
@@ -1772,11 +1774,7 @@ export const ClaudeDriver = {
                     case "assistant": {
                         const msg = o.message ?? {};
                         const text = firstText(msg.content);
-                        // An unauthenticated turn comes back as an api-error frame whose
-                        // only content is the CLI's own "run /login" instruction — a
-                        // command this app has no terminal to run, so relaying it as a
-                        // reply strands the user. Every other engine reports this as a
-                        // setup error; that is what routes them to the sign-in card.
+                        // CLI auth diagnostics enter the shared fallback path, never assistant text.
                         if (claudeAuthFailure(o, text)) {
                             if (session.turn)
                                 session.turn.authFailed = true;
@@ -1853,12 +1851,16 @@ export const ClaudeDriver = {
                         if (o.origin?.kind === "task-notification")
                             break;
                         {
-                            // result.usage is this invocation's total — one process per turn,
-                            // so it is the turn's figure. cache reads count as input: they
-                            // are billed (at the cache rate) and they fill the window — but
-                            // they are reported separately too, so the UI can show how much
-                            // of the figure was context re-read rather than new text.
+                            // Result usage includes input, output and cached context.
                             const t = session.turn;
+                            // Some CLI failures exist only on the result, with no assistant frame.
+                            const resultError = [o.result, ...(Array.isArray(o.errors) ? o.errors : [])]
+                                .filter((value) => typeof value === "string").join("\n");
+                            if (o.is_error === true && !t?.authFailed && claudeAuthFailure({ error: o.error ?? "api_error" }, resultError)) {
+                                if (t)
+                                    t.authFailed = true;
+                                emit({ ...base(threadId, currentTurnId()), type: "runtime.error", message: resultError, setup: true, failure: "auth_failed" });
+                            }
                             const usage = o.usage
                                 ? {
                                     input: (o.usage.input_tokens || 0) + (o.usage.cache_read_input_tokens || 0) + (o.usage.cache_creation_input_tokens || 0),
@@ -1870,7 +1872,7 @@ export const ClaudeDriver = {
                                 : undefined;
                             const earlier = t?.carried;
                             const result = {
-                                ok: o.is_error !== true,
+                                ok: o.is_error !== true && !t?.authFailed,
                                 stopReason: t?.authFailed ? "auth_required"
                                     : t?.refreshConflict && o.is_error === true ? "credential_refresh_conflict"
                                         : claudeResultStopReason(o),

package/dist-server/server/drivers/codex.js

@@ -156,20 +156,13 @@ export function managedCodexArgs(config) {
 }
 const QUESTION_TIMEOUT_NOTE = "No answer was given — use your best judgment.";
 const DENY_TIMEOUT_NOTE = "Atomic: nobody answered this permission request in time. Skip this action and finish what you can without it.";
-const skippedSseServers = new Set();
-const renamedMcpServers = new Set();
-/** Logged once per name: the rename is deliberate, not a lost server. */
-function noteRenamedMcpServer(name, mountName) {
-    if (renamedMcpServers.has(name))
+const notedMcpServers = new Set();
+/** Logged once per server and reason: a rename or a left-out server is deliberate, not a lost one. */
+function noteMcpServerOnce(key, line) {
+    if (notedMcpServers.has(key))
         return;
-    renamedMcpServers.add(name);
-    console.error(`codex: MCP server ${JSON.stringify(name)} is also declared in Codex's own config.toml — mounted as ${JSON.stringify(mountName)} for this bot so the two do not merge`);
-}
-function noteSkippedSseServer(name) {
-    if (skippedSseServers.has(name))
-        return;
-    skippedSseServers.add(name);
-    console.error(`codex: MCP server ${JSON.stringify(name)} uses the SSE transport, which codex does not speak — it is available to Claude bots only`);
+    notedMcpServers.add(key);
+    console.error(`codex: MCP server ${line}`);
 }
 /** A TOML inline table for a `-c key=value` override; JSON string quoting
  * is valid TOML basic-string quoting. */
@@ -645,16 +638,18 @@ export const CodexDriver = {
             // instance's legacy fullAuto setting. Harness turns always send an
             // explicit mode, which takes precedence.
             const approvalMode = turn.approvalMode ?? (config.fullAuto ? "full" : "ask");
+            // The person's servers this turn mounts. One that would clobber a
+            // harness-owned variable is left out, not fatal: the rest still mount.
+            const customServers = {};
             for (const [name, server] of Object.entries(turn.integrations?.custom ?? {})) {
-                if ("url" in server)
-                    continue;
                 // The mcp-remote bridge runs on Atomic's own Electron-as-Node and sets
                 // ELECTRON_RUN_AS_NODE=1, the value the harness mounts already share.
-                const reserved = Object.entries(server.env)
+                const reserved = "url" in server ? undefined : Object.entries(server.env)
                     .find(([key, value]) => isHarnessOwnedMcpEnvName(key) && !(key === "ELECTRON_RUN_AS_NODE" && value === "1"))?.[0];
-                if (reserved) {
-                    throw new Error(`Custom MCP server “${name}” cannot set reserved environment variable “${reserved}”`);
-                }
+                if (reserved)
+                    noteMcpServerOnce(`reserved:${name}`, `${JSON.stringify(name)} sets reserved environment variable ${JSON.stringify(reserved)} — left out of this bot's turns until its settings change`);
+                else
+                    customServers[name] = server;
             }
             let autoAcceptPermissions = approvalMode === "full";
             if (active.has(threadId))
@@ -692,7 +687,7 @@ export const CodexDriver = {
                 // this child actually loads. The mounts assign the same values again,
                 // in the same order, so the final environment is unchanged.
                 const childCwd = turn.cwd ?? homedir();
-                for (const server of Object.values(turn.integrations?.custom ?? {})) {
+                for (const server of Object.values(customServers)) {
                     if (!("url" in server))
                         Object.assign(env, server.env);
                 }
@@ -720,17 +715,17 @@ export const CodexDriver = {
                 // mount name → configured name, so an approval request naming the
                 // mounted server can be traced back to the person's own entry
                 const customByMountName = new Map();
-                for (const [name, server] of Object.entries(turn.integrations?.custom ?? {})) {
+                for (const [name, server] of Object.entries(customServers)) {
                     // codex speaks streamable HTTP to a remote server, not the older
                     // SSE transport: such an entry still reaches Claude bots, and is
                     // left out here rather than mounted as something it is not
                     if ("url" in server && server.type === "sse") {
-                        noteSkippedSseServer(name);
+                        noteMcpServerOnce(`sse:${name}`, `${JSON.stringify(name)} uses the SSE transport, which codex does not speak — it is available to Claude bots only`);
                         continue;
                     }
                     const mountName = mountedMcpServerName(name, declaredInCodexConfig);
                     if (mountName !== name)
-                        noteRenamedMcpServer(name, mountName);
+                        noteMcpServerOnce(`renamed:${name}`, `${JSON.stringify(name)} is also declared in Codex's own config.toml — mounted as ${JSON.stringify(mountName)} for this bot so the two do not merge`);
                     customByMountName.set(mountName, name);
                     mountMcpServer(appServerArgs, env, mountName, server, false);
                 }

package/dist-server/server/drivers/local-inject.js

@@ -213,9 +213,8 @@ function idsFromModelsPayload(payload) {
         const low = id.toLowerCase();
         if (low.includes("embed") || low.includes("bge-") || low.includes("nomic"))
             return [];
-        // An Ollama Cloud model is not this machine's: it bills a plan.
-        if (isOllamaCloudModel(record))
-            return [];
+        // Ollama Cloud tags a signed-in Ollama serves are listed too (Erick,
+        // 2026-10-24); the label says they bill a plan.
         return [id];
     });
 }
@@ -349,7 +348,7 @@ export async function probeLocalInjects(env = process.env, fetchImpl = fetch) {
                 id: encodeInjectId(host.id, model),
                 host: host.id,
                 model,
-                label: `${model} (${host.label})`,
+                label: isOllamaCloudModel(model) ? `${model} (${host.label}, plan-billed)` : `${model} (${host.label})`,
                 loaded: loaded.has(model),
                 ...(contextWindow ? { contextWindow } : {}),
             });

package/dist-server/server/engine-tiers.js

@@ -3,21 +3,11 @@
 // engine of its ladder that is ready. Everything here is pure except the
 // snapshot cache, so the server wires it to the live registry and the tests
 // drive it with plain candidates.
-import { BOT_TIERS, DEFAULT_TIER_CLASSES, MODEL_CLASSES, classBelow, isBotTier, toModelClass } from "../shared/engine-tiers.js";
+import { BOT_TIERS, DEFAULT_LADDERS, DEFAULT_TIER_CLASSES, MODEL_CLASSES, classBelow, isBotTier, toModelClass } from "../shared/engine-tiers.js";
 import { modelHost } from "../shared/engine-choices.js";
+export { DEFAULT_LADDERS };
 import { subscriptionProviderForDriver } from "../shared/subscription-bots.js";
 import { ATOMIC_ENGINE_INSTANCE, engineIntent, localModel, modelBilling, modelProvider, paidCandidate, perTokenModel } from "./harness-import/engine-policy.js";
-/** Hand-written ladders, used only when no model has a class yet (the
- * server always has the bundled baseline, so in practice the generated
- * ladders below apply). Pay-per-token engines need no rung: they form the
- * automatic last band of every ladder (resolveLadder). */
-export const DEFAULT_LADDERS = {
-    orchestrator: [{ engine: "claudeAgent" }, { engine: "atomic-engine" }, { engine: "codex" }],
-    engineering: [{ engine: "claudeAgent" }, { engine: "codex" }, { engine: "cursorAgent" }, { engine: "kimiAgent" }],
-    research: [{ engine: "grokAgent" }, { engine: "antigravityAgent" }, { engine: "kimiAgent" }],
-    writing: [{ engine: "antigravityAgent" }, { engine: "kimiAgent" }, { engine: "codex" }, { engine: "claudeAgent" }],
-    routine: [{ engine: "qwenAgent" }, { engine: "kimiAgent" }, { engine: "antigravityAgent" }],
-};
 /** Engines a tier tries first, whatever the class catalog order says: Chibi
  * runs on Claude (Erick, 2026-10-13: open-weight models broke its
  * orchestration). Its ladder starts with Claude's best model graded in its
@@ -379,7 +369,7 @@ export function resolveFailover(request) {
         const ids = candidate.models.options.map((option) => option.id);
         const multi = ids.some((id) => modelProvider(candidate, id) !== undefined);
         // (A local host's model, Ollama Cloud tags included, is not one of them:
-        // Ollama Cloud joins as its own engine, local models only by local rules.)
+        // it joins when a ladder names it, else by Ollama Cloud or local rules.)
         const models = multi ? ids.filter((id) => modelProvider(candidate, id) !== undefined && modelBilling(candidate, id) === "subscription")
             : candidate.models.default && modelBilling(candidate, candidate.models.default) === undefined ? [candidate.models.default] : [];
         for (const model of models) {
@@ -410,7 +400,8 @@ export function resolveFailover(request) {
                     return "tried";
                 if (!keys && (keyBased(candidate) || perTokenModel(candidate, model)))
                     return "key-later";
-                if (request.isLocal?.(candidate, model) && !(request.localAllowed && modelClass === "Añejo"))
+                // a ladder-named local model is a normal rung (Erick, 2026-10-24)
+                if (!named && request.isLocal?.(candidate, model) && !(request.localAllowed && modelClass === "Añejo"))
                     return "local";
                 const step = named ? ladder.indexOf(entry) : ladder.length;
                 return effective(candidate, model, named ? entry : undefined, step) === modelClass ? undefined : "class";