@tiens.nguyen/gu-cli 1.0.896 → 1.0.898

package/gu-repl.mjs

@@ -126,7 +126,6 @@ import {
   nothingToAnswerWith,
   NO_MODEL_LINES,
   resizeRepaintTarget,
-  workspaceSyncQuestion,
   workspaceAccessQuestion,
   workspaceSyncLabel,
   activeCoderName,
@@ -1052,7 +1051,7 @@ 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)" },
@@ -1436,7 +1435,7 @@ rl._ttyWrite = (str, key) => {
     }
     if (verdict.action === "consume") {
       mouseClearTimer();
-      applyMouseReport(verdict.report);
+      if (verdict.report) applyMouseReport(verdict.report); // null: focus in/out, a win32 record
       return;
     }
     if (verdict.action === "replay") {
@@ -2720,6 +2719,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 +5248,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 +5259,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 +5271,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 +5287,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 +5354,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 +5391,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),
@@ -6196,7 +6201,11 @@ async function runModelDoctor() {
     return;
   }
   console.log(dim("   Asking each model to answer — the real request, not just a ping."));
-  const roles = dc.rolesFromSettings(settings);
+  // The SAME models, URLs and keys a turn gets (GH #397): this folder's /model pick included.
+  const turnPayload = await fetchAgentPayload([{ role: "user", content: "ping" }], sessionCodingModel).catch(() => null);
+  const p = turnPayload?.payload ?? null;
+  const codingKey = p?.codingBackendId ? (await fetchKeyForBackend(p.codingBackendId))?.apiKey ?? "" : "";
+  const roles = dc.rolesFromPayload(p, settings, codingKey) ?? dc.rolesFromSettings(settings);
   const results = [];
   for (const r of roles) {
     // One at a time, and SAID one at a time: these share a GPU, so a check can take a while and
@@ -6213,13 +6222,8 @@ async function runModelDoctor() {
       console.log(GUTTER + (res.status === "ok" ? dim(l) : res.status === "unset" ? dim(l) : yellow(l)));
     }
   }
-  const bad = results.filter((r) => r.status !== "ok" && r.status !== "unset");
-  console.log(
-    "\n" + GUTTER +
-      (bad.length === 0
-        ? accent("✓ every configured model answered.")
-        : red(`✗ ${bad.length} of ${results.length} did not answer.`))
-  );
+  const verdict0 = dc.doctorSummary(results);
+  console.log("\n" + GUTTER + (verdict0.tone === "ok" ? accent : verdict0.tone === "bad" ? red : yellow)(verdict0.text));
   // THE GU SERVICE TOO (#413): every model can answer and a coding turn still fail, because its
   // instructions come from the gu service — reported on a Windows VM where only "hi" worked.
   const sc = await import("./service-check.mjs");
@@ -6292,10 +6296,18 @@ async function doctorFetch(url, init) {
  * Returns [] when there is nothing to offer, or null when the user cancelled — which the caller
  * must treat as "abandon", not as "offer none", or Escape would silently save something.
  */
-async function pickExtraModels(rest, preChecked = []) {
-  if (rest.length === 0) return [];
-  console.log(dim(`   Also offer these in /model?  (up to ${MAX_ALT_CODERS} · ${PICK_MANY_HINT}):`));
+async function pickExtraModels(rest0, preChecked = []) {
+  // The SAME non-coding filter as the main pick (GH #397): the extras are coders too, and this
+  // list offered image, audio and video models the picker just above had hidden.
   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))
+    .sort((a, b) => a.localeCompare(b, "en", { numeric: true })); // as the pick above (GH #397)
+  if (rest.length === 0) return [];
+  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),
@@ -6323,7 +6335,12 @@ async function pickExtraModels(rest, 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 (;;) {
@@ -6333,11 +6350,11 @@ async function chooseCodingModelFrom(ps, all, question, current, { back = false
     // Opens on the CURRENT model where there is one — a long list that opens at the top tells the
     // reader nothing about which one they are already using.
     const at = typeof current === "string" ? list.indexOf(current) : Number(current) || 0;
-    console.log(
-      dim(`  ${question}  (${PICK_HINT})`) +
-        (showingAll || !filtered ? "" : dim(`  ·  ${filtered} non-coding models hidden`))
-    );
-    const idx = await pickFromList(rows, at >= 0 ? at : 0, { back });
+    // A HEADER, not a printed line (GH #397): erased with the list, so a finished pick leaves
+    // "→ model" behind instead of a question nobody is being asked any more.
+    const head = [dim(`   ${question}  (${PICK_HINT})`)];
+    if (!showingAll && filtered) head.push(dim(`   ${filtered} non-coding models hidden — "show all" is the last row`));
+    const idx = await pickFromList(rows, at >= 0 ? at : 0, { back, header: () => head, headerRows: head.length });
     if (idx === PICK_BACK) return BACK;
     if (idx < 0) return null;
     if (idx === list.length) {
@@ -6349,6 +6366,7 @@ async function chooseCodingModelFrom(ps, all, question, current, { back = false
       showingAll = true;
       continue;
     }
+    console.log(dim(`   → ${list[idx]}`));
     return list[idx];
   }
 }
@@ -6366,20 +6384,40 @@ 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;
-  console.log(dim(`   ${question}  (${PICK_HINT})`));
-  const idx = await pickFromList(rows, at >= 0 ? at : 0, { back });
+  const idx = await pickFromList(rows, at >= 0 ? at : 0, {
+    back,
+    header: () => [dim(`   ${question}  (${PICK_HINT})`)],
+    headerRows: 1,
+  });
   if (idx === PICK_BACK) return BACK;
   if (idx < 0) return null;
   if (idx === all.length) {
     const typed = (await ask("   model name: ")).trim();
     return typed || null;
   }
+  console.log(dim(`   → ${all[idx]}`));
   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
@@ -6405,8 +6443,13 @@ async function manageCodingProviders({ back = false } = {}) {
     );
     const ADD = labels.length;
     labels.push(actionRow("add another provider — Claude API, OpenAI, Kimi…"));
-    console.log(dim(`   Providers — pick one to change it, or add another  (${PICK_HINT}):`));
-    const idx = await pickFromList(labels, selAt, { back });
+    // Headers, not printed lines (GH #397): going one level deeper must not leave the level above
+    // stacked on screen.
+    const idx = await pickFromList(labels, selAt, {
+      back,
+      header: () => [dim(`   Providers — pick one to change it, or add another  (${PICK_HINT}):`)],
+      headerRows: 1,
+    });
     if (idx === PICK_BACK) return BACK;
     if (idx < 0) {
       console.log(dim("   (cancelled)\n"));
@@ -6420,11 +6463,10 @@ async function manageCodingProviders({ back = false } = {}) {
 
     const p = providers[idx];
     for (;;) {
-      console.log("\n" + GUTTER + dim(`${p.host}  ·  ${p.model || "no model set"}`));
       const action = await pickFromList(
         [dim("keep it"), "change the model…", "change the URL…", "remove this provider…"],
         1,
-        { back: true }
+        { back: true, header: () => [GUTTER + dim(`${p.host}  ·  ${p.model || "no model set"}`)], headerRows: 1 }
       );
       if (action === PICK_BACK) break; // → the provider list
       if (action <= 0) {
@@ -6548,7 +6590,7 @@ async function changeProviderModel(ps, rows, p) {
     await syncActiveCoderWhere();
     console.log(GUTTER + dim("this folder's pick named the old model — cleared it."));
   }
-  console.log(accent(` ✓ ${p.host} → ${model}`) + dim("  ·  pick it in /model\n"));
+  console.log(accent(`   ✓ ${p.host} now uses ${model}`) + dim("  ·  /model switches between its models\n"));
 }
 
 /** Point a provider at a different URL, keeping its id so saved picks still resolve. */
@@ -6639,6 +6681,18 @@ async function removeCodingProvider(ps, rows, p) {
     );
     console.log(GUTTER + dim("  they will be deleted too; a key with no provider can never be used again.\n"));
   }
+  // THE AGENT MAY TALK THROUGH THIS PROVIDER TOO (GH #397). Removing the row and its key left
+  // agentModelUrl pointing at it: the banner still named the model, every question failed on a
+  // missing key, and /agent-model probed the URL as an Ollama (…/api/tags → 404). So the agent
+  // model goes with it — said before the question, like the keys.
+  const settings = await fetchWorkerSettings().catch(() => null);
+  const sameUrl = (u) => u && ps.ensureV1Root(String(u)).toLowerCase() === ps.ensureV1Root(String(p.url ?? "")).toLowerCase();
+  const agentUses = sameUrl(settings?.agentModelUrl);
+  if (agentUses) {
+    const name = String(settings.agentModelName || settings.agentModel || "").trim();
+    console.log(GUTTER + orange(`  the agent model uses it too${name ? ` — ${name}` : ""}`));
+    console.log(GUTTER + dim("  it will be unset; pick another with /agent-model.\n"));
+  }
   const yes = await askYesNo(
     `Remove ${p.host} (${p.model || "no model set"})? This cannot be undone.`,
     false
@@ -6650,6 +6704,7 @@ async function removeCodingProvider(ps, rows, p) {
   const saved = await withPendingStatus("removing", () =>
     md.saveWorkerSettings(apiBase, workerKey, {
       agentCodingBackends: ps.removeProvider(rows, p.id),
+      ...(agentUses ? { agentModelUrl: "", agentModelName: "", agentModel: "" } : {}),
     })
   );
   if (!saved) {
@@ -6666,6 +6721,7 @@ async function removeCodingProvider(ps, rows, p) {
       sessionCodingKeyId = "";
       await saveSessionCodingKeyId(resolve(process.cwd()));
     }
+    if (k.id === sessionAgentKeyId) await saveFolderKeyPick("agent", "");
   }
   // This folder may have been pointed at the removed provider.
   if (sessionCodingUrl === p.url || sessionCodingModel.startsWith(`${p.id}::`)) {
@@ -6679,8 +6735,21 @@ async function removeCodingProvider(ps, rows, p) {
   console.log(
     accent(` ✓ removed ${p.host}`) +
       (stranded.length ? dim(`  ·  ${deleted} key${deleted === 1 ? "" : "s"} deleted`) : "") +
+      (agentUses ? dim("  ·  agent model unset") : "") +
       "\n"
   );
+  // The bar named the removed coder (the account default is held in memory): read it back.
+  if (sameUrl(defaultCodingUrl)) {
+    defaultCodingModel = "";
+    defaultCodingUrl = "";
+  }
+  const after = (await fetchAgentPayload([{ role: "user", content: "." }]).catch(() => null))?.payload;
+  if (after) {
+    seedDefaultCoder(after);
+    agentMissing = after.agentMissing === true;
+    noModelAtAll = nothingToAnswerWith(after);
+  }
+  if (barPinned()) paintBar();
 }
 
 /**
@@ -6709,6 +6778,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");
@@ -6736,7 +6806,8 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
   const providerPicker = !presetUrl && dialect === "openai";
   const ec = role === "embed" ? await import("./embed-model-command.mjs") : null;
   let target, host, found, need, key, keyName, typedKey, models, model;
-  for (;;) {
+  let lastPick = 0; // GH #397: back from the key re-opens the list ON the provider just chosen
+  providerLoop: for (;;) {
     // --- 1. the server --------------------------------------------------------------------
     target = null;
     // The dialect the URL prompt reads the address in: the caller's, or Ollama's when that row was picked.
@@ -6754,22 +6825,33 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
       const presets = ps.providerPresets(role);
       // #244: an Ollama on this machine or the network is a row here, like the hosted ones — the
       // menus no longer have a separate "use an Ollama server…" entrance. It asks for the address.
-      const OLLAMA_HERE = presets.length;
+      // OLLAMA FIRST (GH #397): first-run setup lists "Ollama server — this machine or your own"
+      // first and these pickers listed it seventh, so the same choice moved between two screens.
+      // gu is local-first; the hosted providers follow in their usual order.
+      const OLLAMA_HERE = 0;
       const rowsShown = [
-        ...presets.map((p) => `${p.name}${dim(`  · ${p.url}`)}`),
         `Ollama — this machine or your network…${dim("  · e.g. 127.0.0.1:11434")}`,
+        // 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.
-      console.log(dim(`   Which provider?  (${PICK_HINT})`));
-      const pi = await pickFromList(rowsShown, 0, { back });
+      // The question is the picker's HEADER, erased with it (GH #397): printed above, it stayed in
+      // the history every time "← back" re-opened this list — "Which provider?" stacked up.
+      const pi = await pickFromList(rowsShown, lastPick, { back, header: () => [dim(`   Which provider?  (${PICK_HINT})`)], headerRows: 1 });
       if (pi === PICK_BACK) return BACK;
       if (pi < 0) {
         console.log(dim("   (nothing saved)\n"));
         return;
       }
-      if (pi < presets.length) target = as.serverTarget(presets[pi].dialect ?? "openai", presets[pi].url);
+      lastPick = pi;
+      const preset = pi > OLLAMA_HERE && pi <= presets.length ? presets[pi - 1] : null;
+      if (preset) target = as.serverTarget(preset.dialect ?? "openai", preset.url);
       else if (pi === OLLAMA_HERE) askDialect = "ollama";
+      // SAY WHAT WAS PICKED (GH #397): the list is erased on Enter, and what followed ("… needs an
+      // API key", "key name:") never named the provider — the choice was nowhere on screen.
+      console.log(GUTTER + dim(`→ ${preset ? preset.name : pi === OLLAMA_HERE ? "Ollama" : "another URL"}`));
     }
     if (!target && !presetUrl) {
       const dflt = as.defaultServerUrl(role, askDialect, settings, existing);
@@ -6806,10 +6888,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
@@ -6835,8 +6917,19 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
         if (key) console.log(GUTTER + dim(`using the key "${inUse.name}" already saved for ${host}.`));
       }
     }
-    const askKey = async () => {
-      const t = await askServerKey({ host, optional: need === "optional" });
+    // ESC AT THE KEY GOES BACK ONE STEP (GH #397): with a provider picker behind it, Esc at
+    // "key name:" / "API key:" returns to "Which provider?" — it used to unwind the whole command,
+    // so choosing the wrong provider meant starting /agent-model or /model again. Nothing is saved
+    // before step 5, so going back leaves nothing behind. Without a picker it still cancels.
+    const BACK_TO_PROVIDERS = Symbol("back");
+    const askKey = async ({ again = false } = {}) => {
+      let t;
+      try {
+        t = await askServerKey({ host, optional: need === "optional", escBack: providerPicker, ...(again && typedKey ? { name: keyName } : {}) });
+      } catch (e) {
+        if (wasPromptCancelled(e) && providerPicker) return BACK_TO_PROVIDERS;
+        throw e;
+      }
       key = t.secret;
       keyName = t.name;
       typedKey = Boolean(t.secret);
@@ -6844,7 +6937,9 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
     };
     if (!key && (need !== "none" || newKey)) {
       if (need === "required") console.log(GUTTER + dim(`${host} needs an API key.`));
-      if (!(await askKey())) return;
+      const got = await askKey();
+      if (got === BACK_TO_PROVIDERS) continue providerLoop;
+      if (!got) return;
     }
 
     // --- 3. its models, listed with that key ----------------------------------------------
@@ -6861,10 +6956,18 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
           }
         });
       let probe = await list();
-      // THE STORED KEY WAS REFUSED — ask for the right one once, rather than saving nothing.
-      if ((probe.status === 401 || probe.status === 403) && !typedKey && key) {
-        console.log(yellow(`   ${host} refused the stored key (HTTP ${probe.status}) — enter the right one.`));
-        if (!(await askKey()) || !key) return;
+      // A REFUSED KEY IS ASKED FOR AGAIN, HERE (GH #397). The stored one always was; a TYPED one
+      // ended the command with "check the key and try again" — which meant /model, the provider and
+      // the key name all over again for one mistyped character. Two more tries, then stop.
+      for (let retry = 0; retry < 2 && (probe.status === 401 || probe.status === 403) && key; retry++) {
+        // Two short lines, not one long one: at 80 columns the single sentence wrapped mid-word.
+        console.log(yellow(typedKey
+          ? `   ${host} rejected that key (HTTP ${probe.status}).`
+          : `   ${host} refused the stored key (HTTP ${probe.status}).`));
+        console.log(GUTTER + dim(providerPicker ? "paste the right one — Esc goes back to the providers." : "paste the right one — Esc cancels."));
+        const got = await askKey({ again: true });
+        if (got === BACK_TO_PROVIDERS) continue providerLoop;
+        if (!got || !key) return;
         probe = await list();
       }
       if (probe.status || probe.err) {
@@ -6896,7 +6999,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;
@@ -6941,6 +7046,7 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
   }
 
   // --- 5. save: the server, its key, then the role --------------------------------------
+  let alsoInModel = false;
   let rowId = found?.id ?? "";
   let rows = existing;
   // A NEW ROW ONLY WHEN SOMETHING NEEDS ONE: the coder is picked through its row, and a key is
@@ -6967,7 +7073,8 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
       console.log(GUTTER + dim("if this machine's local API is old, restart it with `gu api restart`.\n"));
       return;
     }
-    if (!found && role !== "coding" && as.serverRole(role).rowModel) console.log(GUTTER + dim(`${host} is also offered in /model now.`));
+    // Said AFTER the ✓ (GH #397) — printed here it came before the result it is a footnote to.
+    if (!found && role !== "coding" && as.serverRole(role).rowModel) alsoInModel = true;
   }
   if (typedKey) {
     const id = await withPendingStatus("saving the key", () => addCodingKey(keyName, key, rowId));
@@ -6980,14 +7087,15 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
     // the stored one was refused: it is the server's key from now on, for every role and folder.
     if (found) await setServerDefaultKey(rowId, id);
   }
-  const keyLine = key ? dim(`    API key ${keyName || "saved"} ····${key.slice(-4)}  ·  ${host}'s key`) : "";
+  const keyLine = key ? dim(`   API key ${keyName || "saved"} ····${key.slice(-4)}`) : "";
 
   if (role === "agent") {
     // A MACHINE SETTING, not a folder pick: the agent is what gu talks to in every folder. Saved
     // as URL + NAME, the pair app.ts matches back to the server row to find the key.
-    if (await saveAgentModel(target.roleUrl("agent"), model, host)) {
-      if (keyLine) console.log(keyLine + "\n");
-      console.log(GUTTER + dim("the banner shows the new model next time gu starts.\n"));
+    // ONE BLOCK under the ✓ (GH #397): the key, then the footnotes — not three loose paragraphs.
+    const extra = [keyLine, alsoInModel ? dim(`   ${host} is also offered as a coding model in /model.`) : ""];
+    if (await saveAgentModel(target.roleUrl("agent"), model, host, extra.filter(Boolean))) {
+      /* said */
     } else if (rows !== existing || typedKey) {
       // The SERVER landed — say so, or the user re-enters a key that is already stored.
       console.log(yellow(`   ${host} was saved, but the agent model was not pointed at it.`));
@@ -7008,7 +7116,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("");
+  }
 }
 
 /**
@@ -7021,7 +7138,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)
@@ -7070,15 +7187,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();
 }
 
 
@@ -7181,11 +7306,13 @@ async function chooseModel() {
     // choices while still occupying its URL, so sending this branch straight to the ADD flow
     // would meet "already configured here" and dead-end. The manager fixes such a row, and falls
     // through to add when there is genuinely nothing there.
-    console.log(dim("   No coding model configured."));
+    // 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…"],
-      1
+      [dim("leave it"), "add a provider — Claude API, OpenAI, Kimi, Ollama…"],
+      1,
+      { header: () => [dim("   No coding model configured.")], headerRows: 1 }
     );
+    if (go !== 1) console.log(dim("   No coding model configured."));
     if (go === 1 && (await manageCodingProviders({ back: true })) === BACK) return chooseModel();
     if (go !== 1) console.log("");
     return;
@@ -7194,16 +7321,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).
@@ -7212,6 +7333,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)];
@@ -7239,8 +7363,11 @@ async function chooseModel() {
   // enough in name to have already been mixed up. The fix is to say which one THIS is — not to
   // print the other two here: the agent model and the embedder are independent settings with
   // their own commands, and listing them together implies a relationship that does not exist.
-  console.log(dim(`   Choose the CODING model — the one that writes code  (${PICK_ARROWS}):`));
-  const idx = await pickFromList(labels, activeIdx >= 0 ? activeIdx : 0, { footer: ESC_FOOTER });
+  const idx = await pickFromList(labels, activeIdx >= 0 ? activeIdx : 0, {
+    footer: ESC_FOOTER,
+    header: () => [dim(`   Choose the CODING model — the one that writes code  (${PICK_ARROWS}):`)],
+    headerRows: 1,
+  });
   if (idx < 0) {
     console.log(dim("   (cancelled)\n"));
     return;
@@ -9164,7 +9291,14 @@ async function chooseEmbedModel() {
   if (keyRequired) labels.push(actionRow(`API keys for ${host || currentUrl} — switch, add or remove…`));
   const ADD = labels.length;
   labels.push(actionRow("add a provider — OpenAI, Ollama…"));
-  const head = `   Embedding model (now ${current} on ${host || currentUrl})`;
+  // NOTHING SET IS SAID AS NOTHING SET (GH #397). "now nomic-embed-text:latest on 127.0.0.1:11434"
+  // was the DEFAULT, printed as if it were in use — on a Mac with no Ollama, where /doctor said
+  // "embedder (no model) — no server configured" a moment later. The default still drives the
+  // cursor and the "pick another model on …" row; the header only claims what is set.
+  const embedConfigured = isSet || Boolean(String(settings.ragEmbedUrl ?? "").trim());
+  const head = embedConfigured
+    ? `   Embedding model (now ${current} on ${host || currentUrl})`
+    : "   Embedding model — none set up yet, so RAG is off. Pick one";
   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}`));
@@ -9218,7 +9352,7 @@ async function chooseEmbedModel() {
 }
 
 /** Save the agent model on this machine: the URL the API sends turns to, and the model name. */
-async function saveAgentModel(agentUrl, model, host) {
+async function saveAgentModel(agentUrl, model, host, extra = []) {
   const md = await import("./model-doctor.mjs");
   const ok = await withPendingStatus("pointing the agent model at it", () =>
     md.saveWorkerSettings(apiBase, workerKey, { agentModelUrl: agentUrl, agentModelName: model, agentModel: model })
@@ -9229,6 +9363,7 @@ async function saveAgentModel(agentUrl, model, host) {
     return false;
   }
   console.log(accent(` ✓ agent model → ${model}`) + dim(`  · ${host}`));
+  for (const l of extra) console.log(l);
   console.log(dim("   takes effect on your next question.\n"));
   return true;
 }
@@ -9237,7 +9372,9 @@ async function saveAgentModel(agentUrl, model, host) {
  * Ask for a key's NAME — and refuse the key itself as a name: names are printed wherever keys are
  * listed, so a pasted secret there is a secret on screen (reported: "API key sk-E8Iv…  ····3E66").
  */
-async function askKeyName(prompt = "  key name: ") {
+// "(optional)" because nothing said so (GH #397): a bare "key name:" with no default reads as a
+// required field, while Enter has always meant "no name".
+async function askKeyName(prompt = "  key name (optional): ") {
   const am = await import("./agent-model-command.mjs");
   for (let attempt = 0; attempt < 2; attempt++) {
     const name = (await ask(prompt)).trim();
@@ -9258,15 +9395,18 @@ async function askKeyName(prompt = "  key name: ") {
  * "no key" (a local vLLM answers anonymously). `host` names the server in the prompt and decides
  * the shape check's locality: a local server accepts any string, so "abc" is not questioned there.
  */
-async function askServerKey({ host = "", optional = false } = {}) {
+async function askServerKey({ host = "", optional = false, escBack = false, name: knownName = null } = {}) {
   const ps = await import("./coding-provider-setup.mjs");
   // Esc is said here (#249): the prompt that follows is bare text, with nothing on it saying a
   // way out exists — Esc cancels the whole add, nothing saved. (The line explaining what a key
   // name is for was removed on request.)
-  console.log("\n" + GUTTER + dim("Esc to cancel."));
-  const name = (await askKeyName()).trim();
-  console.log(GUTTER + dim(SECRET_KEY_HINT));
-  const secret = (await askSecret(`   API key${host ? ` for ${host}` : ""}${name ? ` (${name})` : ""}: `)).trim();
+  // GH #397: where a provider list is behind this prompt, Esc returns to it — and says so.
+  // 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);
+  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: "" };
@@ -9354,19 +9494,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;
@@ -9376,6 +9535,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);
@@ -9386,7 +9550,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;
   }
 }
@@ -9396,6 +9565,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`));
@@ -9499,7 +9693,7 @@ async function agentModelOnServer({ back = false, start = "menu" } = {}) {
     const options = am.agentRecoveryOptions({ keyProblem, host: listHost });
     const go = await pickFromList(
       options.map((o, i) => (i === 0 ? dim(o.label) : o.label)),
-      keyProblem ? 1 : 0,
+      am.agentRecoveryDefault(options, { keyProblem, configured: Boolean(url || current) }),
       { back }
     );
     if (go === PICK_BACK) return BACK;
@@ -10829,8 +11023,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();
@@ -10884,7 +11077,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;
@@ -11812,6 +12007,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(() => {
@@ -12290,6 +12507,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") {
@@ -14201,7 +14419,12 @@ async function main() {
       // local mongodb is unreachable. Cloud mode failing to reach the hosted API means the
       // computer has lost its internet connection. Two different messages, one per mode.
       dbUnreachable = true;
-      if (isLocalApiBase(apiBase)) {
+      if (isLocalApiBase(apiBase) && (isNetworkError(err) || isTimeout(err))) {
+        // THE API ITSELF IS NOT ANSWERING (GH #397) — MongoDB was not even asked. Blaming the
+        // database here sent the reader to check mongod while it was fine; the message right after
+        // this one names the API and starts it.
+        console.error(dim("(the local API isn't answering — your saved model/key choice is unavailable)"));
+      } else if (isLocalApiBase(apiBase)) {
         console.error(dim("(cannot access local mongodb — your saved model/key choice is unavailable)"));
       } else {
         console.error(dim("(your computer has lost its internet connection — your saved model/key choice is unavailable)"));
@@ -14337,7 +14560,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,
@@ -14598,7 +14825,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;
           }
@@ -14772,6 +14999,19 @@ async function main() {
         );
       } else {
         const started = await tryStartLocalApi();
+        // CARRY ON INSTEAD OF "run gu again" (GH #397). tryStartLocalApi waited for the API to
+        // answer, so the only thing left is the startup this process already abandoned — and the
+        // simplest correct way to redo it is to BE a fresh gu: execve keeps the pid, the terminal
+        // and the arguments. Where execve is missing (Node < 22.15, Windows) the old sentence stays.
+        // ONCE: an API that answers the health check and then dies would otherwise loop forever.
+        if (started && !process.env.GU_API_REOPENED && typeof process.execve === "function" && process.platform !== "win32" && process.stdin.isTTY) {
+          console.error(dim("   Started it — opening gu…\n"));
+          try {
+            process.execve(process.execPath, [process.execPath, ...process.execArgv, ...process.argv.slice(1)], { ...process.env, GU_API_REOPENED: "1" });
+          } catch {
+            /* not allowed here — fall through to the sentence below */
+          }
+        }
         console.error(
           started
             ? dim("   Started it — run `gu` again.\n")
@@ -14794,6 +15034,7 @@ async function main() {
     }
     process.exit(1);
   }
+  delete process.env.GU_API_REOPENED; // GH #397: started — the next start may re-open again
   console.log(wrapGutter("Ask about this repo. Type / to see commands (Tab completes). Ctrl-C aborts a running turn.", dim) + "\n");
   // #221: gu runs, but its own npm folder is not on PATH (npm skipped the postinstall that adds it).
   try {
@@ -15326,18 +15567,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