@tiens.nguyen/gu-cli 1.0.869 → 1.0.871

package/gu-repl.mjs

@@ -157,6 +157,8 @@ import { globalPrefixOf } from "./install-path.mjs";
 import { indentBlock, commandBlockRows } from "./terminal-layout.mjs"; // every line of an Allow-prompt detail indented (#189); wrapped + collapsible command (#204)
 import { firstGuOnPath, pathGuMismatch, guOnPathIsCurrent, updateAttemptRecord, repeatUpdateNotice } from "./update-verify.mjs";
 import { embedNotice, embedState, setupNoticeRows } from "./embed-model-command.mjs";
+import { HINTS, pickHint, hintRow, hintFits, HINT_AFTER_SECONDS } from "./hints.mjs";
+import { normalizeQuick, quickReady, quickTarget, quickBarHint, quickWarning, QUICK_MAX } from "./quick-models.mjs";
 import {
   MODELFALLBACK_PREFIX, fallbackAfterTurn, fallbackHistoryLine, fallbackNotice, keyMissingNotice,
   parseModelFallback,
@@ -517,6 +519,7 @@ const THINKING_WORDS = (() => {
  * file is missing is playful too, and the last-resort default is a real word rather than the
  * one word the list is designed to avoid.
  */
+let lastHintIdx = -1; // the tip the previous turn showed (#234)
 const pickWord = () =>
   THINKING_WORDS[Math.floor(Math.random() * THINKING_WORDS.length)] || "Shaving the yak";
 
@@ -991,6 +994,7 @@ const COMMANDS = [
   // "/model" has meant the CODING model since task #44, and "agent model" vs "agent coding model"
   // has already confused the person who built both. The descriptions carry the distinction.
   { name: "/model", desc: "switch the CODING model (the one that writes code) for this session" },
+  { name: "/quick-models", desc: "pick up to 2 coding models to flip between with ← / → at the prompt" },
   // /provider IS NOT LISTED HERE ANY MORE — see HIDDEN_COMMANDS. It was promoted to a top-level
   // command when editing a provider was genuinely unreachable, and by the very next change
   // /model carried "add or change a provider — Claude API, OpenAI, Kimi…" as a row in EVERY branch of
@@ -1855,6 +1859,7 @@ const fallbackNoticeRows = () => {
     ...(codingKeyMissingKnown === true
       ? [keyMissingNotice({ coder: activeCodingModelId(), width, gutter: GUTTER })]
       : []),
+    ...[quickWarning(quickModels, quickActiveId(), { width, gutter: GUTTER })].filter(Boolean),
   ];
 };
 
@@ -2364,7 +2369,7 @@ function slashCloseSeq(line, cursor, cols) {
 let editMode = "accept"; // "accept" | "manual"
 const modeLineText = () =>
   white("✎ " + (editMode === "accept" ? "accept edits on" : "manually edit")) +
-  dim("   (shift+tab to switch)");
+  dim("   (shift+tab to switch)") + (quickBarHint(quickModels) ? dim("  " + quickBarHint(quickModels)) : "");
 // Token usage for the bar's middle row (task #104): the LAST turn's code-model input +
 // output, then the coder's lifetime output total. Unlike the old per-turn print, this row is
 // ALWAYS on screen — a turn that did no code-model work honestly reads "0", and the lifetime
@@ -4732,6 +4737,14 @@ if (process.stdin.isTTY) {
     if (key && key.ctrl && key.name === "t" && !slashOverlayActive) {
       if (toggleNewestThought()) return;
     }
+    // ← / → at the EMPTY prompt flips between the two quick models (#233). Only at an idle prompt:
+    // not in a question (askWaiting), not during a command or a turn (inputVisible is false then),
+    // not over the slash menu, and never on a line with text — there the arrows move the caret.
+    if (key && (key.name === "left" || key.name === "right") && !key.ctrl && !key.meta && !key.shift
+        && rl.line === "" && inputVisible && !askWaiting && !slashOverlayActive && quickReady(quickModels)) {
+      void quickSwitch();
+      return;
+    }
     // Shift+Tab cycles the edit mode shown in the bottom bar (display-only). Skip while the
     // slash overlay owns the screen so we don't fight its redraw.
     if (key && key.name === "tab" && key.shift) {
@@ -5779,6 +5792,25 @@ async function loadSessionCoding(cwd) {
   }
 }
 
+async function loadQuickModels(cwd) {
+  try {
+    return normalizeQuick(JSON.parse(await readFile(sessionFilePath(cwd), "utf8"))?.quickModels);
+  } catch {
+    return [];
+  }
+}
+
+async function saveQuickModels(cwd) {
+  try {
+    await updateSessionFile(cwd, (raw) => {
+      raw.quickModels = quickModels;
+      raw.updatedAt = new Date().toISOString();
+    });
+  } catch (err) {
+    console.error(dim(`(quick models save failed: ${err.message})`));
+  }
+}
+
 /** This folder's stored choice — the SHAPE reading lives in terminal-layout, where it is
  *  testable; only the file I/O is here. */
 async function loadSessionRagStorage(cwd) {
@@ -6096,9 +6128,25 @@ async function runModelDoctor() {
     "\n" + GUTTER +
       (bad.length === 0
         ? accent("✓ every configured model answered.")
-        : red(`✗ ${bad.length} of ${results.length} did not answer.`)) +
-      "\n"
+        : red(`✗ ${bad.length} of ${results.length} did not answer.`))
+  );
+  // 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");
+  const verdict = await withPendingStatus("the gu service", async () =>
+    sc.checkGuService({
+      hostedBase: (await import("./client-expert-api.mjs")).hostedApiBase(),
+      apiBase,
+      workerKey,
+      localApi: isLocalApiBase(apiBase),
+      proxy: await (await import("./proxy-store.mjs")).loadProxy().catch(() => null),
+      dispatcherFor: (await import("./proxy-dispatcher.mjs")).dispatcherFor,
+    })
   );
+  for (const [i, l] of verdict.lines.entries()) {
+    console.log(GUTTER + (i === 0 ? (verdict.ok ? accent(l) : red(l)) : dim(l)));
+  }
+  console.log("");
 }
 
 /** THROUGH THE PROXY (#160), like every other model call — a bare fetch is what fails on a
@@ -6108,410 +6156,6 @@ async function doctorFetch(url, init) {
   return proxyFetch(url, init);
 }
 
-async function reconfigureOllamaServer() {
-  const os = await import("./ollama-setup.mjs");
-  const am = await import("./agent-model-command.mjs");
-  const md = await import("./model-doctor.mjs");
-  const { proxyFetch } = await import("./proxy-dispatcher.mjs");
-
-  const settings = await withPendingStatus("reading your model settings", fetchWorkerSettings);
-  if (!settings) {
-    console.log(red("   couldn't reach the API to read your current settings.\n"));
-    return;
-  }
-
-  /** Load a box's models THROUGH THE PROXY (#160) — a bare fetch is what fails on a restricted
-   *  network, and it fails as "no models", which is the wrong story entirely. */
-  const load = async (n, key = "") => {
-    const res = await withPendingStatus(`loading models from ${n.host}`, () =>
-      proxyFetch(os.tagsUrlFor(n), {
-        signal: AbortSignal.timeout(8000),
-        // #301: the key typed for this server; absent → the request is what it always was.
-        ...(key ? { headers: { Authorization: `Bearer ${key}` } } : {}),
-      })
-    );
-    // The status is kept: a 404 here means "answered, but not an Ollama" (#43), not "unreachable".
-    if (!res.ok) throw Object.assign(new Error(`HTTP ${res.status}`), { httpStatus: res.status });
-    return am.parseOllamaTags(await res.json().catch(() => null));
-  };
-
-  // #301: the way out, said under every server question (full once, short after), and the keys
-  // typed for servers, by host — saved against their rows once the settings are written.
-  const ui = await import("./model-setup-ui.mjs");
-  const hint = ui.createHinter();
-  const typedKeys = new Map();
-  const askKeyFor = async (host) => {
-    if (typedKeys.has(host)) return typedKeys.get(host); // same server for both roles → asked once
-    console.log(dim(`    ${hint()}`));
-    // askSecret: masked, kept out of history; Esc throws PromptCancelled → /model is cancelled
-    // with nothing changed, which is what "skip all" means here.
-    const k = (await askSecret(`   API key for ${host} (Enter for none): `)).trim();
-    typedKeys.set(host, k);
-    console.log(GUTTER + dim(ui.keyConfirmation(host, k)));
-    return k;
-  };
-
-  /** Ask for one server and load it. Returns {normalized, models} or null (declined/failed). */
-  const askServer = async (label, dflt, { require = false, short = "server", role = "coder" } = {}) => {
-    for (let attempt = 0; attempt < 3; attempt++) {
-      // The address goes ABOVE, in full — it is long, it is the thing Enter accepts, and the
-      // frozen row is too narrow to hold it without truncating exactly that. The row itself
-      // carries a short label so it is obvious WHAT is being asked for.
-      // Shown WITHOUT /v1 (task #220 follow-up): the suffix in a default reads as an
-      // instruction, leaving the reader unsure whether their own address needs it. It does not
-      // — normalizeOllamaUrl adds it — and displayUrl round-trips, so what is shown can be fed
-      // straight back as the default.
-      console.log(dim(`   ${label} — Enter keeps ${os.displayUrl(dflt)}`));
-      console.log(dim(`    ${hint()}`));
-      // THE ROW MUST SAY WHICH SERVER IT IS ASKING FOR. It said a bare "server:" — chosen to
-      // fit the frozen row, which traded away the one thing the label was for. Two questions
-      // in a row, both reading "server:", and the reader cannot tell which one they are
-      // answering (reported: "it should say 'Agent + Embedder server' then 'Coding Server',
-      // it only says 'server:'"). `short` is the role in the fewest words that still name it.
-      const typed = (await ask(`  ${short}: `)).trim();
-      // "s" is the advertised skip (#301); the older words still work.
-      if (ui.readStepAnswer(typed).kind === "skip") return null;
-      // EVERY READING OF A BARE HOSTNAME, in order. Typing "ollama2.getmarsic.cc" means
-      // https://…:443 behind a proxy, while "192.168.1.40" means http://…:11434 — one guess
-      // is right for one of them and produces a timeout that looks like a dead server for the
-      // other. See urlCandidates; the load decides, not the heuristic.
-      const candidates = os.urlCandidates(typed || dflt);
-      if (!candidates.length) {
-        console.log(dim("   that is not a server address — try 192.168.1.40 or a full URL"));
-        continue;
-      }
-      let n = null;
-      let models = null;
-      let lastErr = null;
-      // #301: a TYPED public address may need a key — asked before listing, so a server that
-      // needs one can list its models. A LAN box is never asked.
-      let key = "";
-      if (ui.shouldAskKey({ typed, host: candidates[0].host })) key = await askKeyFor(candidates[0].host);
-      const tryAll = async () => {
-        for (const cand of candidates) {
-          try {
-            models = await load(cand, key);
-            n = cand;
-            if (candidates.length > 1) console.log(dim(`   using ${os.displayUrl(cand.url)}`));
-            return;
-          } catch (err) {
-            lastErr = err;
-          }
-        }
-      };
-      await tryAll();
-      // Refused for want of credentials: ask now, whatever the address looked like, and list again.
-      if (!n && ui.needsKeyAfterStatus(lastErr?.httpStatus) && !key) {
-        console.log(yellow(`   ${candidates[0].host} needs an API key to list its models.`));
-        typedKeys.delete(candidates[0].host);
-        key = await askKeyFor(candidates[0].host);
-        if (key) await tryAll();
-      }
-      if (!n && ui.needsKeyAfterStatus(lastErr?.httpStatus)) {
-        console.log(red(`   ${candidates[0].host} refused the request (HTTP ${lastErr.httpStatus})${key ? " — that key was not accepted" : ""}.`));
-        continue;
-      }
-      if (!n) {
-        if (lastErr?.httpStatus === 404) {
-          // IT ANSWERED — it is simply not an Ollama (#43). "Couldn't reach … is Ollama listening"
-          // sent people to debug a server that was working.
-          for (const l of am.describeNotOllama(candidates[0].host, role)) console.log(yellow(`   ${l}`));
-          continue;
-        }
-        // One address typed, one failure reported — naming every candidate would be two errors
-        // for one mistake, and neither would be the address they gave.
-        console.log(red(`   couldn't reach ${candidates[0].host}: ${os.networkReason(lastErr)}`));
-        console.log(dim("   check the address, that Ollama is listening on the network, and /proxy."));
-        continue;
-      }
-      const usable = os.usableModelList(models);
-      if (!usable.ok) {
-        for (const l of os.describeUnusableList(usable.why, n.host)) console.log(dim(`   ${l}`));
-        continue;
-      }
-      if (require) {
-        // THE AGENT AND THE EMBEDDER ARE NOT A FREE CHOICE. A box without them is "not ready",
-        // not "wrong" — it can still be a perfectly good coder host, so this refuses the ROLE
-        // rather than the server.
-        const need = os.checkRequired(models);
-        if (!need.ok) {
-          for (const l of os.describeNotReady(n.host, need.missing)) console.log(yellow(`   ${l}`));
-          console.log(dim("   (or type s to skip — you can set it later with /model)"));
-          continue;
-        }
-        console.log(dim(` ✓ ${n.host} has the ${os.REQUIRED_AGENT_PREFIX} family and the embedder`));
-      }
-      console.log(dim(`   found ${models.length} model${models.length === 1 ? "" : "s"} on ${n.host}`));
-      return { normalized: n, models };
-    }
-    return null;
-  };
-
-  // AN AGENT ON A PROVIDER IS NOT ASKED ABOUT HERE (#43). This flow is for Ollama boxes; offering
-  // https://api.openai.com as the "agent + embedding server" could only fail its /api/tags probe and
-  // ask again. Keep it, say where it is changed, and go on to the coder.
-  const agentOnProvider = am.agentIsOnProvider(settings);
-  const curAgent =
-    String(settings.agentModelUrl ?? "").trim() || "https://ollama1.getmarsic.cc/v1";
-  const curCode = am.coderServerDefault(settings);
-
-  let agent = null;
-  if (agentOnProvider) {
-    const host = hostOf(String(settings.agentModelUrl ?? ""));
-    console.log(dim(`   The agent model is on ${host} (OpenAI-compatible) — kept as it is; change it with /agent-model.`));
-    console.log(dim("   Enter keeps the current address."));
-  } else {
-    console.log(dim("   TWO servers may be used: the agent + embedder on one, the coder on another."));
-    console.log(dim("   Enter keeps the current address."));
-    agent = await askServer("Agent + embedding server", curAgent, {
-      require: true,
-      short: "agent + embed server",
-      role: "agent",
-    });
-  }
-  const coder = await askServer("Coding-model server", agent?.normalized?.url ?? curCode, {
-    short: "coding server",
-    role: "coder",
-  });
-
-  // Task #14: skipping is a real answer, not a failure — but the bottom bar must keep saying
-  // what it cost. Declining the AGENT + embed server leaves both roles unset → both warnings.
-  if (!agent && !agentOnProvider) {
-    agentMissing = true; // no agent model chosen → the agent falls back to the coding model
-    embedMissing = true; // the embedder lives on the agent server → RAG is off until /embed-model
-  }
-
-  if (!agent && !coder) {
-    console.log(dim("   nothing set — models stay as they are.\n"));
-    return;
-  }
-
-  // THE AGENT IS CHOSEN TOO (user, 2026-09-06). checkRequired now gates on the gemma4 FAMILY
-  // rather than one exact tag, so "the box is ready" no longer names a single model — which of
-  // its gemma4s routes every turn is a real decision, and a box commonly holds a small one for
-  // speed beside a larger one for quality. Skipped when there is only one candidate: a picker
-  // with a single row is a question with one answer.
-  let chat = "";
-  if (agent) {
-    // Task #36: the saved agent stays a choice (and the default) even when it is not a gemma4.
-    const { cands, current: agentDefault } = os.agentChoices(
-      agent.models,
-      String(settings.agentModelName ?? "").trim()
-    );
-    if (cands.length <= 1) {
-      chat = agentDefault;
-    } else {
-      const labels = cands.map((m) => {
-        const size = am.formatSize(m.sizeBytes);
-        return `${m.model}${size ? dim(`  ${size}`) : ""}${m.model === agentDefault ? dim("  (current)") : ""}`;
-      });
-      console.log(dim(`   AGENT model — routes every turn, writes the plain replies  (${PICK_HINT}):`));
-      const pick = await pickFromList(
-        labels,
-        Math.max(0, cands.findIndex((m) => m.model === agentDefault))
-      );
-      if (pick < 0) {
-        console.log(dim("   (cancelled — nothing changed)\n"));
-        return;
-      }
-      chat = cands[pick].model;
-    }
-  }
-
-  // The CODER is chosen from whatever its box has; the EMBEDDER is not a choice at all.
-  let code = "";
-  let extras = [];
-  if (coder) {
-    const roles = os.defaultRoles(coder.models, {
-      preferred: { code: String(settings.agentCodingModelName ?? "").trim() },
-    });
-    const labels = coder.models.map((m) => {
-      const size = am.formatSize(m.sizeBytes);
-      const kind = am.isLikelyEmbedder(m) ? dim("  · embedder") : "";
-      return `${m.model}${size ? dim(`  ${size}`) : ""}${kind}${m.model === roles.code ? dim("  (current)") : ""}`;
-    });
-    console.log(dim(`   CODING model — writes the code; worth waiting for  (${PICK_HINT}):`));
-    const idx = await pickFromList(labels, Math.max(0, coder.models.findIndex((m) => m.model === roles.code)));
-    if (idx < 0) {
-      console.log(dim("   (cancelled — nothing changed)\n"));
-      return;
-    }
-    code = coder.models[idx].model;
-
-    const rest = coder.models.filter((m) => !am.isLikelyEmbedder(m) && m.model !== code);
-    if (rest.length) {
-      // Pre-ticked from what /model already offers, so re-running starts from what is saved
-      // rather than from empty — otherwise every re-run silently drops the extras you had.
-      const already = new Set(
-        (Array.isArray(settings.agentCodingBackends) ? settings.agentCodingBackends : [])
-          .filter((b) => (b?.kind ?? "") === "ollama")
-          .flatMap((b) => (Array.isArray(b.models) ? b.models : []))
-      );
-      console.log(
-        dim(`   Also offer these in /model?  (up to ${MAX_ALT_CODERS} · ${PICK_MANY_HINT}):`)
-      );
-      const ticks = await pickManyFromList(
-        rest.map((m) => `${m.model}${am.formatSize(m.sizeBytes) ? dim(`  ${am.formatSize(m.sizeBytes)}`) : ""}`),
-        rest.map((m, i) => (already.has(m.model) ? i : -1)).filter((i) => i >= 0),
-        { max: Math.max(MAX_ALT_CODERS, rest.filter((m) => already.has(m.model)).length) }
-      );
-      // null is Escape and cancels the command; an EMPTY list is a legitimate "offer none".
-      if (ticks === null) {
-        console.log(dim("   (cancelled — nothing changed)\n"));
-        return;
-      }
-      extras = ticks.map((i) => rest[i].model);
-    }
-  }
-
-  // WRITE ONLY THE HALVES THAT WERE SET. Someone who configured a coder but skipped the agent
-  // box must not have their existing agent model wiped — half-configured is a real state and
-  // clobbering the other half is the opposite of what skipping asked for.
-  const patch = {};
-  if (agent) {
-    Object.assign(patch, {
-      agentModelUrl: agent.normalized.url,
-      agentModelName: chat,
-      agentModel: chat,
-      ragEnabled: true,
-      ragEmbedUrl: agent.normalized.url,
-      ragEmbedModel: os.defaultEmbedModel?.(agent.models) ?? os.REQUIRED_EMBED_MODEL,
-    });
-  }
-  if (coder) {
-    Object.assign(patch, {
-      agentCodingModelUrl: coder.normalized.url,
-      agentCodingModelName: code,
-      agentCodingModelKind: "ollama",
-      agentCodingDefaultKind: "ollama",
-      // MERGED, not replaced (#43): the providers already configured — and the keys bound to them —
-      // survive choosing a new Ollama server.
-      agentCodingBackends: (await import("./client-expert-api.mjs")).mergeOllamaServerBackends(
-        (await import("./coding-provider-setup.mjs")).existingBackendRows(settings),
-        (await import("./client-expert-api.mjs")).codingBackendsForClientExpert({
-          url: coder.normalized.url,
-          chat: agent ? chat : code,
-          code,
-          altCoders: extras,
-        }),
-        { isCloud: (await import("./coding-key-prompt.mjs")).isOllamaCloudUrl }
-      ),
-    });
-  }
-
-  const saved = await withPendingStatus("saving", () =>
-    md.saveWorkerSettings(apiBase, workerKey, patch)
-  );
-  if (!saved) {
-    console.log(red("   couldn't save that to this machine — nothing changed."));
-    console.log(GUTTER + dim("if this machine's local API is old, restart it with `gu api restart`.\n"));
-    return;
-  }
-  // #301: THE KEYS TYPED FOR THE SERVERS, bound to their rows now that the rows exist (the API
-  // refuses a key for a row it does not have). Before the cloud check below, so a key typed for
-  // the Ollama cloud is not asked for a second time. Reported by host, never by value.
-  {
-    const used = [agent?.normalized?.url, coder?.normalized?.url].filter(Boolean);
-    // By HOSTNAME: the key was asked for urlCandidates' host, which carries no port, while a URL's
-    // .host does — box.example.com:8443 would otherwise never match its own key.
-    const hostnameOf = (u) => { try { return new URL(u).hostname; } catch { return ""; } };
-    const pending = [...typedKeys].filter(([host, k]) => k && used.some((u) => hostnameOf(u) === host));
-    if (pending.length) {
-      const fresh = await withPendingStatus("storing the key", fetchWorkerSettings);
-      const ps = await import("./coding-provider-setup.mjs");
-      for (const [host, k] of pending) {
-        const url = used.find((u) => hostnameOf(u) === host);
-        const found = ps.providerRowForUrl(ps.existingBackendRows(fresh ?? {}), url);
-        if (!found) {
-          console.log(yellow(`   no server row holds ${host} yet — add its key with ctrl+k in /model.`));
-          continue;
-        }
-        const ok = await withPendingStatus("saving the key", () => addCodingKey(host, k, found.id));
-        console.log(ok
-          ? GUTTER + dim(`✓ key stored for ${host} — the server's default key`)
-          : red(`   couldn't store the key for ${host} — add it with ctrl+k.`));
-      }
-    }
-  }
-  // THE OLLAMA CLOUD NEEDS ITS OWN KEY. Reported: choosing https://ollama.com here listed its 20 models
-  // (that list is public) and saved, without a key — and the next turn failed "REJECTED the coding API
-  // key", having borrowed an unrelated sk-… key. Asked for now, bound to the row just saved.
-  {
-    const cloudUrls = [coder?.normalized?.url, agent?.normalized?.url].filter(
-      (u, i, all) => u && all.indexOf(u) === i && isOllamaCloudUrl(u)
-    );
-    if (cloudUrls.length) {
-      const fresh = await withPendingStatus("checking the Ollama cloud key", fetchWorkerSettings);
-      const keys = await fetchCodingKeys();
-      const ps = await import("./coding-provider-setup.mjs");
-      for (const u of cloudUrls) {
-        const found = ps.providerRowForUrl(ps.existingBackendRows(fresh ?? {}), u);
-        if (found && !am.boundKeyFor(keys, found.id)) {
-          console.log(yellow(`   ${hostOf(u)} is the Ollama cloud — it needs its own API key (the model list worked without one).`));
-          // The shared key prompt (task #245); the server's first key becomes its default.
-          const { name, secret } = await askServerKey({ host: hostOf(u) });
-          if (secret && !(await withPendingStatus("saving the key", () => addCodingKey(name, secret, found.id)))) {
-            console.log(red("   couldn't save the key — add it with ctrl+k.\n"));
-          }
-        }
-      }
-    }
-  }
-  // THE ACCOUNT DEFAULT JUST CHANGED — say so in memory, or the bar reports the old one.
-  //
-  // The override is cleared just below, correctly: what was picked here IS the account default
-  // now, so an override would be a duplicate of it. But the bar reads
-  // `sessionCodingLabel || defaultCodingModel`, and defaultCodingModel was read from the
-  // startup payload and never touched again. Clearing one while the other stayed stale is why
-  // the confirmation said gemma4 and the footer kept showing the old coder (reported
-  // 2026-09-05). Both halves of that expression have to be current, not one.
-  if (coder) {
-    defaultCodingModel = code;
-    defaultCodingUrl = coder.normalized.url;
-  }
-  // The session override names a model on the OLD box; leaving it set would send a name the new
-  // host has never heard of, with the settings now correct — the most confusing shape of all.
-  sessionCodingModel = "";
-  sessionCodingLabel = "";
-  sessionCodingUrl = "";
-  // Persist the CLEARING too. The stored override names a model on the OLD box; leaving it on
-  // disk would resurrect it at the next launch, against a server that has never heard of it.
-  await saveSessionCoding(resolve(process.cwd()));
-  await syncActiveCoderWhere(); // the bar now names the account default — with ITS host (#263)
-  // The GLOBAL output-token total is keyed to the coding backend (task #125), and the backend
-  // just moved — re-fetch it for the new one, exactly as /model does after a pick, or the
-  // footer keeps counting against the box that is no longer in use.
-  if (coder) {
-    const t = await fetchOutputTokenTotals(resolve(process.cwd()));
-    const g = pickGlobalTotal(t);
-    if (g !== null) globalOutputTokens = g;
-  }
-  paintBar(); // …and show all of it now, not at the next keystroke
-  console.log(accent(" ✓ models saved"));
-  if (agent) {
-    console.log(dim(`      chat   ${chat}  @ ${agent.normalized.host}`));
-    console.log(dim(`      RAG    ${os.defaultEmbedModel?.(agent.models) ?? os.REQUIRED_EMBED_MODEL}  @ ${agent.normalized.host}`));
-  } else {
-    console.log(dim("      chat   — not set (agent server skipped)"));
-  }
-  console.log(
-    coder
-      ? dim(`      code   ${code}  @ ${coder.normalized.host}`)
-      : dim("      code   — not set (coding server skipped)")
-  );
-  if (extras.length) console.log(dim(`      also   ${extras.join(", ")}  — offered by /model`));
-  // Compare to the embedder this box was seeded with — an accepted OTHER embedder (a
-  // qwen3-embedding-only box) was written to settings above, so REQUIRED_EMBED_MODEL would
-  // falsely scream "changed" while the seeded value is exactly what settings now hold.
-  const seededEmbed = agent ? (os.defaultEmbedModel?.(agent.models) ?? os.REQUIRED_EMBED_MODEL) : "";
-  // Only a CHANGE when there was an embedder before — from none it is simply set (task #36).
-  const prevEmbed = String(settings.ragEmbedModel ?? "").trim();
-  if (agent && prevEmbed && prevEmbed !== seededEmbed) {
-    console.log(dim("   the embedder changed — existing RAG indexes need rebuilding (/rag)."));
-  }
-  console.log(dim("   takes effect on your next question.\n"));
-}
-
 // ---------- fetch the ready-to-run agent payload from user settings ----------
 // /model command: fetch the allowed coding models (default + web-curated whitelist),
 // show a numbered picker, and set sessionCodingModel to the choice for this session.
@@ -6775,8 +6419,7 @@ async function changeProviderModel(ps, rows, p) {
     return;
   }
   // THE FOLDER'S PICK NAMES THE OLD MODEL. Leaving it would send a name this provider no longer
-  // offers, with the settings now correct — the most confusing shape there is (the same trap
-  // reconfigureOllamaServer clears its override for).
+  // offers, with the settings now correct — the most confusing shape there is.
   if (sessionCodingLabel === p.model || sessionCodingModel.endsWith(`::${p.model}`)) {
     sessionCodingModel = "";
     sessionCodingLabel = "";
@@ -7275,6 +6918,76 @@ async function useCoderInThisFolder({ ps, rows, beforeChoices, url, host, locali
   { const g = pickGlobalTotal(t); if (g !== null) globalOutputTokens = g; }
 }
 
+
+/**
+ * The picker rows for a list of coding choices, and the tags that tell same-named ones apart.
+ * Shared by /model and /quick-models (#233) so the two lists read identically.
+ */
+function codingChoiceLabels(choices, def) {
+  const { tags, show: showTag } = codingChoiceTags(choices);
+  const labels = choices.map((c, i) => {
+    // Every row says WHERE it runs in front of the name ("ollama.com/kimi-k3",
+    // "api.anthropic.com/claude-opus-5" — #263), so the kind tag is only for a row with no server.
+    const where = coderWhere(c.kind, c.url);
+    const tag = showTag && !where ? `  ${dim(`· ${tags[i]}`)}` : "";
+    return `${coderDisplayName(c.model, where)}${tag}${c.id === def ? "  (default)" : ""}`;
+  });
+  return { labels, tags, showTag };
+}
+
+/**
+ * /quick-models — tick up to two coding models to flip between with ← / → (#233). The list is the
+ * same (backend, model) choices /model offers, pre-ticked from what is saved; Enter saves, Esc leaves
+ * it as it was.
+ */
+async function chooseQuickModels() {
+  let probe;
+  try {
+    probe = await withPendingStatus("loading models", () => fetchAgentPayload([{ role: "user", content: "ping" }]));
+  } catch (err) {
+    console.log(red(`   ${describeApiFailure(err, "couldn't load models")}\n`));
+    return;
+  }
+  const def = (probe?.codingDefault ?? "").trim();
+  const choices = Array.isArray(probe?.codingChoices) && probe.codingChoices.length
+    ? probe.codingChoices
+    : (Array.isArray(probe?.codingAllowed) ? probe.codingAllowed : []).map((id) => ({ id, model: id, kind: "" }));
+  if (choices.length < 2) {
+    console.log(dim("   Quick models need at least two coding models — add one with /model → add or change a provider.\n"));
+    return;
+  }
+  const { labels } = codingChoiceLabels(choices, def);
+  const pre = quickModels.map((q) => choices.findIndex((c) => c.id === q.id)).filter((i) => i >= 0);
+  console.log(dim(`   Tick up to ${QUICK_MAX} models to flip between with ← / →  (space ticks · Enter saves · Esc cancels):`));
+  const picked = await pickManyFromList(labels, pre, { max: QUICK_MAX });
+  if (picked === null) {
+    console.log(dim("   (cancelled)\n"));
+    return;
+  }
+  quickModels = normalizeQuick(picked.map((i) => choices[i]));
+  await saveQuickModels(resolve(process.cwd()));
+  if (quickModels.length === 0) console.log(dim("   quick models cleared — ← / → does nothing.\n"));
+  else if (quickModels.length === 1) console.log(accent(` ✓ 1 quick model: ${quickModels[0].model}`) + dim(" — pick a second to switch with ← / →\n"));
+  else console.log(accent(` ✓ quick models: ${quickModels.map((c) => c.model).join("  ⇄  ")}`) + dim("   (← / → at the prompt)\n"));
+  paintBar();
+}
+
+/** ← / → at the empty prompt: flip to the other quick model, through the same steps as /model. */
+async function quickSwitch() {
+  if (quickSwitching) return;
+  const target = quickTarget(quickModels, quickActiveId());
+  if (!target) return;
+  quickSwitching = true;
+  try {
+    await applyChosenCoder(target, { quick: true });
+  } catch (e) {
+    if (!wasPromptCancelled(e)) console.log(red(`   quick switch failed: ${e?.message ?? e}\n`));
+  } finally {
+    quickSwitching = false;
+    paintBar();
+  }
+}
+
 async function chooseModel() {
   let probe;
   try {
@@ -7307,35 +7020,24 @@ async function chooseModel() {
     // through to add when there is genuinely nothing there.
     console.log(dim("   No coding model configured."));
     const go = await pickFromList(
-      [dim("leave it"), "add or change a provider — Claude API, OpenAI, Kimi…", "change the Ollama server this machine uses…"],
+      [dim("leave it"), "add or change a provider — Claude API, OpenAI, Kimi…"],
       1
     );
     if (go === 1) await manageCodingProviders();
-    else if (go === 2) await reconfigureOllamaServer();
     else console.log("");
     return;
   }
-  // ONE ENTRY THAT IS NOT A MODEL (task #220 req 6): re-point this machine at a different Ollama
-  // box. Offered HERE because /model is where someone already is when they discover the coder is
-  // wrong — and on a Client Expert machine there is no web app to go and change it in. Appended
-  // last so it never shifts the index of a model anyone has muscle memory for.
-  // …and shown even when there is only ONE model, because "only one is available" is often the
-  // symptom of being pointed at the wrong box, and the old message sent people to a web app a
-  // Client Expert machine does not have.
+  // Shown even with ONE model: "only one is available" often means the wrong server, and the
+  // 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}.`));
-    // APPENDED AFTER the existing entry, here and below, so that entry keeps the index anyone
-    // who has used it already reaches for.
     const go = await pickFromList(
-      [
-        dim("keep it"),
-        "change the Ollama server this machine uses…",
-        "add or change a provider — Claude API, OpenAI, Kimi…",
-      ],
+      [dim("keep it"), "add or change a provider — Claude API, OpenAI, Kimi…"],
       0
     );
-    if (go === 1) await reconfigureOllamaServer();
-    else if (go === 2) await manageCodingProviders();
+    if (go === 1) await manageCodingProviders();
     else console.log("");
     return;
   }
@@ -7345,18 +7047,10 @@ async function chooseModel() {
   // Which tag tells these rows apart — the kind, or the provider the API derived from each
   // URL. The rule and its reasons live in coding-choice-tags.mjs (task #223): two
   // OpenAI-compatible providers are both "OpenAI-compatible", so the kind names neither.
-  const { tags, show: showTag } = codingChoiceTags(choices);
-  const labels = choices.map((c, i) => {
-    // Every row says WHERE it runs in front of the name ("ollama.com/kimi-k3",
-    // "api.anthropic.com/claude-opus-5" — #263), so the kind tag is only for a row with no server.
-    const where = coderWhere(c.kind, c.url);
-    const tag = showTag && !where ? `  ${dim(`· ${tags[i]}`)}` : "";
-    return `${coderDisplayName(c.model, where)}${tag}${c.id === def ? "  (default)" : ""}`;
-  });
+  const { labels, tags, showTag } = codingChoiceLabels(choices, def);
   const activeIdx = choices.findIndex((c) => c.id === active);
-  labels.push("change the Ollama server this machine uses…");
-  // Task #223. Appended LAST, after the #220 entry, for the same reason that one is appended
-  // after the models: a new row must never shift an index someone already has muscle memory for.
+  // Task #223. Appended LAST, after the models: a new row must never shift an index someone
+  // already has muscle memory for.
   //
   // "add or change" rather than "add", because add-only was a one-way door: a model id typed
   // wrong could not be corrected from anywhere, here or in web Settings. The entry leads to the
@@ -7377,14 +7071,21 @@ async function chooseModel() {
     console.log(dim("   (cancelled)\n"));
     return;
   }
-  // The appended entries sit past the last model, so they are the only indices without a choice.
-  // Their ORDER here must match the order they were pushed in, or a pick runs the other flow.
+  // The one appended entry sits past the last model.
   if (idx >= choices.length) {
-    if (idx === choices.length) await reconfigureOllamaServer();
-    else await manageCodingProviders();
+    await manageCodingProviders();
     return;
   }
-  const chosen = choices[idx];
+  await applyChosenCoder(choices[idx], { def, tag: showTag ? tags[idx] : "" });
+}
+
+/**
+ * Make `chosen` ({ id, model, kind, url }) the coding model: session state, saved choice, the key
+ * check and the lifetime token total. The tail of /model, extracted so /quick-models' ← / → (#233)
+ * runs EXACTLY the same steps — a quick switch that skipped the key prompt would leave gu on a
+ * coder it cannot use (#181). `quick` only quietens the output: one ✓ line, no key essay.
+ */
+async function applyChosenCoder(chosen, { def = "", tag = "", quick = false } = {}) {
   // Empty override means "use the account default" — so don't send an override when the
   // user picks the default (keeps the payload clean and lets a later default change win).
   // GitHub #130: what to go back to if the key prompt for the new coder is cancelled (Esc).
@@ -7409,7 +7110,7 @@ async function chooseModel() {
   // WRITTEN NOW, not at the end of the next turn: `/model` then `/exit` is how the choice is
   // made and then tested, and that path never reaches saveSession.
   await saveSessionCoding(resolve(process.cwd()));
-  const where = showTag && !activeCoderWhere ? ` (${tags[idx]})` : "";
+  const where = tag && !activeCoderWhere ? ` (${tag})` : "";
   console.log(
     accent(
       ` ✓ coding model → ${coderDisplayName(chosen.model, activeCoderWhere)}${where}${chosen.id === def ? " (default)" : ""}\n`
@@ -7480,7 +7181,7 @@ async function chooseModel() {
       backendId: ks.backendId,
       host: ks.provider,
     });
-    console.log(
+    if (!quick) console.log(
       dim("   API key ") + accent(line.text) +
         (line.note ? orange(`  ·  ${line.note}`) : "") +
         dim(`  ·  ctrl+k to ${line.verb} it`)
@@ -7490,7 +7191,7 @@ async function chooseModel() {
     // the more common one — "how do I change the model" — with no visible answer at all. Reported
     // three times from exactly this view, twice after being told where the picker entry was.
     // /provider is hidden (see HIDDEN_COMMANDS): point at the row of /model that does the same.
-    console.log(dim("   to change this provider's model or URL, or remove it: /model → add or change a provider\n"));
+    if (!quick) console.log(dim("   to change this provider's model or URL, or remove it: /model → add or change a provider\n"));
   }
   // Task #125: the GLOBAL lifetime total is per-backend, so re-fetch it for the newly
   // selected backend NOW — otherwise the footer would keep showing the previous backend's
@@ -11524,6 +11225,16 @@ let jobIdForApprovalRace = "";
 // Task #123: with several backends configured this is a QUALIFIED id ("<kind>::<model>"),
 // which resolves to a whole backend — URL, kind and API key — not just a model name.
 let sessionCodingModel = "";
+// QUICK MODELS (#233): up to two coding choices ({ id, model, kind, url }) that ← / → flips between at
+// the empty prompt. Per folder, in the session file, like the /model pick.
+let quickModels = [];
+let quickSwitching = false;
+/** The id the quick list compares against: the folder's pick, else the account default's choice id. */
+const quickActiveId = () => {
+  if (sessionCodingModel) return sessionCodingModel;
+  const d = quickModels.find((c) => c.id === defaultCodingModel) ?? quickModels.find((c) => c.model === defaultCodingModel);
+  return d ? d.id : defaultCodingModel;
+};
 /**
  * WHICH STORED API KEY THIS FOLDER USES for the coding model (task #222, phase 3).
  *
@@ -12277,6 +11988,10 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
   let thinking = false;
   let thinkingSince = 0;
   let thinkWord = pickWord(); // playful word shown UNDER the in-progress line (flavor)
+  // ONE TIP PER TURN (#234), under the word: stable for the whole turn (a tip that changed every few
+  // seconds would be read as flicker), never the one the previous turn showed.
+  const hintIdx = (lastHintIdx = pickHint(Math.random, lastHintIdx));
+  let blockHintRows = 0; // 1 while the tip row is part of the live block (see the click arithmetic)
   let lastWordBucket = -1; // 12s window index → rotate the word once per window (task: 30-spinner)
   let almostDone = false; // set from the worker's "…almost completed thinking…" heartbeat
   let runningCmd = null; // the command currently executing (from a "Running → …" event)
@@ -12545,7 +12260,13 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
     // redrawn continuously, so a blank written into the transcript would either accumulate one
     // per redraw or be stranded above a block that has since moved. Owned by the block, they
     // are erased with it — always exactly one, wherever it currently is. See LEAD_ROWS/WORD_GAP.
-    const drawn = 2 + LEAD_ROWS + WORD_GAP + expLines.length + detailRows.length;
+    // THE TIP (#234): after a few seconds of waiting, one dim row under the word. Not on a very
+    // short terminal, not with the animation off, and never wrapped.
+    const hintText = !stillStatus && hintIdx >= 0 && secs >= HINT_AFTER_SECONDS && hintFits(process.stdout.rows)
+      ? hintRow(HINTS[hintIdx], { width: Math.max(20, process.stdout.columns || 80), indent: visibleLen(GUTTER) })
+      : "";
+    blockHintRows = hintText ? 1 : 0;
+    const drawn = 2 + LEAD_ROWS + WORD_GAP + expLines.length + detailRows.length + blockHintRows;
     // The bottom bar rides along UNDER the live status while a turn runs, so it stays on screen
     // the whole time the agent is thinking instead of only at the prompt. It's part of the same
     // in-place block: the ticker redraws it every 120ms and clearStatus wipes it with the rest,
@@ -12616,6 +12337,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
     contentRows.push(
       clipRow(`${markLine(waitPaint(wc, glyph))}${waitPaint(wc, `${thinkWord}…`)}${outLabel}`)
     );
+    if (hintText) contentRows.push(clipRow(GUTTER + dim(hintText)));
     // PINNED → the block IS frozen rows; unpinned (a window too short to reserve any) there is
     // no zone, so it keeps the old in-place draw at the output position.
     if (barPinned()) {
@@ -12660,7 +12382,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
     //   LEAD_ROWS · thought · detail… · expansion… · WORD_GAP · word
     // so the responding rows run from `top` to the last expansion row — statusContentLines less
     // the fixed rows around them (the two gaps, the thought line and the word row).
-    if (row < top || row > top + statusContentLines - LEAD_ROWS - WORD_GAP - 2) return;
+    if (row < top || row > top + statusContentLines - LEAD_ROWS - WORD_GAP - 2 - blockHintRows) return;
     // Only meaningful when there IS a fuller thought to reveal; otherwise ignore the click
     // so we don't flicker an empty expand.
     if (!thoughtExpanded && !liveExpandable) return;
@@ -13823,6 +13545,7 @@ async function main() {
       sessionEmbedKeyId = await loadSessionFolderKeyId(resolve(process.cwd()), "embed");
     }
   }
+  quickModels = await loadQuickModels(resolve(process.cwd())); // #233 — folder file only, whatever the database said
   // Fetch the API key tail after loading the session, if a key is configured
   if (sessionCodingKeyId) {
     try {
@@ -13866,7 +13589,7 @@ async function main() {
       void syncEmbedWarning({ repair: true });
     }
     // A RESTORED PICK MUST STILL EXIST. The stored id names a model on the box this folder was
-    // last pointed at — and the box can change (`/model` → change the Ollama server), a model
+    // last pointed at — and the server can change (`/model` → add or change a provider), a model
     // can be removed, or the folder can be opened on another machine entirely. Sending a name
     // the account no longer allows fails the FIRST TURN with "not in your allowed coding
     // models", which reads as a broken agent rather than as a stale preference.
@@ -14277,7 +14000,8 @@ async function main() {
           red("gu: this machine has no models set up yet.") +
             dim(
               "\n  Nothing can run until it knows which Ollama server to use." +
-                "\n  Start `gu`, then `/model` → change the Ollama server this machine uses." +
+                "\n  Start `gu`, then `/agent-model` → use an Ollama server, `/embed-model` for RAG," +
+                "\n  and `/model` → add a provider → another URL… for the coding model." +
                 `\n  The agent server needs a ${REQUIRED_AGENT_PREFIX} model (e.g. ${REQUIRED_AGENT_MODEL})` +
                 `\n  and any ONE of these embedders: ${ACCEPTED_EMBED_MODELS.map((m) => m.replace(/:latest$/, "")).join(", ")};` +
                 "\n  the agent and coding models are then yours to pick."
@@ -14765,6 +14489,10 @@ async function main() {
       paintBar();
       continue;
     }
+    if (line === "/quick-models") {
+      await chooseQuickModels();
+      continue;
+    }
     if (line === "/model") {
       await chooseModel();
       await refreshNoModelAtAll(); // #188: a coding model may have just been set → drop its row