@holt-os/holt 0.15.0 → 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
 
@@ -494,6 +496,14 @@ It reports, section by section:
 - **Always-on / Telegram**: whether a Telegram bot is set up, and a note on hosting the bot on a low-power always-on machine while keeping heavy local models on a bigger one.
 - **Recommended next steps**: a short checklist built from whatever gaps it found.
 
+And when you would rather not do the steps yourself:
+
+```bash
+holt doctor --fix
+```
+
+`--fix` repairs the common problems in one go: starts Ollama when it is installed but not running, downloads the missing embed model, upgrades any memories saved while embeddings were off, and reports a damaged-config repair if one happened. It ends with a "Repairs" section listing exactly what it did (or "Nothing needed repair"). Every Holt error message points here, so the answer to "something is off" is always the same one command.
+
 It is read-only advice: it changes nothing, needs no trust, and always exits cleanly even when a probe fails.
 
 The RAM-to-model table lives in `src/specs.ts` (`LOCAL_MODEL_RECS` / `recommendLocalModel`), the single source of truth the wiki maintainer reads too.
@@ -549,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

@@ -98,6 +98,18 @@ function createStatusBar() {
     detach
   };
 }
+async function askYesNo(ask, question, def) {
+  for (let tries = 0; tries < 3; tries++) {
+    const raw = await ask(question);
+    if (raw === null) return def;
+    const a = raw.trim().toLowerCase();
+    if (a === "") return def;
+    if (a === "y" || a === "yes") return true;
+    if (a === "n" || a === "no") return false;
+    console.log(c.dim(`  Just "y" or "n" please (enter = ${def ? "yes" : "no"}). You typed "${raw.trim()}".`));
+  }
+  return def;
+}
 function createReader() {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   const buffer = [];
@@ -155,8 +167,7 @@ async function ensureTrusted(ask) {
   console.log("\n" + c.accent("Trust this folder?"));
   console.log("  " + ws);
   console.log(c.dim("  Holt will read and write here: its config, memory, and any files you ask a brain to touch."));
-  const ans = (await ask("  Trust and continue? [y/N] ") ?? "").trim().toLowerCase();
-  if (ans === "y" || ans === "yes") {
+  if (await askYesNo(ask, "  Trust and continue? [y/N] ", false)) {
     trustDir(ws);
     console.log(c.green("  Trusted.") + c.dim(" (remembered for next time)") + "\n");
     return true;
@@ -194,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"
 };
@@ -210,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) {
@@ -1369,9 +1395,9 @@ async function setupTelegram(ask) {
   console.log(c.dim("  Option A: open your new bot in Telegram and send it any message,"));
   console.log(c.dim("            then I will auto-detect the chat id."));
   console.log(c.dim("  Option B: paste a numeric chat id yourself."));
-  const mode = (await ask("\n  Auto-detect from a message you just sent? [Y/n] ") ?? "").trim().toLowerCase();
+  const autoDetect = await askYesNo(ask, "\n  Auto-detect from a message you just sent? [Y/n] ", true);
   let allowedChatId = null;
-  if (mode === "" || mode === "y" || mode === "yes") {
+  if (autoDetect) {
     console.log(c.dim("\n  Checking for a recent message..."));
     const updates = await getUpdates(0, token);
     allowedChatId = latestChatId(updates);
@@ -1498,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}`);
   }
@@ -1517,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") {
@@ -1536,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;
@@ -1592,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;
@@ -1912,8 +1948,7 @@ async function runQuestions(ask, depth) {
   return out;
 }
 async function askKeepExcerpt(ask) {
-  const a = (await ask("  Store a short excerpt so Holt can match your tone directly? [y/N] ") ?? "").trim().toLowerCase();
-  return a === "y" || a === "yes";
+  return askYesNo(ask, "  Store a short excerpt so Holt can match your tone directly? [y/N] ", false);
 }
 async function addFileSample(ask, file, v) {
   const path = resolve(process.cwd(), file);
@@ -2129,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();
@@ -2149,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("");
@@ -2161,13 +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) {
-    const a = (await ask(`  ${BRAIN_DEFS[id].label} is not installed. Sign in after install? [Y/n] `) ?? "").trim().toLowerCase();
-    if (a !== "n" && a !== "no") loginWanted.add(id);
+    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 apiAns = (await ask("\nAlso connect a direct API brain (raw key, no CLI needed)? [y/N] ") ?? "").trim().toLowerCase();
-  if (apiAns === "y" || apiAns === "yes") {
-    const holder = defaultConfig();
+  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 brain = await connectApiBrain(ask, holder);
     if (brain) connectedApiBrains.push(brain);
   }
@@ -2195,13 +2311,11 @@ Default brain? [${chosen.join("/")}] (${defPick}): `) ?? "").trim();
   } else {
     const ollamaHere = isInstalled("ollama");
     const q = ollamaHere ? `Semantic memory needs a local embed model. Pull ${EMBED_MODEL} with Ollama now? [Y/n] ` : "Enable private semantic memory? Installs Ollama plus a small local embed model. Everything stays on your machine. [Y/n] ";
-    const a = (await ask("\n" + q) ?? "").trim().toLowerCase();
-    wantMemorySetup = a !== "n" && a !== "no";
+    wantMemorySetup = await askYesNo(ask, "\n" + q, true);
     if (!wantMemorySetup) console.log(c.dim('  Okay. Memory still works with keyword recall; run "holt init" again anytime.'));
   }
   if (!loadTelegramConfig()) {
-    const tgAns = (await ask("\nChat with Holt from your phone over Telegram? [y/N] ") ?? "").trim().toLowerCase();
-    if (tgAns === "y" || tgAns === "yes") await setupTelegram(ask);
+    if (await askYesNo(ask, "\nChat with Holt from your phone over Telegram? [y/N] ", false)) await setupTelegram(ask);
   }
   close();
   for (const id of toInstall) {
@@ -2240,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);
@@ -2253,17 +2367,17 @@ 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'));
   }
   const voiceReader = createReader();
-  const voiceAns = (await voiceReader.ask("Want Holt to learn how you write, so it can draft in your voice? [y/N] ") ?? "").trim().toLowerCase();
+  const voiceYes = await askYesNo(voiceReader.ask, "Want Holt to learn how you write, so it can draft in your voice? [y/N] ", false);
   voiceReader.close();
-  if (voiceAns === "y" || voiceAns === "yes") {
+  if (voiceYes) {
     await voiceInterview();
   } else {
     console.log(c.dim('  Skipped. Run "holt voice" anytime to set up your writing voice.\n'));
@@ -4067,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";
@@ -4222,14 +4313,14 @@ async function chat() {
   }
   let cfg = loadConfig();
   if (!cfg || !cfg.defaultBrain) {
-    const a = (await ask(c.dim("No Holt setup in this folder. Set it up now? [Y/n] ")) ?? "").trim().toLowerCase();
+    const setupYes = await askYesNo(ask, c.dim("No Holt setup in this folder. Set it up now? [Y/n] "), true);
     close();
-    if (a === "n" || a === "no") {
+    if (!setupYes) {
       console.log(c.dim('  Run "holt init" here when ready.\n'));
       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);
@@ -4357,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") {
@@ -4426,8 +4517,7 @@ async function chat() {
       const outside = findOutsidePaths(line, workspace());
       for (const dir of outside) {
         if (grantedDirs.has(dir)) continue;
-        const ans = (await ask(c.dim(`  Allow this session to access ${dir} (outside this folder)? [y/N] `)) ?? "").trim().toLowerCase();
-        if (ans === "y" || ans === "yes") {
+        if (await askYesNo(ask, c.dim(`  Allow this session to access ${dir} (outside this folder)? [y/N] `), false)) {
           grantedDirs.add(dir);
           console.log(c.green(`  granted this session: ${dir}`));
         } else {
@@ -4456,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();
@@ -4595,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;
 }
@@ -4639,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;
   }
@@ -7061,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;
@@ -7384,7 +7486,7 @@ function holtTools() {
 }
 
 // src/version.ts
-var VERSION = "0.15.0";
+var VERSION = "0.16.0";
 
 // src/commands/mcp.ts
 function printSetup() {
@@ -7568,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;
     }
@@ -8075,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;
     }
@@ -8478,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 ?? [];
@@ -8560,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}`);
@@ -8695,8 +8803,7 @@ async function update() {
     }
     console.log(`  Newer version available: ${c.bold(latest)}`);
     if (isBrewInstall()) {
-      const a2 = (await ask("  Update now via Homebrew? [Y/n] ") ?? "").trim().toLowerCase();
-      if (a2 === "n" || a2 === "no") {
+      if (!await askYesNo(ask, "  Update now via Homebrew? [Y/n] ", true)) {
         console.log(c.dim("  Later, then. The command is: brew upgrade holt\n"));
         return;
       }
@@ -8706,8 +8813,7 @@ async function update() {
       else console.log(c.dim("\n  Homebrew reported a problem above. You can retry with: brew upgrade holt\n"));
       return;
     }
-    const a = (await ask("  Update now? [Y/n] ") ?? "").trim().toLowerCase();
-    if (a === "n" || a === "no") {
+    if (!await askYesNo(ask, "  Update now? [Y/n] ", true)) {
       console.log(c.dim("  Later, then. The command is: npm install -g @holt-os/holt\n"));
       return;
     }
@@ -8872,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;
     }
@@ -8986,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
@@ -9029,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.0",
+  "version": "0.16.0",
   "description": "An open-source personal agent OS: any LLM, private memory you can see and walk.",
   "type": "module",
   "license": "MIT",