@tiens.nguyen/gu-cli 1.0.897 → 1.0.899

package/README.md

@@ -1,9 +1,9 @@
 <h1 align="center">gu — the coding agent for your own models</h1>
 
 <p align="center">
-  <strong>A coding agent in your terminal that runs on Ollama or any OpenAI-compatible API.</strong><br>
-  It reads your repo, makes the change, runs the tests and shows you what it did.<br>
-  <strong>Free installs run entirely on your machine. Free for 30 days: no account, no sign-in, no card.</strong>
+  <strong>Describe the change. gu edits your repo, runs the tests and shows you the diff, with Ollama or any OpenAI-compatible API.</strong><br>
+  Your prompts and code go to the model you choose, not to gu: its API and database run on your computer.<br>
+  <strong>Free for 30 days: no account, no sign-in, no card.</strong>
 </p>
 
 <p align="center">
@@ -18,7 +18,8 @@
   <a href="https://gucli.com">Website</a> ·
   <a href="https://gucli.com/start">Docs</a> ·
   <a href="https://gucli.com/pricing">Pricing</a> ·
-  <a href="https://gucli.com/support">Support</a>
+  <a href="https://gucli.com/support">Support</a><br>
+  <sub>The website is also in Tiếng Việt, 中文 and 日本語.</sub>
 </p>
 
 <p align="center">
@@ -40,8 +41,13 @@ gu
 computer. Press Enter to use it, pick a model provider, then type what you want done.
 
 A free install is **private**: gu's API and its database (MongoDB) run on this computer, next to
-your code. The first run shows what it will install and asks before installing anything.
-Needs **Node.js 20.19+**.
+your code, and your prompts and code go to the model you pick, not to gu. The first run shows what it will
+install and asks before installing anything. Needs **Node.js 20.19+**.
+
+**Local or hosted: you choose once, at the first run.** Free installs run in *Local mode* (above).
+With a Pro token, gu uses gu's hosted API and models instead. To switch later, run `gu clear` and
+set gu up again. In Local mode `gu clear` also deletes this computer's conversations (it asks
+first); `gu clear --keep-history` keeps them.
 
 > **`gu: command not found`?** Run `npx @tiens.nguyen/gu-cli fix-path`. See [Troubleshooting](#troubleshooting).
 
@@ -65,11 +71,15 @@ Needs **Node.js 20.19+**.
 ## Is gu for you?
 
 **A good fit if** you run (or want to run) your own models, can't send code to someone else's
-cloud, work on remote Linux boxes over SSH, or want a coding agent that costs $4 a month instead
-of a model subscription.
+cloud, work on remote Linux boxes over SSH, or want a terminal coding agent that is free with
+your own models and $4 a month with ours.
 
 **Want a frontier model?** gu runs those too, through any OpenAI-compatible API, and keeps
-everything else: the edits in your repo, the tests, the browser check and `/undo`.
+everything else: the edits in your repo, the tests, the browser check and `/undo`. (Your code then
+goes to that provider, as with any tool that uses it.)
+
+**Not a fit if** you want one click and no setup: gu asks you to pick a model, and it works best
+with a strong one.
 
 ## Quick start
 
@@ -89,8 +99,8 @@ gu uses up to three models, each with its own command:
 | `/agent-model` | **agent**: talks to you and plans | this machine |
 | `/embed-model` | **embedding**: RAG (`nomic-embed-text`, `qwen3-embedding`), local or remote | this machine |
 
-Run `/doctor` any time to check that each one answers. Coding works best with a strong model:
-small local models often fail at multi-step changes.
+Run `/doctor` any time to check that each one answers. Pick a strong model for coding: small
+local models often fail at multi-step changes.
 
 ## Using gu
 
@@ -167,7 +177,7 @@ gu doctor                      set up and check models on this machine
 gu rag [plan [path] | --test]  test the embedder, estimate index time
 gu workspace revert [runId]    undo an agent run's file edits from its backups
 gu support                     send a support request with masked logs
-gu clear [--yes]               back to a fresh machine (asks first)
+gu clear [--keep-history]      back to a fresh machine (asks first)
 gu fix-path | fix-powershell   repair PATH / remove PowerShell's `gu` alias
 ```
 
@@ -188,6 +198,7 @@ gu fix-path | fix-powershell   repair PATH / remove PowerShell's `gu` alias
 | --- | --- | --- |
 | **Free trial** | 30 days, from the first run | nothing: the token is created for you |
 | **Free plan** | 3 more months on that computer | a free account at [gucli.com](https://gucli.com) |
+| **After that** | gu asks for a token | Pro, or a voucher for more free days |
 | **Pro** | **$4 a month** or **$40 a year** (+ VAT where it applies) | hosted models (no model server to run), any number of computers, provider budgets |
 
 On Pro, the hosted models and the hosted API run on gu's servers, so the prompts and code you
@@ -206,6 +217,11 @@ so the step that adds npm's bin folder to your PATH may not have run. Run
 `npx @tiens.nguyen/gu-cli fix-path`. It also finds what an old install left behind (broken links,
 a second gu from another npm, a stale PATH line) and asks before fixing each one. `--check` only reports.
 
+**`EACCES` / permission denied during install (macOS, Linux).** npm's global folder belongs to
+root. No sudo needed: run `npm config set prefix ~/.npm-global`, then install again. gu adds that
+folder to your PATH; open a new terminal. With nvm, skip that (nvm refuses an npm prefix):
+`nvm use` a Node 20.19 or newer and install again.
+
 **Windows: `gu` runs `Get-Unique`.** PowerShell has a built-in `gu` alias. Run `gu-cli fix-powershell`.
 
 **Node version.** gu needs **Node.js 20.19+** (a Pro install using only hosted models runs on 18+).

package/agent-model-label.mjs

@@ -153,7 +153,7 @@ export function sameModelName(a, b) {
 /** Plain-text fallback for each reason we cannot name the model. Never a sentinel. */
 export const UNKNOWN_MODEL_TEXT = Object.freeze({
   remote: "(named by the remote server)",
-  "not-set": "not set — /agent-model",
+  "not-set": "same as the coding model",
   "no-server": "(no model server running)",
   ambiguous: "(the loaded model)",
 });

package/client-expert-run.mjs

@@ -20,8 +20,9 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
 import { createHash } from "node:crypto";
-import { localModeNodeProblem } from "./node-version.mjs";
+import { localModeNodeProblem, nvmNodeVersions } from "./node-version.mjs";
 import { downloadMongodExe, startPortableMongod, portableMongoInstalled, mongoWinPaths, mongodCommandLine, MONGO_WIN_VERSION, mongodRuns, isDllNotFoundExit, installVcRuntime, VC_REDIST_URL } from "./mongo-windows.mjs";
+import { macosMajor, macNeedsOwnMongo, mongoMacPaths, macMongoInstalled, downloadMongodMac, mongodRunsMac, MONGO_MAC_OLD_VERSION, MONGO_MAC_BREW_MIN_MAJOR } from "./mongo-mac.mjs";
 import {
   apiDepsInstalled,
   installApiDeps,
@@ -248,11 +249,17 @@ export async function probeMongo() {
   // saying ("you already have mongosh") and because `verify` runs through it.
   const serverPath = (await tryRun("sh", ["-c", "command -v mongod || true"])) || "";
   const shellPath = (await tryRun("sh", ["-c", "command -v mongosh || true"])) || "";
+  // gu's own mongod on macOS 13 and older (GH #403) is not on PATH; `portable` says to start that one.
+  const portable = process.platform === "darwin" && (await macMongoInstalled());
+  // On those Macs Homebrew's mongod cannot run, so it does not count as installed: "it is not
+  // running" would send the reader to a server that can never start.
+  const brewUsable = !(process.platform === "darwin" && macNeedsOwnMongo(macosMajor()));
   return {
     running: false,
     how: null,
-    installed: Boolean(serverPath.trim()),
+    installed: (brewUsable && Boolean(serverPath.trim())) || portable,
     shellInstalled: Boolean(shellPath.trim()),
+    portable,
   };
 }
 
@@ -298,7 +305,12 @@ export async function probeDockerForMongo(name = MONGO_DOCKER_NAME) {
  * macOS: make a native MongoDB answer on 27017 (task #304). → { ok, explained }.
  * `explained` = it printed its own guidance, so the caller adds none.
  */
-export async function ensureNativeMongoMac(ask, mongo, { log = (l) => console.log(l), brewHasTrust = null } = {}) {
+export async function ensureNativeMongoMac(ask, mongo, { log = (l) => console.log(l), brewHasTrust = null, osMajor = macosMajor, ownMongo = ensureOwnMongoMac } = {}) {
+  // macOS 13 and older: Homebrew's MongoDB installs and then cannot run there (GH #403), so gu
+  // runs its own. A Mac that already has gu's own mongod keeps using it after a macOS upgrade.
+  if (!mongo.silentPort && (mongo.portable || macNeedsOwnMongo(osMajor()))) {
+    return ownMongo(ask, mongo, { log });
+  }
   const mn = await import("./mongo-native.mjs");
   brewHasTrust ??= mn.brewHasTrust;
   const brew = mn.findBrew();
@@ -351,6 +363,71 @@ export async function ensureNativeMongoMac(ask, mongo, { log = (l) => console.lo
   return { ok: true, explained: true };
 }
 
+/**
+ * macOS 13 and older (GH #403): gu's own mongod 8.0.5 in ~/.gonext/mongodb, run on 127.0.0.1 —
+ * no Homebrew, no service, no sudo. Shown, asked, then done, like the other platforms.
+ * Not started at login: gu's start-up check (preflightLocalMongo) starts it again when needed.
+ */
+export async function ensureOwnMongoMac(ask, mongo, {
+  log = (l) => console.log(l),
+  osMajor = macosMajor,
+  paths = mongoMacPaths(),
+  download = downloadMongodMac,
+  runs = (p) => mongodRunsMac(p.exe),
+  start = startPortableMongod,
+  waitFor = null,
+} = {}) {
+  const installing = !mongo.portable;
+  const { host, port } = mongoHostPort(LOCAL_MONGO_URI);
+  if (installing) {
+    const major = osMajor();
+    log(dim(`\n  Homebrew's MongoDB needs macOS ${MONGO_MAC_BREW_MIN_MAJOR} or newer${major ? ` (this Mac has macOS ${major})` : ""}, so gu runs`));
+    log(dim(`  its own MongoDB ${MONGO_MAC_OLD_VERSION} instead — no Homebrew, no service, no password:\n`));
+    log(`    download MongoDB ${MONGO_MAC_OLD_VERSION} (about 85 MB) into ${paths.dir}`);
+  } else {
+    log(dim("\n  gu's MongoDB is installed but not running. This starts it:\n"));
+  }
+  log("    " + mongodCommandLine({ port, paths }));
+  log("");
+  const yes = await readYesNo(ask, `  ${installing ? "Install" : "Start"} MongoDB now? [Y/n]: `, true, log);
+  if (!yes) {
+    log(dim(`\n  Not ${installing ? "installed" : "started"} — run the commands above yourself.`));
+    return { ok: false, explained: true };
+  }
+  log("\n  " + bold(installing ? "Installing MongoDB" : "Starting MongoDB") + dim(installing ? "   about 85 MB" : ""));
+  if (installing) {
+    try {
+      await download({ paths, log });
+    } catch (e) {
+      log("\n  " + red("✗ ") + `could not download MongoDB: ${e?.message ?? e}`);
+      return { ok: false, explained: true };
+    }
+  }
+  const probe = await runs(paths);
+  if (!probe.ok) {
+    log("\n  " + red("✗ ") + `MongoDB cannot run on this Mac: ${probe.why}`);
+    return { ok: false, explained: true };
+  }
+  let started;
+  try {
+    started = await start({ port, paths });
+  } catch (e) {
+    started = { ok: false, error: e };
+  }
+  if (!started?.ok) {
+    log("\n  " + red("✗ ") + `MongoDB could not be started${started?.error ? `: ${started.error.message ?? started.error}` : ""}`);
+    return { ok: false, explained: true };
+  }
+  const wait = waitFor ?? (await import("./mongo-native.mjs")).waitForMongo;
+  if (!(await wait(host, port, { timeoutMs: 60000 }))) {
+    log("\n  " + red("✗ ") + `MongoDB was ${installing ? "installed" : "started"} but is not answering at ${host}:${port} yet.`);
+    log(dim(`  Its log:  ${paths.log}   — then run gu again.`));
+    return { ok: false, explained: true };
+  }
+  log("  " + cyan("✓ MongoDB is running") + dim(` at ${host}:${port} (started by gu — data in ${paths.data})`));
+  return { ok: true, explained: true };
+}
+
 /** /etc/os-release → { id, codename, versionId }, or null where there is none (not Linux). */
 export function readOsRelease({ read = (f) => readFileSync(f, "utf8") } = {}) {
   let text = "";
@@ -622,7 +699,8 @@ export async function preflightLocalMongo({
   log("\n  " + red("gu: MongoDB is not answering") + dim(` at ${host}:${port}`) +
     red(mongo.installed || mongo.silentPort || !local ? "." : " — it is not installed on this machine."));
   log(dim("  Local mode keeps your conversations, models and keys in that database, so"));
-  log(dim(`  nothing can start without it. The API on :${LOCAL_API_PORT} is fine — it is waiting on this.`));
+  // Nothing here checks the API, so say nothing about it (it was "fine" with no API process, GH #406).
+  log(dim("  nothing can start without it. gu starts the API once the database answers."));
   if (!local) {
     log(dim(`\n  That database is on another machine (${host}). Start it there, then run gu again.\n`));
     return { ok: false, fixed: false, installed: false };
@@ -1132,7 +1210,7 @@ export async function runClientExpertSetup({
   // BEFORE ANYTHING IS INSTALLED (task #333): the API needs a newer Node than gu does. Not part
   // of the gate on purpose — a gate "no" makes the first run settle on Cloud mode for good,
   // while the fix here is a Node upgrade, after which `gu` must resume Local setup.
-  const nodeProblem = localModeNodeProblem(process.version, machine.platform);
+  const nodeProblem = localModeNodeProblem(process.version, machine.platform, { nvmVersions: nvmNodeVersions() });
   if (nodeProblem) {
     console.log("\n  " + red("✗ ") + nodeProblem + "\n");
     return { complete: false, stoppedAt: "node" };
@@ -1189,6 +1267,7 @@ export async function runClientExpertSetup({
     // "Docker is not available here": a machine without Docker is the ordinary case on a server
     // and on Windows, not an error to open with.
     let explained = false;
+    const hadServer = Boolean(mongo.installed);
     if (machine.platform !== "darwin" && !mongo.silentPort && (await probeDockerForMongo()).usable) {
       if (await startMongoInDocker(ask)) {
         mongo.running = true;
@@ -1233,6 +1312,8 @@ export async function runClientExpertSetup({
       mongo.running = true;
       mongo.how = after.how;
     }
+    // Setup INSTALLED it a moment ago, so it has no credentials of its own to ask about.
+    mongo.installedNow = !hadServer;
   }
 
   console.log("\n  " + cyan("✓ MongoDB is running") + dim(` (${mongo.how})`));
@@ -1251,6 +1332,8 @@ export async function runClientExpertSetup({
     if (mongoUri !== LOCAL_MONGO_URI) {
       console.log(dim("  using the MongoDB credentials from the previous run"));
     }
+  } else if (credsDecision === "ask" && mongo.installedNow) {
+    state = { ...state, mongoCredsConfirmed: true };
   } else if (credsDecision === "ask") {
     const credsChoice = await askMongoCredentials(ask, askSecret);
     if (credsChoice.exit) {
@@ -1575,8 +1658,10 @@ export async function runClientExpertSetup({
     }
     if (skipModels) {
       console.log("");
-      console.log("  " + cyan("✓ Model setup skipped") + dim(addProvider
-        ? ` — ${addProvider.name || "the provider list"}: its key and model are asked as soon as gu starts`
+      // "skipped" is only true when nothing was chosen: a provider that was picked is NOT skipped,
+      // its key and model are just asked in gu itself (GH #397).
+      console.log("  " + cyan(addProvider ? `✓ ${addProvider.name || "Provider"} chosen` : "✓ Model setup skipped") + dim(addProvider
+        ? " — gu asks for its key and model as soon as it starts"
         : loadPreset
         ? " — the preset picker opens as soon as gu starts"
         : " — set them any time with /model (or /use-presets)"));

package/doctor-check.mjs

@@ -83,14 +83,17 @@ export function rolesFromPayload(payload, settings, codingKey = "") {
   const realKey = (k) => (str(k) && str(k) !== "local" ? str(k) : "");
   const [, , embed] = rolesFromSettings(settings);
   const agentSet = payload.agentMissing !== true;
+  // NO SEPARATE AGENT MODEL: the coding model answers the chat calls too (GH #397), so check it
+  // on THAT path with its key — a "not set" here hid a 401 on "hi" while coding turns worked.
+  const chat = agentSet
+    ? { url: str(payload.agentBaseURL), model: str(payload.agentModelId), apiKey: realKey(payload.agentApiKey) }
+    : { url: str(payload.codingBaseURL), model: str(payload.codingModelId), apiKey: realKey(codingKey) };
   return [
     {
       role: "chat",
       label: "chat model",
-      why: "answers and routes every turn",
-      url: agentSet ? str(payload.agentBaseURL) : "",
-      model: agentSet ? str(payload.agentModelId) : "",
-      apiKey: agentSet ? realKey(payload.agentApiKey) : "",
+      why: agentSet ? "answers and routes every turn" : "answers and routes every turn (the coding model, none set apart)",
+      ...chat,
     },
     {
       role: "code",

package/embed-model-command.mjs

@@ -228,14 +228,14 @@ export function embedNotice({ state, model } = {}) {
  * WHICH SETUP ROWS THE BOTTOM BAR SHOWS (first-run noise, #188). A fresh install used to stack
  * three warnings at once. Now they come in order of need, and pure (no OS-specific logic):
  *  - nothing to answer with → ONLY "coding model not set" (the one thing to do first);
- *  - a coding model exists but no agent model → the agent row (the coding model stands in);
+ *  - a coding model exists but no agent model → NOTHING: one model that also talks is the normal
+ *    setup, not a fault (GH #397). `agentMissing` is still accepted and ignored.
  *  - no embed model → NOTHING until embedding was actually needed (`embedNeeded`: the agent tried
  *    a RAG tool, or the user opened /embed-model), then the embed row.
  */
 export function setupNoticeRows({ noModel = false, agentMissing = false, embedMissing = false, embedNeeded = false, embedWhy } = {}) {
   if (noModel) return ["coding model not set · /model"];
   return [
-    ...(agentMissing ? ["agent model not set — using the coding model · /agent-model"] : []),
     ...(embedMissing && embedNeeded ? [embedNotice(embedWhy) || "no embed model — RAG is off · /embed-model"] : []),
   ];
 }

package/gu-cli.mjs

@@ -400,7 +400,7 @@ if (["start", "stop", "status", "logs", "restart"].includes(args[0])) {
     if (await ctl.isClientMode()) {
       console.log(
         "[gu-worker] CLIENT mode — this machine runs the agent but serves no models;\n" +
-          "                it calls your model machine over the network. `/host-mode` undoes it."
+          "                it calls your model machine over the network. `gu clear` starts setup over."
       );
     }
     if (s.running) {
@@ -4214,7 +4214,13 @@ async function runAgentChatJob(job) {
     const input = JSON.stringify({
       messages: payload?.messages ?? [],
       agentBaseURL,
-      agentApiKey: payload?.agentApiKey ?? "",
+      // NO AGENT MODEL SET (GH #397): the API points the chat calls at the coding model and sends
+      // the placeholder key "local". Chat calls ("hi", the plain-reply fallback, routing) must
+      // carry the CODER's real key, or a hosted provider answers 401 while coding turns work.
+      agentApiKey:
+        payload?.agentMissing === true && codingApiKey
+          ? codingApiKey
+          : (payload?.agentApiKey ?? ""),
       agentModelId,
       // Task #134: on a CLIENT the RAG embedder lives on the model machine, so "run doctor
       // here" is advice that cannot work. The agent uses this to say the right thing.

package/gu-repl.mjs

@@ -126,7 +126,6 @@ import {
   nothingToAnswerWith,
   NO_MODEL_LINES,
   resizeRepaintTarget,
-  workspaceSyncQuestion,
   workspaceAccessQuestion,
   workspaceSyncLabel,
   activeCoderName,
@@ -1052,9 +1051,8 @@ const COMMANDS = [
   // The two synonyms were dispatched but declared nowhere (found by slash-command-wiring.test.mjs):
   // they worked, Tab-completed to nothing, and appeared in no help. Aliases is what the registry
   // already has for exactly this — /quit, /rag-local.
-  { name: "/host-mode", desc: "undo client mode — run agent turns on THIS machine again" },
+  // /host-mode is gone (owner, 11-07): modes are chosen at setup; `gu clear` sets up again.
   // /undo is HIDDEN_COMMANDS now — still works when typed.
-  { name: "/server", desc: "pick a deployment server (host/user) for this session" },
   { name: "/proxy", usage: "/proxy [show|set|on|off|clear|test]", desc: "route MODEL calls through an HTTP proxy (local calls always go direct)" },
   { name: "/s3", usage: "/s3 [test]", desc: "set up YOUR S3 bucket (RAG index, and the PDFs/downloads gu makes) and check the AWS keys work — without it, files are saved on this computer" },
   { name: "/context-window", usage: "/context-window [tokens|auto]", desc: "tell gu how big the coding model's context is — hosted models cannot be probed" },
@@ -2720,6 +2718,11 @@ let cliNoticeShown = false;
 function announceCliUpdate() {
   if (cliNoticeShown || !availableUpdates.cli) return;
   if (following) return; // a turn owns the transcript — try again at the next prompt
+  // …and so does an open menu or question (GH #397): printed into a picker's in-place block, the
+  // notice pushed it down and the picker could no longer erase itself — the rows of a menu left
+  // closed stayed on screen. Retried at the next prompt, like a turn.
+  // A slash command still running hides the input row (inputVisible): its output is not done.
+  if (listPickerActive || askWaiting || !inputVisible) return;
   let lines = [];
   try {
     lines = repeatUpdateNotice({ last: readUpdateAttempt(), cli: availableUpdates.cli, running: REPL_VERSION,
@@ -5244,7 +5247,7 @@ const ask = async (q, { prefill = "", hint = [], atomic = false, noCancel = fals
 // Masked prompt for a secret (an API key). Mutes readline's echo/refresh (secretInput)
 // so the typed value never hits the terminal or scrollback (task #127). Returns "" on a
 // bare Enter (skip).
-const askSecret = async (q) => {
+const askSecret = async (q, { hint = [] } = {}) => {
   // Same rule as ask(): input has ended, so stop. Returning "" here would hand an EMPTY
   // secret to a caller that is about to store or send it.
   if (_stdinClosed) return await ask("");
@@ -5255,6 +5258,9 @@ const askSecret = async (q) => {
   // FOR. With the bar pinned the row itself becomes the prompt, so nothing is left to infer.
   secretPrompt = String(q ?? "").replace(/\s+$/, "") + " ";
   secretInput = true;
+  // A hint UNDER the input, gone once answered (GH #397) — printed above, "type or paste the
+  // key…" stayed in the history after the key was in, as if it were still being asked.
+  askHint = barPinned() ? hint : [];
   // Same reason as ask() above: inputLineFor returns "" when inputVisible is false, so the one
   // bullet per character — the only proof a keystroke registered while the echo is muted —
   // would not be drawn either. askSecret is reached from /model, which is exactly a command
@@ -5264,7 +5270,10 @@ const askSecret = async (q) => {
   // Unpinned (piped output, or a window too short to reserve rows) there IS no frozen row, so
   // the label has to be printed the old way or the prompt is silent.
   if (barPinned()) paintBar();
-  else process.stdout.write(q);
+  else {
+    for (const l of hint) console.log(GUTTER + dim(l));
+    process.stdout.write(q);
+  }
   let raw = "";
   try {
     askWaiting = true;
@@ -5277,6 +5286,7 @@ const askSecret = async (q) => {
     askWaiting = false;
     secretInput = false;
     secretPrompt = "";
+    askHint = [];
     inputVisible = _secretWasVisible;
     // READLINE KEEPS EVERY SUBMITTED LINE (task #191). Muting the echo stops the key reaching
     // the screen; it does nothing about rl.history, which is where the line goes on Enter — so
@@ -5343,10 +5353,10 @@ async function ensureWorkspace() {
     // Registered before cloud sync existed → ask once and persist. Otherwise honor the
     // stored choice. (undefined = old record that never opted in → ask.)
     if (hit.allowSync === undefined) {
-      const q = workspaceSyncQuestion({ clientExpert: isClientExpert() });
-      hit.allowSync = q.ask
-        ? await askYesNo("Allow syncing this workspace's chat history to the cloud?", true)
-        : q.value;
+      // No question (owner, 11-07): the mode chosen at setup decides where history goes —
+      // the cloud on a hosted account, the local database on Client Expert. A folder that
+      // answered No before keeps that answer; only a folder never asked is filled in.
+      hit.allowSync = true;
       await writeFile(WS_FILE, JSON.stringify({ workspaces: list }, null, 2) + "\n");
     }
     // The workspace facts now live in the startup banner (task #131) — just remember them.
@@ -5380,16 +5390,10 @@ async function ensureWorkspace() {
   } catch (e) {
     console.log(GUTTER + yellow(`Could not save the browser permission (${e?.message || e}) — gu will ask when it first needs it.`));
   }
-  // On Client Expert there is no cloud to sync TO — see workspaceSyncQuestion.
-  const syncQ = workspaceSyncQuestion({ clientExpert: isClientExpert() });
-  const allowSync = syncQ.ask
-    ? await askYesNo(
-        "Allow syncing this workspace's chat history to the cloud?\n" +
-          "(your conversation is saved to your account so you can see it on the web app)",
-        true /* default Yes — RAG is NOT synced (it stays on your S3); only chat history. */
-      )
-    : syncQ.value;
-  if (!syncQ.ask && syncQ.note) console.log(wrapGutter(syncQ.note, dim));
+  // NO SYNC QUESTION (owner, 11-07): Cloud or Client Expert is chosen once, at setup, and it
+  // decides where chat history lives — your account's cloud database, or the local one. To
+  // change it, `gu clear` and set up again. RAG is never synced (it stays where it was built).
+  const allowSync = true;
   const next = list.filter((w) => w.path !== cwd);
   next.push({
     name: basename(cwd),
@@ -6297,10 +6301,12 @@ async function pickExtraModels(rest0, preChecked = []) {
   const already = new Set(preChecked);
   const { codingModelCandidates } = await import("./coding-provider-setup.mjs");
   const keep = new Set(codingModelCandidates(rest0).models);
-  const rest = rest0.filter((m) => keep.has(m) || already.has(m));
+  const rest = rest0
+    .filter((m) => keep.has(m) || already.has(m))
+    .sort((a, b) => a.localeCompare(b, "en", { numeric: true })); // as the pick above (GH #397)
   if (rest.length === 0) return [];
-  console.log(dim(`   Also offer these in /model?  (up to ${MAX_ALT_CODERS})`));
-  console.log(dim(`   ${PICK_MANY_HINT}`));
+  console.log(dim(`   Any other models to switch to in /model?  optional · up to ${MAX_ALT_CODERS}`));
+  console.log(dim(`   space ticks · Enter saves (nothing ticked skips this) · Esc cancels`));
   const ticks = await pickManyFromList(
     rest,
     rest.map((m, i) => (already.has(m) ? i : -1)).filter((i) => i >= 0),
@@ -6328,7 +6334,12 @@ async function pickExtraModels(rest0, preChecked = []) {
  * Returns the model id, or null when the user cancelled.
  */
 async function chooseCodingModelFrom(ps, all, question, current, { back = false } = {}) {
-  const { models: coders, filtered } = ps.codingModelCandidates(all);
+  const { models: coders0, filtered } = ps.codingModelCandidates(all);
+  // SORTED, like /agent-model's list (GH #397): the provider's own order is arbitrary, and a
+  // family (qwen3.8-*, deepseek-v4-*) scattered over the list is hard to scan.
+  const byName = (a, b) => a.localeCompare(b, "en", { numeric: true });
+  const coders = [...coders0].sort(byName);
+  all = [...all].sort(byName);
   let list = coders;
   let showingAll = filtered === 0;
   for (;;) {
@@ -6372,8 +6383,9 @@ async function chooseCodingModelFrom(ps, all, question, current, { back = false
  * stays available for the same reason it does there — a listed model may be unusable and an
  * unlisted one may be exactly right.
  */
-async function chooseFromModelList(all, question, current = 0, { back = false } = {}) {
-  const rows = [...all, "type a model name…"];
+async function chooseFromModelList(all, question, current = 0, { back = false, notes = null } = {}) {
+  // `notes` (GH #397): a dim note per row ("an audio/speech model"), as /agent-model's own list has.
+  const rows = [...all.map((m, i) => (notes?.[i] ? `${m}${dim(`  · ${notes[i]}`)}` : m)), "type a model name…"];
   const at = typeof current === "string" ? all.indexOf(current) : Number(current) || 0;
   const idx = await pickFromList(rows, at >= 0 ? at : 0, {
     back,
@@ -6390,6 +6402,21 @@ async function chooseFromModelList(all, question, current = 0, { back = false }
   return all[idx];
 }
 
+/**
+ * The agent's pick from a fresh provider (GH #397): the SAME order and labels as /agent-model's
+ * "pick another model on <host>…" — chat models alphabetically, then audio/image/video models
+ * sunk to the bottom and named. The add flow showed them mixed in and unlabelled.
+ */
+async function pickAgentModelFrom(models, question, current, opts) {
+  const am = await import("./agent-model-command.mjs");
+  const sorted = am.agentModelsFromProvider(models);
+  const ids = sorted.map((m) => m.model);
+  return chooseFromModelList(ids, question, Math.max(0, ids.indexOf(current)), {
+    ...opts,
+    notes: sorted.map((m) => m.note),
+  });
+}
+
 /**
  * /model's provider manager. `back` (#242): opened from /model's list, so its first menu offers
  * "← back" and returns BACK. Inside it, each sub-menu's "← back" returns HERE — re-read, because a
@@ -6750,6 +6777,7 @@ async function removeCodingProvider(ps, rows, p) {
  *   newKey    ask for a key even if the server has one (the stored one was refused)
  */
 async function addServer({ role = "coding", dialect = "openai", url: presetUrl = "", model: presetModel = "", plan: presetPlan = null, newKey = false, back = false } = {}) {
+  let claudeSdkLater = false; // offered after the save, see step 1
   const as = await import("./add-server.mjs");
   const ps = await import("./coding-provider-setup.mjs");
   const sk = await import("./server-keys.mjs");
@@ -6802,7 +6830,9 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
       const OLLAMA_HERE = 0;
       const rowsShown = [
         `Ollama — this machine or your network…${dim("  · e.g. 127.0.0.1:11434")}`,
-        ...presets.map((p) => `${p.name}${dim(`  · ${p.url}`)}`),
+        // The HOST, not the full URL (GH #397): "…/compatible-mode/v1" ran past 100 columns and was
+        // cut mid-word; the path is plumbing, and the URL is echoed in full once one is picked.
+        ...presets.map((p) => `${p.name}${dim(`  · ${hostOf(p.url)}`)}`),
         "another URL…",
       ];
       // A preset names its own dialect (Ollama cloud is "ollama"); the rest are OpenAI-compatible.
@@ -6857,10 +6887,10 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
       console.log("");
       return;
     }
-    // Claude as the CODER: prompt caching needs Anthropic's SDK (#262) — offer it once, here.
-    if (target.claude && role === "coding") {
-      await md.ensureClaudeSdk({ log: (l) => console.log(GUTTER + dim(l.trim())), confirm: (q) => askYesNo(`  ${q}`, true) });
-    }
+    // Claude as the CODER: prompt caching needs Anthropic's SDK (#262). Offered AFTER the key and the
+    // model are saved (GH #397): asked first, it interrupted the flow before the user had even been
+    // asked for a key, and dumped pip's raw output over the screen.
+    claudeSdkLater = Boolean(target.claude && role === "coding");
 
     // --- 2. the server's key --------------------------------------------------------------
     // AN EXISTING SERVER IS REUSED, never stored twice (two rows for one URL would be two picker
@@ -6968,7 +6998,9 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
         const canBack = { back: providerPicker || back };
         model = R.filterCoders
           ? await chooseCodingModelFrom(ps, models, R.question, 0, canBack)
-          : await chooseFromModelList(models, R.question, Math.max(0, models.indexOf(current)), canBack);
+          : role === "agent"
+            ? await pickAgentModelFrom(models, R.question, current, canBack)
+            : await chooseFromModelList(models, R.question, Math.max(0, models.indexOf(current)), canBack);
         if (model === BACK) {
           if (providerPicker) continue; // → Which provider?
           return BACK;
@@ -7083,7 +7115,16 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
     }
     return;
   }
-  await useCoderInThisFolder({ ps, rows, beforeChoices, url: target.url, host, locality: target.locality, model, backendId: rowId, key, keyName });
+  await useCoderInThisFolder({ ps, rows, beforeChoices, url: target.url, host, locality: target.locality, model, backendId: rowId, key, keyName, extras });
+  if (claudeSdkLater) {
+    // pip's own lines ("Requirement already satisfied…", "Collecting…") are noise here: keep gu's.
+    const pipNoise = /^(Requirement already satisfied|Collecting|Downloading|Using cached|Installing collected|Successfully installed|Obtaining|Preparing|Building|Created wheel|Stored in directory|WARNING|\[notice\]|\s*[━╸─]+)/i;
+    await md.ensureClaudeSdk({
+      log: (l) => { const t = String(l ?? "").trim(); if (t && !pipNoise.test(t)) console.log(GUTTER + dim(t)); },
+      confirm: (q) => askYesNo(`  ${q}`, true),
+    });
+    console.log("");
+  }
 }
 
 /**
@@ -7096,7 +7137,7 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
  *   · DID SAVING EVICT ANOTHER PROVIDER? An API older than row ids keys a backend by its KIND,
  *     so a second openai row replaced the first with a 200. Said BEFORE the success line.
  */
-async function useCoderInThisFolder({ ps, rows, beforeChoices, url, host, locality, model, backendId, key, keyName }) {
+async function useCoderInThisFolder({ ps, rows, beforeChoices, url, host, locality, model, backendId, key, keyName, extras = [] }) {
   const cwd = resolve(process.cwd());
   const after = await withPendingStatus("checking it is offered", () =>
     fetchAgentPayload([{ role: "user", content: "ping" }]).catch(() => null)
@@ -7145,15 +7186,23 @@ async function useCoderInThisFolder({ ps, rows, beforeChoices, url, host, locali
   // that was just entered, which reads as the save having failed.
   codingKeyMissingKnown = false;
   console.log(accent(` ✓ coding model → ${model}`) + dim(`  · ${host}`));
-  if (key) console.log(dim(`   API key ${keyName || "saved"} ····${key.slice(-4)}  ·  ${host}'s key\n`));
+  if (key) console.log(dim(`   API key ${keyName || "saved"} ····${key.slice(-4)}`));
+  // The extras were ticked a screen ago and never mentioned again (GH #397) — say where they went.
+  if (extras.length) console.log(dim(`   also in /model: ${extras.join(", ")}`));
+  console.log("");
   // A HOSTED SERVER NEEDS ITS WINDOW SET: with nothing set gu assumes 24,000 prompt tokens and
   // compacts there — on a large hosted model that throws history away every turn.
   if (ps.shouldMentionContextWindow(locality)) {
-    console.log(GUTTER + dim("tip: /context-window — hosted servers do not report their size,"));
-    console.log(GUTTER + dim("     so gu assumes 24,000 prompt tokens and compacts there.\n"));
+    console.log(GUTTER + dim("tip: set this model's context size with /context-window —"));
+    console.log(GUTTER + dim("     hosted providers don't report it, so gu assumes 24k tokens.\n"));
   }
   const t = await fetchOutputTokenTotals(cwd);
   { const g = pickGlobalTotal(t); if (g !== null) globalOutputTokens = g; }
+  // The bar still said "coding model not set · /model" under the success line of the FIRST model
+  // added on a fresh install, until the next turn repainted it (GH #397).
+  noModelAtAll = after?.payload ? nothingToAnswerWith(after.payload) : false;
+  if (after?.payload) agentMissing = after.payload.agentMissing === true;
+  if (barPinned()) paintBar();
 }
 
 
@@ -7258,7 +7307,7 @@ async function chooseModel() {
     // through to add when there is genuinely nothing there.
     // As the picker's header (GH #397), so "← back" re-opening this menu does not stack it.
     const go = await pickFromList(
-      [dim("leave it"), "add or change a provider — Claude API, OpenAI, Kimi…"],
+      [dim("leave it"), "add a provider — Claude API, OpenAI, Kimi, Ollama…"],
       1,
       { header: () => [dim("   No coding model configured.")], headerRows: 1 }
     );
@@ -7271,16 +7320,10 @@ async function chooseModel() {
   // provider manager is where another one is added (an Ollama box is "another URL…").
   // #412 removed "change the Ollama server this machine uses…" from all three menus: it re-asked
   // the agent, embedder and coder servers in one go, which confused people picking a model.
-  if (choices.length === 1) {
-    console.log(dim(`   Only one coding model is available: ${choices[0].model}.`));
-    const go = await pickFromList(
-      [dim("keep it"), "add or change a provider — Claude API, OpenAI, Kimi…"],
-      0
-    );
-    if (go === 1 && (await manageCodingProviders({ back: true })) === BACK) return chooseModel();
-    if (go !== 1) console.log("");
-    return;
-  }
+  // GH #397: ONE model used to get its own screen ("Only one coding model is available: X ·
+  // keep it / add or change a provider"). Set up from /agent-model first, that was the agent's
+  // model — and the other 12 coders on the same provider were three menus away. The full menu
+  // below already has "pick another model on <host>…", keys and add, so one model uses it too.
   const active = sessionCodingModel || def;
   // Arrow-key picker (↑/↓ + Enter) — pre-highlight the active model, tag the default, and
   // name the backend when more than one is in play (the same model name can appear twice).
@@ -7289,6 +7332,9 @@ async function chooseModel() {
   // OpenAI-compatible providers are both "OpenAI-compatible", so the kind names neither.
   const { labels, tags, showTag } = codingChoiceLabels(choices, def);
   const activeIdx = choices.findIndex((c) => c.id === active);
+  // GH #397: "(default)" marked the account default while this folder used another model, and
+  // nothing said which one runs here. The one in use is marked.
+  if (activeIdx >= 0 && choices[activeIdx].id !== def) labels[activeIdx] += accent("  (in use here)");
   // THE CURRENT CODER'S KEYS, ON THIS LIST (#248) — the manager ctrl+k opens, for a provider that
   // takes a key (OpenAI-compatible, ollama.com). Before the add row, so no model row moves.
   const activeChoice = choices[activeIdx >= 0 ? activeIdx : choices.findIndex((c) => c.id === def)];
@@ -9357,8 +9403,9 @@ async function askServerKey({ host = "", optional = false, escBack = false, name
   // A RETRY KEEPS THE NAME (GH #397): only the secret was wrong, so only the secret is asked.
   if (knownName === null) console.log("\n" + GUTTER + dim(escBack ? "Esc goes back to the providers." : "Esc to cancel."));
   const name = knownName === null ? (await askKeyName()).trim() : String(knownName);
-  console.log(GUTTER + dim(SECRET_KEY_HINT));
-  const secret = (await askSecret(`   API key${host ? ` for ${host}` : ""}${name ? ` (${name})` : ""}: `)).trim();
+  const secret = (
+    await askSecret(`   API key${host ? ` for ${host}` : ""}${name ? ` (${name})` : ""}: `, { hint: [SECRET_KEY_HINT] })
+  ).trim();
   if (!secret) {
     console.log(GUTTER + dim(optional ? "(no key — the server will be called anonymously)" : "(cancelled — nothing was saved)\n"));
     return { name, secret: "" };
@@ -9446,19 +9493,38 @@ async function chooseAgentModel() {
   const source = am.agentListSource(settings);
   const needsKey = am.agentSourceNeedsKey(source);
   for (;;) {
-    const labels = saved.map((c) => c.label + (c.current ? accent("  (current)") : ""));
+    // The first row is the default and the way back to ONE model: the coding model talks too (GH #397).
+    const labels = [
+      `same as the coding model${dim("  — follows /model")}` + (current ? "" : accent("  (current)")),
+      ...saved.map((c) => c.label + (c.current ? accent("  (current)") : "")),
+    ];
     const MODELS = curHost ? labels.length : -1;
     if (curHost) labels.push(actionRow(`pick another model on ${curHost}…`));
+    // NO SEPARATE AGENT MODEL YET: offer the coder's own server, so a talking model from the provider
+    // already set up is one pick away — its saved key is reused (GH #397).
+    const coderUrl = (await import("./coding-provider-setup.mjs")).ensureV1Root(String(sessionCodingUrl || defaultCodingUrl || "")).toLowerCase();
+    const coderRow = curHost ? null : (saved.find((c) => c.url.toLowerCase() === coderUrl) ?? null);
+    const CODER_MODELS = coderRow ? labels.length : -1;
+    if (coderRow) labels.push(actionRow(`pick another model on ${coderRow.host}…`));
     const KEYS = curHost && needsKey ? labels.length : -1;
     if (KEYS >= 0) labels.push(actionRow(`API keys for ${curHost} — switch, add or remove…`));
     const ADD = labels.length;
     labels.push(actionRow("add a provider — Claude API, OpenAI, Kimi, Ollama…"));
     // The hint drops to its own row when the header would wrap (80 columns over SSH).
-    const head = `   Agent model — the one that TALKS (now ${current || "unset"}${curHost ? ` on ${curHost}` : ""})`;
+    // GH #397: "(now unset)" hid that the coding model answers in the meantime; and printed
+    // before the list, this title stacked each time "← back" re-opened the menu.
+    const now = current
+      ? `now ${current}${curHost ? ` on ${curHost}` : ""}`
+      : "same as the coding model";
+    const head = `   Agent model — the one that TALKS (${now})`;
     const hint = `(${PICK_ARROWS}):`;
     const cols = Math.max(20, process.stdout.columns || 80);
-    console.log(dim(head.length + 2 + hint.length < cols ? `${head}  ${hint}` : `${head}\n   ${hint}`));
-    const idx = await pickFromList(labels, Math.max(0, saved.findIndex((c) => c.current)), { footer: ESC_FOOTER });
+    const headLines = head.length + 2 + hint.length < cols ? [`${head}  ${hint}`] : [head, `   ${hint}`];
+    const idx = await pickFromList(labels, saved.findIndex((c) => c.current) + 1, {
+      footer: ESC_FOOTER,
+      header: () => headLines.map((l) => dim(l)),
+      headerRows: headLines.length,
+    });
     if (idx < 0) {
       console.log(dim("   (cancelled)\n"));
       return;
@@ -9468,6 +9534,11 @@ async function chooseAgentModel() {
       if ((await agentModelOnServer({ back: true, start: "models" })) === BACK) continue;
       return;
     }
+    if (idx === CODER_MODELS) {
+      const dialect = coderRow.kind === "ollama" ? "ollama" : "openai";
+      if ((await addServer({ role: "agent", dialect, url: coderRow.url, back: true })) === BACK) continue;
+      return;
+    }
     if (idx === KEYS) {
       const rowId = String(source.row?.id ?? "").trim() || String(source.row?.kind ?? "").trim();
       if (!rowId) return enterAgentProviderKey(source.row, curHost);
@@ -9478,7 +9549,12 @@ async function chooseAgentModel() {
       if ((await addServer({ role: "agent", dialect: "openai", back: true })) === BACK) continue;
       return;
     }
-    await useSavedAgentChoice(saved[idx]);
+    if (idx === 0) {
+      if (!current) console.log(dim("   already the same as the coding model — nothing changed.\n"));
+      else await useCoderForAgent();
+      return;
+    }
+    await useSavedAgentChoice(saved[idx - 1]);
     return;
   }
 }
@@ -9488,6 +9564,31 @@ async function chooseAgentModel() {
  * API finds the key by the URL (resolveKeyForRole), so nothing is re-entered — unless the server
  * needs a key and has none, which is asked here rather than failing on the next question.
  */
+/**
+ * "Same as the coding model" (GH #397): clear the separate agent model, so the coding model talks
+ * too — and keeps following each folder's /model pick. The way BACK to one model: before this the
+ * only route was removing the whole provider (and its key).
+ */
+async function useCoderForAgent() {
+  const md = await import("./model-doctor.mjs");
+  const saved = await withPendingStatus("saving", () =>
+    md.saveWorkerSettings(apiBase, workerKey, { agentModelUrl: "", agentModelName: "", agentModel: "" })
+  );
+  if (!saved) {
+    console.log(red("   couldn't save that — nothing changed.\n"));
+    return;
+  }
+  if (sessionAgentKeyId) await saveFolderKeyPick("agent", "");
+  console.log(accent(" ✓ agent model → same as the coding model") + dim("  ·  /model switches both"));
+  console.log(GUTTER + dim("takes effect on your next question.\n"));
+  const after = (await fetchAgentPayload([{ role: "user", content: "." }]).catch(() => null))?.payload;
+  if (after) {
+    agentMissing = after.agentMissing === true;
+    noModelAtAll = nothingToAnswerWith(after);
+  }
+  if (barPinned()) paintBar();
+}
+
 async function useSavedAgentChoice(c) {
   if (c.current) {
     console.log(dim(`   already using ${c.model} on ${c.host} — nothing changed.\n`));
@@ -9725,39 +9826,6 @@ async function agentModelOnServer({ back = false, start = "menu" } = {}) {
   console.log(dim("   takes effect on your next question.\n"));
 }
 
-// Probe whether SSH KEY auth already works for a server (so we can tell the user to run
-// ssh-copy-id if not). BatchMode=yes = never prompt for a password → exit!=0 if no key.
-async function checkServerKeyAuth(s) {
-  try {
-    const ok = await new Promise((resolve) => {
-      const p = spawn(
-        "ssh",
-        [
-          "-o", "BatchMode=yes",
-          "-o", "ConnectTimeout=6",
-          "-o", "StrictHostKeyChecking=accept-new",
-          `${s.user}@${s.host}`,
-          "true",
-        ],
-        { stdio: "ignore" }
-      );
-      p.on("exit", (code) => resolve(code === 0));
-      p.on("error", () => resolve(false));
-    });
-    if (ok) console.log(dim("    ✓ key auth works — deploys will connect without a password."));
-    else
-      console.log(
-        yellow("   key auth not set up yet.") +
-          dim(` Run once in your terminal:  `) +
-          `ssh-copy-id ${s.user}@${s.host}`
-      );
-  } catch {
-    /* best-effort check — never block the picker */
-  }
-}
-
-// /server — pick a deployment target (from the web app's Servers registry) for this
-// session. Host/user only, never a secret; the agent deploys here with KEY auth (#69).
 /**
  * `/proxy` — configure the outbound proxy for MODEL calls (task #160).
  *
@@ -10146,53 +10214,6 @@ async function runProxyCommand(line) {
   }
 }
 
-async function chooseServer() {
-  let servers;
-  try {
-    const res = await withPendingStatus("loading servers", () =>
-      fetch(`${apiBase}/api/worker/deploy-servers`, {
-        headers: { "X-Worker-Key": workerKey },
-        signal: AbortSignal.timeout(API_CALL_TIMEOUT_MS),
-      })
-    );
-    const data = await res.json().catch(() => ({}));
-    if (!res.ok) {
-      console.log(red(`   couldn't load servers: ${data?.error || `HTTP ${res.status}`}\n`));
-      return;
-    }
-    servers = Array.isArray(data?.servers) ? data.servers : [];
-  } catch (err) {
-    console.log(red(`   ${describeApiFailure(err, "couldn't load servers")}\n`));
-    return;
-  }
-  if (servers.length === 0) {
-    console.log(dim("   No deployment servers yet — add them in the web app → Servers.\n"));
-    return;
-  }
-  // Arrow-key picker: ↑/↓ to move, Enter to choose (no number typing). The list ends with
-  // a "none" row to clear the selection. Pre-highlight the current pick if there is one.
-  const labels = servers.map((s) => `${s.name}  (${s.user}@${s.host})`);
-  labels.push("none (clear selection)");
-  const activeIdx = servers.findIndex((s) => s.host === selectedServer?.host);
-  console.log(dim(`   Choose a deployment server  (${PICK_HINT}):`));
-  const idx = await pickFromList(labels, activeIdx >= 0 ? activeIdx : 0);
-  if (idx < 0) {
-    console.log(dim("   (cancelled)\n"));
-    return;
-  }
-  if (idx === servers.length) {
-    // the trailing "none" row
-    selectedServer = null;
-    console.log(dim(" ✓ deployment server cleared.\n"));
-    return;
-  }
-  const s = servers[idx];
-  selectedServer = { name: s.name, host: s.host, user: s.user };
-  console.log(accent(` ✓ deploy target → ${s.name} (${s.user}@${s.host})`));
-  await checkServerKeyAuth(selectedServer);
-  console.log("");
-}
-
 /**
  * Ask for the coding model's API key if the resolved coder needs one and none is stored.
  *
@@ -10921,8 +10942,7 @@ async function replaceCodingKey({ back = false } = {}) {
       (ks.stored ? dim("(replacing ") + accent(maskKey(ks.stored)) + dim(")") : dim("(none stored)")) +
       dim("  ·  Enter alone cancels, \"clear\" removes it\n")
   );
-  console.log(GUTTER + dim(SECRET_KEY_HINT));
-  const typed = (await askSecret(`  ${ks.model} API key: `)).trim();
+  const typed = (await askSecret(`  ${ks.model} API key: `, { hint: [SECRET_KEY_HINT] })).trim();
   if (!typed) {
     console.log(GUTTER + dim("(cancelled — the stored key is unchanged)\n"));
     paintBar();
@@ -10976,7 +10996,9 @@ async function manageServerKeys({ role = "coding", backendId, host, model = "",
   });
   const ADD = rows.length;
   rows.push(dim("add a new key…"));
-  console.log("\n" + GUTTER + dim(`Keys for ${host} — ${folderLabel()}'s ${roleLabel}${model ? ` (${model})` : ""}\n`));
+  // The agent model is a MACHINE setting (GH #397): "proj's agent model" named a folder it is not tied to.
+  const whose = role === "agent" ? `the ${roleLabel}` : `${folderLabel()}'s ${roleLabel}`;
+  console.log("\n" + GUTTER + dim(`Keys for ${host} — ${whose}${model ? ` (${model})` : ""}\n`));
   console.log(GUTTER + dim("Enter chooses · ctrl+d deletes the highlighted key\n"));
   const picked = await pickFromList(rows, Math.max(0, keys.findIndex((k) => k.id === inUse?.id)), { allowDelete: true, back });
   const idx = picked?.index ?? -1;
@@ -11904,6 +11926,28 @@ function pickFromList(items, initialSel = 0, opts = {}) {
     listTimeoutIndex = -1;
     listHeader = typeof opts.header === "function" ? opts.header : null;
     listHeaderRows = listHeader ? Math.max(0, opts.headerRows | 0) : 0;
+    // A STATIC HEADER WIDER THAN THE TERMINAL IS WRAPPED AT WORDS (GH #397), not clipped: on 80
+    // columns "Which model on token-plan.maas.qwencloudapi.com? (↑/↓ then Enter · Esc to c" lost
+    // its way out. Done once, here, so the block keeps the constant height its redraw walks
+    // depend on. A live panel (refreshMs) is already sized by its caller and is left alone.
+    if (listHeader && !(opts.refreshMs > 0)) {
+      const w = Math.max(20, process.stdout.columns || 80) - 1;
+      let given = [];
+      try { given = (listHeader(listHeaderRows) || []).slice(0, listHeaderRows); } catch { /* blank */ }
+      if (given.some((l) => visibleLen(l) > w)) {
+        const wrapped = given.flatMap((l) => {
+          if (visibleLen(l) <= w) return [l];
+          const plain = stripAnsiEscapes(l);
+          const lead = /^\s*/.exec(plain)[0];
+          // The key hint "  (↑/↓ then Enter · Esc …)" moves to its own line whole, before any word wrap.
+          const at = plain.indexOf("  (", lead.length);
+          const parts = at > 0 ? [plain.slice(lead.length, at), plain.slice(at + 2)] : [plain.slice(lead.length)];
+          return parts.flatMap((p) => wrapIndented(p, { width: w, indent: lead, hang: "" })).map((r) => dim(r));
+        });
+        listHeader = () => wrapped;
+        listHeaderRows = wrapped.length;
+      }
+    }
     if (listHeader && opts.refreshMs > 0) {
       // A live panel (#376): redrawn in place until the picker closes.
       const live = setInterval(() => {
@@ -12382,6 +12426,7 @@ async function localScaffoldState() {
 /** Print the startup scaffold line — deferred while a turn owns the transcript. */
 function announceScaffold() {
   if (!scaffoldNotice || following) return;
+  if (listPickerActive || askWaiting || !inputVisible) return; // as announceCliUpdate (GH #397)
   const { kind, text } = scaffoldNotice;
   scaffoldNotice = null;
   if (kind === "link") {
@@ -14434,7 +14479,11 @@ async function main() {
         await import("./agent-model-label.mjs");
       // Skip the `ps` sweep entirely when settings already name the model — the overwhelmingly
       // common case, and startup is not the place to spend a subprocess proving it.
-      const agentLabel = namesAModel(p.agentModelId)
+      // NO AGENT MODEL SET: the payload's agentModelId is only the account-default coder, which may
+      // not be this folder's pick — naming it here said "kimi" over a folder running qwen (GH #397).
+      const agentLabel = p.agentMissing === true
+        ? { name: "", known: false, reason: "not-set" }
+        : namesAModel(p.agentModelId)
         ? { name: String(p.agentModelId).trim(), known: true, reason: "settings" }
         : agentModelLabel({
             configuredId: p.agentModelId,
@@ -14695,7 +14744,7 @@ async function main() {
               dim("   Skipped — this machine won't SERVE models; the agent still runs here and\n") +
                 dim("  calls your model machine over the network. Point the Agent model URL at\n") +
                 dim("  that machine (not 127.0.0.1) — `gu status` shows what it resolves to.\n") +
-                dim("  `gu doctor` sets models up here · `/host-mode` undoes this.\n")
+                dim("  `gu doctor` sets models up here · `gu clear` starts setup over.\n")
             );
             void st;
           }
@@ -15349,11 +15398,6 @@ async function main() {
       await syncEmbedWarning({ repair: false });
       continue;
     }
-    if (line === "/server") {
-      await chooseServer();
-      await saveSession(cwd, history); // remember the pick for this folder
-      continue;
-    }
     if (line === "/full-log" || line.startsWith("/full-log ")) {
       await runFullLogCommand(line);
       continue;
@@ -15437,18 +15481,6 @@ async function main() {
       );
       continue;
     }
-    if (line === "/host-mode") {
-      const ctl2 = await import("./daemon-control.mjs");
-      await ctl2.setClientMode(false);
-      await saveSessionSkip(cwd, "skipModelSetupPrompt", false);
-      await saveSessionSkip(cwd, "skipDaemonPrompt", false);
-      console.log(
-        accent("host mode") +
-          dim(" — this machine will run turns again. Start the worker with `gu start`, ") +
-          dim("and `gu doctor` to set up models here.\n")
-      );
-      continue;
-    }
     if (line === "/rag" || line === "/rag-cloud" || line === "/rag-local") {
       // ONE QUESTION, THREE ANSWERS (task #180). This was two commands that toggled one flag,
       // so the command you typed did not determine the state you got — and the reply named a

package/mongo-mac.mjs

@@ -0,0 +1,166 @@
+/**
+ * MONGODB ON macOS 13 AND OLDER (GH #403).
+ *
+ * Homebrew's mongodb-community is 9.0, and every MongoDB from 8.0.6 on is built for macOS 14+
+ * (LC_BUILD_VERSION minos 14.0 — checked with otool on the 8.0.6 … 9.0.4 downloads). On macOS 13
+ * it installs fine and then cannot start: "dyld: Symbol not found … built for macOS 14.0".
+ * 8.0.5 is the last release built for older Macs (minos 10.14 on Intel, 11.0 on Apple Silicon).
+ *
+ * So on those Macs gu runs its own mongod 8.0.5, like the Windows one (#210): no Homebrew, no
+ * service, no sudo. Everything lives under ~/.gonext/mongodb and goes away with that folder:
+ *   bin/mongod   data/   mongod.log   launch.log   version.txt
+ *
+ * The .tgz is gzip, so unlike the Windows zip one file cannot be fetched on its own: the whole
+ * archive (~80-90 MB) is downloaded, checked against MongoDB's published SHA-256, and only
+ * bin/mongod is kept.
+ */
+import { createHash } from "node:crypto";
+import { execFile, execFileSync } from "node:child_process";
+import { createWriteStream } from "node:fs";
+import { mkdir, rename, rm, stat, writeFile, mkdtemp, chmod } from "node:fs/promises";
+import { homedir, release } from "node:os";
+import { join } from "node:path";
+
+export const MONGO_MAC_OLD_VERSION = "8.0.5";
+/** Homebrew's MongoDB (and every release after 8.0.5) needs this macOS or newer. */
+export const MONGO_MAC_BREW_MIN_MAJOR = 14;
+
+// From https://downloads.mongodb.org/full.json, and re-checked by downloading both (2026-11-07).
+export const MONGO_MAC_DOWNLOADS = {
+  x64: {
+    url: `https://fastdl.mongodb.org/osx/mongodb-macos-x86_64-${MONGO_MAC_OLD_VERSION}.tgz`,
+    sha256: "eb528846663ef106003b3c491dfe3722f918cb75d056670b23a620b339f7f6ec",
+  },
+  arm64: {
+    url: `https://fastdl.mongodb.org/osx/mongodb-macos-arm64-${MONGO_MAC_OLD_VERSION}.tgz`,
+    sha256: "71e2510f0455ff24e1961aa0507eb0660b300c84f6da9899052be409090fb990",
+  },
+};
+
+/** "13.7.1" → 13. Darwin's kernel number is the fallback (Darwin 20-24 = macOS 11-15, 25 = 26). */
+export function macosMajor({ productVersion = null, darwin = release(), platform = process.platform } = {}) {
+  if (productVersion == null && platform !== "darwin") return 0; // not a Mac: no answer, not a guess
+  let v = productVersion;
+  if (v == null) {
+    try { v = execFileSync("sw_vers", ["-productVersion"], { encoding: "utf8", timeout: 5000 }); } catch { v = ""; }
+  }
+  const m = /^(\d+)/.exec(String(v).trim());
+  if (m) return Number(m[1]);
+  const d = parseInt(String(darwin), 10);
+  if (!Number.isFinite(d)) return 0;
+  return d >= 25 ? d + 1 : d >= 20 ? d - 9 : 10;
+}
+
+/** Does this Mac need gu's own MongoDB? 0 (unknown) keeps Homebrew — the path that worked before. */
+export function macNeedsOwnMongo(major) {
+  return major > 0 && major < MONGO_MAC_BREW_MIN_MAJOR;
+}
+
+/** Where gu keeps its own mongod on a Mac — the same layout as Windows. `home` for tests. */
+export function mongoMacPaths(home = homedir()) {
+  const dir = join(home, ".gonext", "mongodb");
+  return {
+    dir,
+    exe: join(dir, "bin", "mongod"),
+    data: join(dir, "data"),
+    log: join(dir, "mongod.log"),
+    launchLog: join(dir, "launch.log"),
+    version: join(dir, "version.txt"),
+  };
+}
+
+/** Is gu's own mongod there? */
+export async function macMongoInstalled(paths = mongoMacPaths()) {
+  try { return (await stat(paths.exe)).isFile(); } catch { return false; }
+}
+
+/** The download for this CPU, or null for one MongoDB does not build. */
+export function macMongoDownload(arch = process.arch) {
+  return MONGO_MAC_DOWNLOADS[arch] ?? null;
+}
+
+/**
+ * Download the archive, check its SHA-256, keep only bin/mongod. → { bytes }.
+ * Throws a plain reason; nothing half-written is left at paths.exe.
+ * `fetchFn` and `extract` are injectable so tests never touch the network or tar.
+ */
+export async function downloadMongodMac({
+  paths = mongoMacPaths(),
+  arch = process.arch,
+  fetchFn = fetch,
+  extract = extractMongod,
+  log = () => {},
+  version = MONGO_MAC_OLD_VERSION,
+  dl = macMongoDownload(arch),
+} = {}) {
+  if (!dl) throw new Error(`MongoDB has no macOS build for ${arch}`);
+  await mkdir(paths.dir, { recursive: true });
+  const tgz = join(paths.dir, "mongodb.tgz.part");
+  const res = await fetchFn(dl.url);
+  if (!res.ok || !res.body) throw new Error(`download failed (HTTP ${res.status})`);
+  const total = Number(res.headers?.get?.("content-length")) || 0;
+  const mb = (n) => (n / 1048576).toFixed(0);
+  const hash = createHash("sha256");
+  const out = createWriteStream(tgz);
+  let got = 0;
+  let shown = -1;
+  try {
+    const reader = res.body.getReader();
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      hash.update(value);
+      got += value.length;
+      if (!out.write(value)) await new Promise((r) => out.once("drain", r));
+      if (total) {
+        const pct = Math.floor((got / total) * 10) * 10;
+        if (pct !== shown) { shown = pct; log(`  … ${pct}%  (${mb(got)} of ${mb(total)} MB)`); }
+      }
+    }
+  } finally {
+    await new Promise((r) => out.end(r));
+  }
+  try {
+    if (hash.digest("hex") !== dl.sha256) throw new Error("the download is damaged (SHA-256 does not match) — run gu again");
+    const tmp = await mkdtemp(join(paths.dir, "unpack-"));
+    try {
+      const mongod = await extract(tgz, tmp);
+      await mkdir(join(paths.dir, "bin"), { recursive: true });
+      await rm(paths.exe, { force: true });
+      await rename(mongod, paths.exe);
+      await chmod(paths.exe, 0o755);
+    } finally {
+      await rm(tmp, { recursive: true, force: true });
+    }
+  } finally {
+    await rm(tgz, { force: true });
+  }
+  await writeFile(paths.version, `${version}\n`);
+  return { bytes: got };
+}
+
+/** tar -x of only the archive's bin/mongod into `dir` → the extracted file's path. */
+export function extractMongod(tgz, dir) {
+  return new Promise((resolve, reject) => {
+    execFile("tar", ["-xzf", tgz, "-C", dir, "--strip-components", "2", "*/bin/mongod"], { timeout: 300000 }, (err, _o, stderr) => {
+      if (err) reject(new Error(`could not unpack the archive: ${String(stderr || err.message).trim().split("\n").pop()}`));
+      else resolve(join(dir, "mongod"));
+    });
+  });
+}
+
+/**
+ * Can this mongod run here at all? `mongod --version` stops at once with a dyld error when the
+ * build is for a newer macOS — the failure this module exists for — so ask it before starting it
+ * detached, where that would only show up as "not answering". → { ok, why }.
+ */
+export function mongodRunsMac(exe, { execFn = execFile, timeoutMs = 20000 } = {}) {
+  return new Promise((resolve) => {
+    execFn(exe, ["--version"], { timeout: timeoutMs }, (err, stdout, stderr) => {
+      if (!err) return resolve({ ok: true, why: "" });
+      const text = `${stderr || ""}\n${stdout || ""}`;
+      const newer = /built for macOS ([\d.]+) which is newer/.exec(text);
+      resolve({ ok: false, why: newer ? `it is built for macOS ${newer[1]} or newer` : (text.trim().split("\n")[0] || String(err.message)) });
+    });
+  });
+}

package/node-version.mjs

@@ -12,6 +12,9 @@
  *
  * Checked at the TOP of both entry points, before any import that might itself fail.
  */
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+
 export const MIN_NODE_MAJOR = 18;
 
 /** The message for a too-old runtime, or "" when this one is fine. Pure, so it is testable. */
@@ -52,11 +55,30 @@ export function nodeAtLeast(version, min) {
   return true;
 }
 
+/**
+ * The Node versions nvm has installed when THIS node is one of nvm's, else []. Found on the 2017
+ * MacBook Pro (GH #406): nvm's default was 18 while 22 was already installed, and "install a new
+ * Node" was the wrong advice — one `nvm alias default` was the whole fix.
+ */
+export function nvmNodeVersions({ env = process.env, execPath = process.execPath, list = null } = {}) {
+  const dir = env.NVM_DIR;
+  if (!dir || !String(execPath).startsWith(dir)) {return [];}
+  let names = list;
+  if (!names) {
+    try { names = readdirSync(join(dir, "versions", "node")); } catch { return []; }
+  }
+  return names.filter((n) => /^v\d+\.\d+\.\d+$/.test(n));
+}
+
 /** Why Local mode cannot run on this node, with what to do — or "" when it can. Pure. */
-export function localModeNodeProblem(version = process.version, platform = process.platform) {
+export function localModeNodeProblem(version = process.version, platform = process.platform, { nvmVersions = [] } = {}) {
   if (nodeAtLeast(version, LOCAL_API_MIN_NODE)) {return "";}
-  const how =
-    platform === "win32"
+  // nvm already has a new enough Node: switch to it, nothing to install.
+  const ready = nvmVersions.filter((v) => nodeAtLeast(v, LOCAL_API_MIN_NODE))
+    .sort((a, b) => (nodeAtLeast(a, b) ? -1 : 1))[0];
+  const how = ready
+    ? [`  nvm already has ${ready}. Make it the default, then open a new terminal:`, `    nvm alias default ${ready.replace(/^v/, "")}`]
+    : platform === "win32"
       ? ["  winget install OpenJS.NodeJS.LTS      (or: nvm install lts with nvm-windows)"]
       : platform === "darwin"
         ? ["  brew install node                     (or: nvm install --lts)"]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.897",
-  "description": "gu: the coding agent in your terminal. It reads your repo, makes the change and runs the tests, with your own models (Ollama or any OpenAI-compatible provider). Free installs run entirely on your machine. macOS, Linux and Windows.",
+  "version": "1.0.899",
+  "description": "gu: the coding agent in your terminal. It reads your repo, makes the change and runs the tests, with your own models (Ollama or any OpenAI-compatible provider). Free installs keep the agent, its API and its database on your machine. macOS, Linux and Windows.",
   "keywords": [
     "ai",
     "coding-agent",
@@ -74,6 +74,7 @@
     "turn-stop.mjs",
     "workspace-revert.mjs",
     "mongo-native.mjs",
+    "mongo-mac.mjs",
     "mongo-windows.mjs",
     "python-windows.mjs",
     "terminal-hover.mjs",

package/server-keys.mjs

@@ -49,7 +49,6 @@ export function keyTags(k, { folderKeyId = "", inUseId = "" } = {}) {
   if (k.id === folderKeyId) tags.push("this folder");
   else if (k.id === inUseId) tags.push("in use");
   if (k.default) tags.push("default");
-  if (k.first) tags.push("first key");
   if (!k.backendId) tags.push("not tied to a server yet");
   return tags;
 }

package/terminal-layout.mjs

@@ -2790,29 +2790,6 @@ export function resizeRepaintTarget({ barPinned, modal, busy, scrolledBack }) {
   return scrolledBack ? "scrollback" : "live";
 }
 
-/**
- * Should the workspace "sync chat history to the cloud?" question be ASKED? (task #154)
- *
- * Not on a Client Expert machine. There is no cloud there: the API and the database are on
- * this box, "your account" is a local row, and there is no web app to see it on — so every
- * clause of the question is false. Asking a question whose premise is wrong is worse than not
- * asking, because the answer cannot mean what the reader thinks it means.
- *
- * The sync itself still happens — it writes to the local database, which is where that
- * machine's conversations already live — so the value is true and it is stated rather than
- * asked. Reported live: a Client Expert machine on Windows offering to send chat to a cloud
- * it does not have.
- */
-export function workspaceSyncQuestion({ clientExpert }) {
-  return clientExpert
-    ? {
-        ask: false,
-        value: true,
-        note: "chat history is kept in the local database on this machine (Local mode)",
-      }
-    : { ask: true, value: null, note: "" };
-}
-
 /**
  * The ONE first-run question for a new folder (GitHub #192). It used to be two or three separate
  * Y/n prompts (register, trust to run commands, then the browser on first use). They are one
@@ -2928,8 +2905,9 @@ export function identityRow(
   // The mark only means anything beside a named coder: with none shown there is nothing for it
   // to be about, and it would read as a fault in the folder.
   const mark = name && keyUnchosen ? red(" key not chosen") : "";
-  // API key tail: show the last 4 characters of the API key when available (e.g., "| abcd")
-  const keyIndicator = apiKeyTail ? dim(" | ") + dim(apiKeyTail) : "";
+  // API key tail, LABELLED (GH #397): a bare "| VW3Y" between the model and the folder read as a
+  // stray code. Same "····" form every key line in gu uses.
+  const keyIndicator = apiKeyTail ? dim(" | ") + dim(`key ····${apiKeyTail}`) : "";
   return (name ? orange(name) + mark + keyIndicator + dim(" | ") : "") + cyan(where);
 }
 
@@ -2938,7 +2916,7 @@ export function identityRow(
  *
  * ON CLIENT EXPERT, NOTHING. That mode's whole promise is that the machine keeps everything —
  * API, database, models — and shares none of it, so "cloud sync on" is not merely noise, it
- * contradicts the mode the user chose (reported 2026-09-04). workspaceSyncQuestion already
+ * contradicts the mode the user chose (reported 2026-09-04). The workspace record already
  * knows this and stores `true` meaning "persist it", but the LABEL read that value as "to the
  * cloud", which is the one place it does not go.
  *