@holt-os/holt 0.15.1 → 0.16.0

package/README.md

@@ -50,7 +50,7 @@ cd ~/where-you-want-to-work
 holt           # start your assistant (or use your custom command, e.g. `ai`)
 ```
 
-That is it. Bare `holt` sets the folder up the first time (trust, brain, memory hooks) and then launches the **real interactive brain** (Claude Code, Codex, or Gemini), branded as Holt. Run `holt help` for the full command list, and `holt chat` for the lightweight REPL described further down.
+That is it. Bare `holt` sets the folder up the first time (trust, brain, memory hooks) and then launches the **real interactive brain** (Claude Code, Codex, or Gemini), branded as Holt. Run `holt help` for the full command list.
 
 Prefer to step through setup on its own first? `holt init` still does that, then `holt` starts the session.
 
@@ -59,10 +59,12 @@ Prefer to step through setup on its own first? `holt init` still does that, then
 `holt` (with no command) is the front door: **your assistant, with memory of you.**
 
 1. **Sets up if needed.** In a fresh folder it runs onboarding (trust, pick a brain, memory). In an already-configured folder it just makes sure the folder is trusted, the memory directory exists, and the [ambient memory hooks](#ambient-memory-for-claude-code-holt-hook) are installed.
-2. **Launches the real interactive brain.** It hands the terminal to the brain's own interactive session (`claude`, `codex`, or `gemini` with no `-p` and no prompt), so you keep the brain's full power: agentic edits, tool use, the permission UI, MCP. This is different from `holt chat`, which is a lightweight REPL that shells out to the brain once per turn.
+> **Gemini note.** Personal Google accounts can no longer sign in to Gemini CLI (Google retired that login on 18 June 2026 in favour of Antigravity). Gemini still works in Holt with an API key from <https://aistudio.google.com/apikey>; `holt login gemini` walks you through connecting it.
+
+2. **Launches the real interactive brain.** It hands the terminal to the brain's own interactive session (`claude`, `codex`, or `gemini` with no `-p` and no prompt), so you keep the brain's full power: agentic edits, tool use, the permission UI, MCP. That is different from Holt's own built-in REPL, which shells out to the brain once per turn and is used for API brains that have no TUI of their own.
 3. **Brands the session as Holt.** See [Branding](#branding-holt-forward) below.
 
-If your default brain is a **direct API brain** (no interactive TUI), bare `holt` prints a one-line note and starts `holt chat` instead, since that path supports API brains.
+If your default brain is a **direct API brain** (no interactive TUI of its own), bare `holt` opens Holt's own built-in REPL instead, branded the same way. Same command, same intro, no second thing to learn.
 
 ### Branding (Holt-forward)
 
@@ -96,7 +98,7 @@ During `holt init` you:
 
 ## Using it
 
-Inside `holt chat`:
+Inside a Holt session:
 
 ```
 /brain            list your brains and see which is active
@@ -127,7 +129,7 @@ Holt runs the brain in the folder you launched it from, so by default the brain
 - `/allow <path>` grants a folder up front with no prompt.
 - `/allowed` lists what you have granted.
 
-Grants are **in-memory and session-scoped**: nothing is written to disk, and they reset the next time you run `holt chat`. Access is **read-oriented** and only works with a **Claude Code** brain: Holt passes `--add-dir=<dir>` for each granted folder plus `--allowedTools=Read,Glob,Grep` so Claude Code can read (but not write) those files without an interactive permission prompt. With a Codex/Gemini or API brain, external file access is unavailable and Holt says so instead of adding flags. (If you need to tune the flags, they live in one place: `claudeAccessArgs` in `src/access.ts`.)
+Grants are **in-memory and session-scoped**: nothing is written to disk, and they reset the next time you run `holt`. Access is **read-oriented** and only works with a **Claude Code** brain: Holt passes `--add-dir=<dir>` for each granted folder plus `--allowedTools=Read,Glob,Grep` so Claude Code can read (but not write) those files without an interactive permission prompt. With a Codex/Gemini or API brain, external file access is unavailable and Holt says so instead of adding flags. (If you need to tune the flags, they live in one place: `claudeAccessArgs` in `src/access.ts`.)
 
 ***
 
@@ -248,7 +250,7 @@ holt wiki setup               # recommend a local model for this machine's RAM
 
 **How sync works.** `holt wiki sync` gathers facts added since the last sync (a marker in `.holt/wiki/.state.json`), embeds each one locally, and routes it to the nearest existing page by cosine similarity. Related facts land on the same page; a fact that matches nothing new starts a fresh page. Facts are grouped by target page and the maintainer is called **once per changed page** (not once per fact), so it only rewrites the few pages that actually changed. Routing is always local and free, which is what keeps the maintainer's cost minimal. `holt wiki rebuild` folds every fact from scratch.
 
-**Self-maintaining (auto-sync).** Turn on `holt wiki auto on` (persists `wiki.autoSync: true` for the folder) and the wiki keeps itself current with no manual command. It syncs **after fact distillation** at the end of a `holt chat` session, and ambiently when the Claude Code **Stop** hook fires (`holt hook capture`), so newly captured facts fold straight into pages. Auto-sync is silent, best-effort, and never blocks exit: it reuses the exact same sync engine as `holt wiki sync`, so there is no behavior drift. Left off (the default), nothing changes and you sync by hand. `holt wiki auto` with no argument shows the current state; `holt wiki status` surfaces it too.
+**Self-maintaining (auto-sync).** Turn on `holt wiki auto on` (persists `wiki.autoSync: true` for the folder) and the wiki keeps itself current with no manual command. It syncs **after fact distillation** at the end of a Holt session, and ambiently when the Claude Code **Stop** hook fires (`holt hook capture`), so newly captured facts fold straight into pages. Auto-sync is silent, best-effort, and never blocks exit: it reuses the exact same sync engine as `holt wiki sync`, so there is no behavior drift. Left off (the default), nothing changes and you sync by hand. `holt wiki auto` with no argument shows the current state; `holt wiki status` surfaces it too.
 
 **Lint that can fix.** `holt wiki lint` audits pages for contradictions, duplicates, and gaps and prints a report only (files untouched). Add `--fix` and Holt asks the maintainer to return corrected page bodies and **applies them**, rewriting the affected pages (provenance/`sources` is preserved). Because pages are derived and regenerable, applying is safe: a bad `--fix` is fully recoverable with `holt wiki rebuild`, and the command prints a git/backup nudge before writing. Only pages that actually change are rewritten.
 
@@ -378,7 +380,7 @@ Point the client at the folder whose memory you want it to use; Holt serves what
 
 ## Ambient memory for Claude Code (`holt hook`)
 
-The MCP server above lets Claude Code recall and remember **when it decides to**. `holt hook` goes further: it makes Holt's per-folder memory work **ambiently**, with no `holt chat` and no manual tool call. Two directions, both wired as [Claude Code hooks](https://docs.claude.com/en/docs/claude-code/hooks):
+The MCP server above lets Claude Code recall and remember **when it decides to**. `holt hook` goes further: it makes Holt's per-folder memory work **ambiently**, with no Holt session open and no manual tool call. Two directions, both wired as [Claude Code hooks](https://docs.claude.com/en/docs/claude-code/hooks):
 
 - **Inject** (`UserPromptSubmit`): before each prompt, Holt quietly recalls the most relevant remembered notes for the current folder and adds them to the model's context.
 - **Capture** (`Stop`): when a session ends, Holt distills durable facts from the transcript (via this folder's configured brain) and saves them to the folder's memory.
@@ -394,7 +396,7 @@ holt hook remove                  # remove ONLY Holt's hooks, leaving everything
 
 Install **merges** into any existing `hooks` config, never clobbers unrelated settings or other hooks, is **idempotent** (re-running does not duplicate), and backs the file up to `settings.json.holt-bak` before writing. `remove` deletes only the entries whose command is `holt hook inject` / `holt hook capture`.
 
-**Trusted-folder guard (important).** The two runtime hooks (`holt hook inject` and `holt hook capture`, invoked by Claude Code, not you) no-op **silently** unless the folder is a trusted Holt workspace with an existing `.holt/memory`. So Holt never injects your private notes into an unrelated project, and never creates memory in a folder you never set up. To make a folder ambient, run `holt init` (or `holt chat`) there once so it becomes trusted and gets its `.holt/memory`. The inject hook keeps stdout clean (only the context block is printed, since Claude Code injects it verbatim); all diagnostics go to stderr, and both hooks always exit 0 so a memory step never blocks or slows your prompt.
+**Trusted-folder guard (important).** The two runtime hooks (`holt hook inject` and `holt hook capture`, invoked by Claude Code, not you) no-op **silently** unless the folder is a trusted Holt workspace with an existing `.holt/memory`. So Holt never injects your private notes into an unrelated project, and never creates memory in a folder you never set up. To make a folder ambient, run `holt init` there once so it becomes trusted and gets its `.holt/memory`. The inject hook keeps stdout clean (only the context block is printed, since Claude Code injects it verbatim); all diagnostics go to stderr, and both hooks always exit 0 so a memory step never blocks or slows your prompt.
 
 **Seeing what the hooks did (`~/.holt/hooks.log`).** Since the hooks stay silent, every `holt hook capture` run appends **one** line to `~/.holt/hooks.log` with the outcome or the exact skip reason (untrusted folder, no config, `extractFacts` off, no usable brain, missing or empty transcript, too few exchanges, or `saved N facts`), preceded by a line of the raw hook fields it received. Check this file first if capture seems to save nothing. `inject` uses the same log but stays quiet by default; set `HOLT_HOOK_DEBUG=1` to make it log too.
 
@@ -418,7 +420,7 @@ Run a single task non-interactively. It recalls relevant memory, injects your sk
 holt run "summarize the open items in this folder"
 ```
 
-Options: `--brain <id>` pick a brain, `--out <file>` also write the reply to a file, `--no-store` skip saving, `--no-recall` skip memory, `--quiet` suppress streaming. The folder must be trusted first (`holt init` or `holt chat` once); in a non-interactive context an untrusted folder exits non-zero instead of prompting.
+Options: `--brain <id>` pick a brain, `--out <file>` also write the reply to a file, `--no-store` skip saving, `--no-recall` skip memory, `--quiet` suppress streaming. The folder must be trusted first (`holt init` once); in a non-interactive context an untrusted folder exits non-zero instead of prompting.
 
 ### holt schedule
 
@@ -557,7 +559,6 @@ holt                 start your assistant: set up if needed, then launch the rea
                      interactive brain (Claude Code/Codex/Gemini), branded as Holt
 holt launch          same as bare "holt"
 holt init            set up (trust, brains, sign-in, defaults) for this folder
-holt chat            lightweight REPL that remembers past ones (used for API brains)
 holt run <task>      run one task non-interactively (recall, brain, remember)
 holt schedule        run a task on a timer: add | list | remove
 holt routine         named, reusable, scheduled jobs: add | run | list | show | remove

package/dist/cli.js

@@ -205,12 +205,22 @@ var BRAIN_SETUP = {
   codex: { install: ["npm", "install", "-g", "@openai/codex"], login: ["codex", "login"] },
   gemini: { install: ["npm", "install", "-g", "@google/gemini-cli"], login: ["gemini"] }
 };
+var BRAIN_LOGIN_UNAVAILABLE = {
+  gemini: {
+    reason: 'Google ended "Login with Google" for Gemini Code Assist individual accounts on 18 June 2026. Personal Google accounts (free, AI Pro, AI Ultra) can no longer sign in to Gemini CLI.',
+    provider: "gemini",
+    keyUrl: "https://aistudio.google.com/apikey"
+  }
+};
+function loginUnavailable(id) {
+  return BRAIN_LOGIN_UNAVAILABLE[id] ?? null;
+}
 var BRAIN_IDS = ["claude", "codex", "gemini"];
 var PROVIDERS = ["anthropic", "openai", "gemini", "kimi", "grok"];
 var PROVIDER_MODEL_SUGGESTION = {
-  anthropic: "claude-sonnet-4-6",
+  anthropic: "claude-sonnet-5",
   openai: "gpt-5",
-  gemini: "gemini-2.5-flash",
+  gemini: "gemini-flash-latest",
   kimi: "kimi-k2-turbo-preview",
   grok: "grok-4"
 };
@@ -221,6 +231,11 @@ var PROVIDER_ENV = {
   kimi: "MOONSHOT_API_KEY",
   grok: "XAI_API_KEY"
 };
+function cliBrainUsable(id) {
+  const gone = loginUnavailable(id);
+  if (!gone) return true;
+  return Boolean(process.env[PROVIDER_ENV[gone.provider]]);
+}
 function defaultConfig() {
   const brains = {};
   for (const id of BRAIN_IDS) {
@@ -1509,7 +1524,10 @@ function printStatus(cfg) {
     const b = cfg.brains[id];
     const tags = [
       b.enabled ? c.green("enabled") : isInstalled(b.command) ? c.dim("installed, off") : c.dim("not installed"),
-      cfg.defaultBrain === id ? c.accent("default") : ""
+      cfg.defaultBrain === id ? c.accent("default") : "",
+      // A retired sign-in with no key in the environment is the real reason a
+      // brain will not answer, so name it here rather than at first failure.
+      loginUnavailable(id) && !cliBrainUsable(id) ? c.red("no sign-in, needs API key") : ""
     ].filter(Boolean).join("  ");
     console.log(`  ${id.padEnd(10)} ${b.label.padEnd(16)} ${tags}`);
   }
@@ -1528,8 +1546,9 @@ function printStatus(cfg) {
   console.log("\n  " + c.dim("[d] default brain   [t] toggle brain   [c] connect API brain   [x] remove API brain"));
   console.log("  " + c.dim("[a] launch command   [m] connect Telegram   [enter] done"));
 }
-async function connectApiBrain(ask, cfg) {
-  let provider = null;
+async function connectApiBrain(ask, cfg, preset) {
+  let provider = preset ?? null;
+  if (provider) console.log(c.dim(`  provider: ${provider}`));
   for (let tries = 0; tries < 3 && !provider; tries++) {
     const provRaw = (await ask(`  provider [${PROVIDERS.join("/")}] (enter for ${PROVIDERS[0]}, or "skip"): `) ?? "skip").trim().toLowerCase();
     if (provRaw === "skip" || provRaw === "q" || provRaw === "n" || provRaw === "no") {
@@ -1547,7 +1566,9 @@ async function connectApiBrain(ask, cfg) {
   const suggestion = PROVIDER_MODEL_SUGGESTION[provider];
   const modelRaw = (await ask(`  model (enter for ${suggestion}): `) ?? "").trim();
   const model = modelRaw || suggestion;
-  const idRaw = (await ask("  short name for this brain (e.g. sonnet): ") ?? "").trim();
+  const idHint = preset ? `${preset}-api` : "";
+  const idPrompt = idHint ? `  short name for this brain (enter for ${idHint}): ` : "  short name for this brain (e.g. sonnet): ";
+  const idRaw = (await ask(idPrompt) ?? "").trim() || idHint;
   if (!idRaw) {
     console.log(c.dim("  cancelled (no name)."));
     return null;
@@ -1603,8 +1624,12 @@ async function runSettings(ask) {
     } else if (choice === "t") {
       const pick = (await ask(`  toggle which brain [${BRAIN_IDS.join("/")}]: `) ?? "").trim();
       if (BRAIN_IDS.includes(pick)) {
+        const goneLogin = loginUnavailable(pick);
         if (!cfg.brains[pick].enabled && !isInstalled(cfg.brains[pick].command)) {
           console.log(c.dim(`  ${cfg.brains[pick].label} is not installed. Run "holt init" to install it.`));
+        } else if (!cfg.brains[pick].enabled && goneLogin && !cliBrainUsable(pick)) {
+          console.log(c.dim(`  ${cfg.brains[pick].label} has no sign-in any more and no ${goneLogin.provider.toUpperCase()}_API_KEY set.`));
+          console.log(c.dim(`  Get a key at ${goneLogin.keyUrl}, then connect it here with "c".`));
         } else {
           cfg.brains[pick].enabled = !cfg.brains[pick].enabled;
           if (!cfg.brains[pick].enabled && cfg.defaultBrain === pick) cfg.defaultBrain = selectableIds(cfg)[0] ?? null;
@@ -2139,6 +2164,75 @@ async function voiceClear() {
   console.log(had ? c.green("\n  Voice profile removed.\n") : c.dim("\n  No voice profile to remove.\n"));
 }
 
+// src/commands/login.ts
+function printLoginUnavailable(id, info) {
+  console.log("\n" + c.red(`${BRAIN_DEFS[id].label} sign-in is no longer available.`));
+  console.log(c.dim("  " + info.reason));
+  console.log("\n  It still works on an API key. Two ways:");
+  console.log("    1. " + c.accent(`Get a key at ${info.keyUrl}`));
+  console.log("    2. Either export it as " + c.accent(`${info.provider.toUpperCase()}_API_KEY`) + c.dim(` (the ${BRAIN_DEFS[id].command} CLI reads it too), or connect it to Holt as a direct API brain.`));
+}
+async function offerKeyInstead(ask, id, info) {
+  const cfg = loadConfig();
+  if (!cfg) {
+    console.log(c.dim('\n  This folder is not set up yet. Run "holt init" and connect it as a direct API brain.\n'));
+    return false;
+  }
+  if (!await askYesNo(ask, `
+  Connect ${BRAIN_DEFS[id].label} to Holt with an API key now? [Y/n] `, true)) {
+    console.log(c.dim('  Okay. Run "holt setting" then "c" whenever you have the key.\n'));
+    return false;
+  }
+  const brain = await connectApiBrain(ask, cfg, info.provider);
+  if (!brain) return false;
+  if (!cfg.defaultBrain || cfg.defaultBrain === id) {
+    cfg.defaultBrain = brain.id;
+    console.log(c.dim(`  default brain for this folder is now "${brain.id}".`));
+  }
+  if (cfg.brains[id]?.enabled) {
+    cfg.brains[id].enabled = false;
+    console.log(c.dim(`  turned off the ${BRAIN_DEFS[id].label} brain (no sign-in available).`));
+  }
+  saveConfig(cfg);
+  console.log(c.green("\n  Done. Start Holt: holt\n"));
+  return true;
+}
+async function login(which) {
+  const id = (which || "").toLowerCase();
+  if (!BRAIN_IDS.includes(id)) {
+    if (which) {
+      console.error(`
+  Unknown brain "${which}". Use one of: ${BRAIN_IDS.join(", ")}
+`);
+      process.exitCode = 1;
+    } else {
+      console.log(c.dim(`
+  Usage: holt login <${BRAIN_IDS.join("|")}>
+`));
+    }
+    return;
+  }
+  const gone = loginUnavailable(id);
+  if (gone) {
+    printLoginUnavailable(id, gone);
+    if (cliBrainUsable(id)) {
+      console.log(c.green(`
+  ${PROVIDER_ENV[gone.provider]} is already set, so ${BRAIN_DEFS[id].label} works as it is. Nothing to do.
+`));
+      return;
+    }
+    const { ask, close } = createReader();
+    await offerKeyInstead(ask, id, gone);
+    close();
+    return;
+  }
+  const s = BRAIN_SETUP[id];
+  console.log("\n" + c.accent(`Sign in to ${BRAIN_DEFS[id].label}`));
+  console.log(c.dim(`  Starting "${s.login.join(" ")}". Complete sign-in, then exit that tool.
+`));
+  await runInteractive(s.login[0], s.login.slice(1));
+}
+
 // src/commands/init.ts
 function parseBrains(raw, found) {
   const s = raw.trim().toLowerCase();
@@ -2159,7 +2253,8 @@ async function init() {
   const found = [];
   for (const id of BRAIN_IDS) {
     const ok2 = isInstalled(BRAIN_DEFS[id].command);
-    console.log(`  ${ok2 ? c.green("found  ") : c.dim("missing")}  ${BRAIN_DEFS[id].label} (${BRAIN_DEFS[id].command})`);
+    const note2 = loginUnavailable(id) && !cliBrainUsable(id) ? c.dim("  (needs an API key, no sign-in)") : "";
+    console.log(`  ${ok2 ? c.green("found  ") : c.dim("missing")}  ${BRAIN_DEFS[id].label} (${BRAIN_DEFS[id].command})${note2}`);
     if (ok2) found.push(id);
   }
   console.log("");
@@ -2171,11 +2266,24 @@ async function init() {
   const toInstall = chosen.filter((id) => !isInstalled(BRAIN_DEFS[id].command));
   const loginWanted = /* @__PURE__ */ new Set();
   for (const id of toInstall) {
+    if (loginUnavailable(id)) continue;
     if (await askYesNo(ask, `  ${BRAIN_DEFS[id].label} is not installed. Sign in after install? [Y/n] `, true)) loginWanted.add(id);
   }
   const connectedApiBrains = [];
+  const holder = defaultConfig();
+  for (const id of chosen) {
+    const gone = loginUnavailable(id);
+    if (!gone || cliBrainUsable(id)) continue;
+    printLoginUnavailable(id, gone);
+    if (await askYesNo(ask, `
+  Connect ${BRAIN_DEFS[id].label} with an API key now? [Y/n] `, true)) {
+      const brain = await connectApiBrain(ask, holder, gone.provider);
+      if (brain) connectedApiBrains.push(brain);
+    } else {
+      console.log(c.dim('  Okay. Run "holt setting" then "c" whenever you have the key.'));
+    }
+  }
   if (await askYesNo(ask, "\nAlso connect a direct API brain (raw key, no CLI needed)? [y/N] ", false)) {
-    const holder = defaultConfig();
     const brain = await connectApiBrain(ask, holder);
     if (brain) connectedApiBrains.push(brain);
   }
@@ -2246,7 +2354,7 @@ Default brain? [${chosen.join("/")}] (${defPick}): `) ?? "").trim();
     }
   }
   const cfg = loadConfig() ?? defaultConfig();
-  for (const id of BRAIN_IDS) cfg.brains[id].enabled = chosen.includes(id) && isInstalled(BRAIN_DEFS[id].command);
+  for (const id of BRAIN_IDS) cfg.brains[id].enabled = chosen.includes(id) && isInstalled(BRAIN_DEFS[id].command) && cliBrainUsable(id);
   for (const b of connectedApiBrains) if (!cfg.apiBrains.some((a) => a.id === b.id)) cfg.apiBrains.push(b);
   cfg.defaultBrain = cfg.brains[defaultBrain].enabled ? defaultBrain : BRAIN_IDS.find((id) => cfg.brains[id].enabled) ?? cfg.apiBrains[0]?.id ?? null;
   saveConfig(cfg);
@@ -2259,9 +2367,9 @@ Default brain? [${chosen.join("/")}] (${defPick}): `) ?? "").trim();
       console.log("\nStart chatting:");
       console.log("  " + c.accent(`source ${aliasNeedsSource}`) + c.dim("   (once; new terminals will not need it)"));
       console.log("  " + c.accent(aliasAns) + "\n");
-      console.log(c.dim("  Or right now, without sourcing: holt chat\n"));
+      console.log(c.dim("  Or right now, without sourcing: holt\n"));
     } else {
-      console.log("Start chatting:  " + c.accent("holt chat") + "\n");
+      console.log("Start chatting:  " + c.accent("holt") + "\n");
     }
   } else {
     console.log(c.dim('No brain is ready yet. Install one, then run "holt init" again.\n'));
@@ -4073,29 +4181,6 @@ function saveReply(reply, format, name) {
   return path;
 }
 
-// src/commands/login.ts
-async function login(which) {
-  const id = (which || "").toLowerCase();
-  if (!BRAIN_IDS.includes(id)) {
-    if (which) {
-      console.error(`
-  Unknown brain "${which}". Use one of: ${BRAIN_IDS.join(", ")}
-`);
-      process.exitCode = 1;
-    } else {
-      console.log(c.dim(`
-  Usage: holt login <${BRAIN_IDS.join("|")}>
-`));
-    }
-    return;
-  }
-  const s = BRAIN_SETUP[id];
-  console.log("\n" + c.accent(`Sign in to ${BRAIN_DEFS[id].label}`));
-  console.log(c.dim(`  Starting "${s.login.join(" ")}". Complete sign-in, then exit that tool.
-`));
-  await runInteractive(s.login[0], s.login.slice(1));
-}
-
 // src/access.ts
 import { existsSync as existsSync11, realpathSync as realpathSync3, statSync as statSync6 } from "fs";
 import { homedir as homedir6 } from "os";
@@ -4235,7 +4320,7 @@ async function chat() {
       return;
     }
     await init();
-    console.log(c.dim('\nSetup done. Run "holt chat" to start talking.\n'));
+    console.log(c.dim('\nSetup done. Run "holt" to start talking.\n'));
     return;
   }
   let active = resolveActive2(cfg, cfg.defaultBrain);
@@ -4363,7 +4448,7 @@ async function chat() {
         sb.detach();
         close();
         await login(targetId);
-        console.log(c.dim('\n  Signed in. Run "holt chat" again to continue.\n'));
+        console.log(c.dim(loginUnavailable(targetId) ? '\n  Run "holt" again to continue.\n' : '\n  Signed in. Run "holt" again to continue.\n'));
         return;
       }
       if (cmd === "brain") {
@@ -4461,7 +4546,8 @@ async function chat() {
     };
     const res = active.kind === "cli" ? await runBrain(cfg.brains[active.id], prompt, onChunk, extraArgs) : await runApiBrain(active.brain, prompt, onChunk);
     if (looksLikeAuthError(res.text)) {
-      const hint = active.kind === "cli" ? `  ${active.label} looks signed out. Run "holt login ${active.id}" in a terminal, or type /login here.` : `  ${active.label} has no working key. Run "holt setting" to add or fix it.`;
+      const goneLogin = active.kind === "cli" ? loginUnavailable(active.id) : null;
+      const hint = goneLogin ? `  ${active.label} has no sign-in any more and no ${PROVIDER_ENV[goneLogin.provider]} to fall back on. Get a key at ${goneLogin.keyUrl}, then run "holt setting" to connect it.` : active.kind === "cli" ? `  ${active.label} looks signed out. Run "holt login ${active.id}" in a terminal, or type /login here.` : `  ${active.label} has no working key. Run "holt setting" to add or fix it.`;
       if (!streamed || !res.text.endsWith("\n")) console.log("");
       console.log(c.red(hint) + "\n");
       showStatus();
@@ -4600,11 +4686,12 @@ function resolveTarget(cfg) {
   if (!id) return null;
   if (BRAIN_IDS.includes(id)) {
     const bid = id;
-    return { kind: "cli", id: bid, label: cfg.brains[bid].label };
+    if (cliBrainUsable(bid)) return { kind: "cli", id: bid, label: cfg.brains[bid].label };
+  } else {
+    const api = findApiBrain(cfg, id);
+    if (api) return { kind: "api", label: `${id} (api: ${api.provider}/${api.model})` };
   }
-  const api = findApiBrain(cfg, id);
-  if (api) return { kind: "api", label: `${id} (api: ${api.provider}/${api.model})` };
-  const fallback = BRAIN_IDS.find((b) => cfg.brains[b].enabled);
+  const fallback = BRAIN_IDS.find((b) => cfg.brains[b].enabled && cliBrainUsable(b));
   if (fallback) return { kind: "cli", id: fallback, label: cfg.brains[fallback].label };
   return null;
 }
@@ -4644,13 +4731,23 @@ async function launch() {
   await ensureSetup();
   const target = resolveTarget(cfg);
   if (!target) {
+    const def = cfg.defaultBrain;
+    const gone = def && BRAIN_IDS.includes(def) ? loginUnavailable(def) : null;
+    if (gone) {
+      console.log("\n  " + c.red(`${cfg.brains[def].label} can no longer sign in.`));
+      console.log(c.dim("  " + gone.reason));
+      console.log(c.dim(`  Get a key at ${gone.keyUrl}, then run "holt setting" and press "c" to connect it.`));
+      if (cfg.apiBrains.length) {
+        console.log(c.dim(`  Or switch this folder to an API brain you already have (${cfg.apiBrains.map((b) => b.id).join(", ")}): "holt setting" then "d".`));
+      }
+      console.log("");
+      return;
+    }
     console.log(c.dim('\n  No brain is ready. Run "holt setting" or "holt init".\n'));
     return;
   }
   if (target.kind === "api") {
-    console.log(c.dim(`
-  launch needs a CLI brain; starting chat instead (default is ${target.label}).
-`));
+    console.log(renderIntroBox());
     await chat();
     return;
   }
@@ -7066,7 +7163,7 @@ async function graph(args = []) {
     if (skipNotes.length) console.log(c.dim(`  ingest skipped: ${skipNotes.join(", ")}`));
   }
   if (turns.length === 0 && wikiPages.length === 0 && !codeGraph) {
-    console.log(c.dim('\n  No memory in this folder yet. Have a chat first with "holt chat", then come back.\n'));
+    console.log(c.dim('\n  No memory in this folder yet. Talk to Holt here first with "holt", then come back.\n'));
     console.log(c.dim(`  Or ingest this folder's code/docs: "holt graph --code" / "holt graph --docs".
 `));
     return;
@@ -7389,7 +7486,7 @@ function holtTools() {
 }
 
 // src/version.ts
-var VERSION = "0.15.1";
+var VERSION = "0.16.0";
 
 // src/commands/mcp.ts
 function printSetup() {
@@ -7573,7 +7670,7 @@ async function run(args) {
       close();
       if (!ok2) return;
     } else {
-      process.stderr.write("This folder is not trusted. Run holt init or holt chat here once, then schedule/run.\n");
+      process.stderr.write("This folder is not trusted. Run holt init here once, then schedule/run.\n");
       process.exitCode = 1;
       return;
     }
@@ -8080,7 +8177,7 @@ async function runCmd(rest) {
       close();
       if (!ok2) return;
     } else {
-      process.stderr.write("This folder is not trusted. Run holt init or holt chat here once, then run the routine.\n");
+      process.stderr.write("This folder is not trusted. Run holt init here once, then run the routine.\n");
       process.exitCode = 1;
       return;
     }
@@ -8483,8 +8580,14 @@ async function doctor(args = []) {
   for (const id of BRAIN_IDS) {
     const def = BRAIN_DEFS[id];
     const here = isInstalled(def.command);
-    if (here) installed.push(def.label);
+    const gone = loginUnavailable(id);
+    const usable = cliBrainUsable(id);
+    if (here && usable) installed.push(def.label);
     console.log(`  ${here ? c.green("installed") : c.dim("missing  ")}  ${def.label} ${c.dim(`(${def.command})`)}`);
+    if (here && gone && !usable) {
+      warn(`${def.label} cannot sign in any more. ${gone.reason}`);
+      steps.push(`Get a ${gone.provider} key at ${gone.keyUrl}, then connect it: holt setting -> "c".`);
+    }
   }
   const cfg = loadConfig();
   const apiBrains = cfg?.apiBrains ?? [];
@@ -8565,7 +8668,7 @@ async function doctor(args = []) {
     steps.unshift('Set up this folder: run "holt init".');
   }
   if (steps.length === 0) {
-    good('You are in good shape. Run "holt chat" to start.');
+    good('You are in good shape. Run "holt" to start.');
   } else {
     let n = 1;
     for (const s of steps) console.log(`  ${c.accent(String(n++) + ".")} ${s}`);
@@ -8875,7 +8978,7 @@ async function write(args) {
       close();
       if (!ok2) return;
     } else {
-      process.stderr.write("This folder is not trusted. Run holt init or holt chat here once first.\n");
+      process.stderr.write("This folder is not trusted. Run holt init here once first.\n");
       process.exitCode = 1;
       return;
     }
@@ -8989,12 +9092,12 @@ From your phone, while you sleep:
 
 Housekeeping:
   setting         Change brains, API connections, and your launch word (per folder)
-  login <brain>   Sign in to a brain: claude, codex, or gemini
+  login <brain>   Sign in to a brain: claude or codex
+                  (Gemini has no sign-in left; it routes you to an API key)
   update          Get the latest Holt, in one word
   reset           Start this folder over (asks first; your own files are untouched)
   hook            Ambient memory inside plain Claude Code: holt hook [install | status]
   mcp             Share Holt's memory with other AI apps (Claude Code, Cursor, Codex)
-  chat            Lightweight built-in chat, used for API brains
   init            Full setup by hand (bare "holt" runs this for you when needed)
   launch          Same as bare "holt": start your assistant
   version | help  Print the version / show this help
@@ -9032,6 +9135,8 @@ async function main() {
     case "init":
       await init();
       break;
+    // Undocumented: bare `holt` reaches the REPL by itself for API brains.
+    // Kept as a working alias so older scripts and aliases do not break.
     case "chat":
       await chat();
       break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holt-os/holt",
-  "version": "0.15.1",
+  "version": "0.16.0",
   "description": "An open-source personal agent OS: any LLM, private memory you can see and walk.",
   "type": "module",
   "license": "MIT",