@tiens.nguyen/gu-cli 1.0.814 → 1.0.816

package/README.md

@@ -10,7 +10,8 @@ gu            # open the REPL in the current folder
 
 The package installs three commands: `gu` (the terminal REPL), `gu-cli` and `gu-local-worker`
 (the same worker CLI). Requires Node.js 18 or newer. The install runs `fix-path` for you; if
-npm's global bin folder is not on your PATH afterwards, run `gu-cli fix-path`.
+npm's global bin folder is not on your PATH afterwards, run `npx @tiens.nguyen/gu-cli fix-path`
+(works even when `gu-cli` itself is not found, e.g. when npm skipped the install script).
 On Windows, PowerShell's built-in `gu` alias (Get-Unique) shadows this CLI — run
 `gu-cli fix-powershell` to drop it.
 

package/client-expert-run.mjs

@@ -312,8 +312,8 @@ export async function ensureNativeMongoMac(ask, mongo, { log = (l) => console.lo
   log(dim(installing ? "\n  It is not installed here. This installs it (Homebrew):\n" : "\n  It is installed but not running. This starts it:\n"));
   for (const s of steps) log(`    brew ${s.join(" ")}`);
   log("");
-  const yes = await ask(installing ? "  Install MongoDB now? [Y/n]: " : "  Start MongoDB now? [Y/n]: ");
-  if (String(yes ?? "").trim().toLowerCase().startsWith("n")) {
+  const yes = await readYesNo(ask, installing ? "  Install MongoDB now? [Y/n]: " : "  Start MongoDB now? [Y/n]: ", true, log);
+  if (!yes) {
     log(dim(`\n  Not ${installing ? "installed" : "started"} — run the commands above yourself.`));
     return { ok: false, explained: true };
   }
@@ -440,8 +440,8 @@ export async function ensureNativeMongo(ask, mongo, {
   const needs = platform === "win32"
     ? "Windows may ask for administrator permission"
     : isRoot ? "" : "sudo will ask for your password";
-  const yes = await ask(`  ${installing ? "Install" : "Start"} MongoDB now?${needs ? ` (${needs})` : ""} [Y/n]: `);
-  if (String(yes ?? "").trim().toLowerCase().startsWith("n")) {
+  const yes = await readYesNo(ask, `  ${installing ? "Install" : "Start"} MongoDB now?${needs ? ` (${needs})` : ""} [Y/n]: `, true, log);
+  if (!yes) {
     log(dim(`\n  Not ${installing ? "installed" : "started"} — run the commands above yourself.`));
     return { ok: false, explained: true };
   }
@@ -608,8 +608,7 @@ export async function startMongoInDocker(ask, { platform = process.platform } =
   console.log(dim(`  Simplest path: ${plan.summary}.`));
   console.log(dim("  Your conversation history lives in that volume and survives a restart."));
   console.log(dim("\n    " + plan.commands[0] + "\n"));
-  const yes = await ask("  Start MongoDB in Docker now? [Y/n]: ");
-  if (String(yes ?? "").trim().toLowerCase().startsWith("n")) return false;
+  if (!(await readYesNo(ask, "  Start MongoDB in Docker now? [Y/n]: ", true))) return false;
 
   for (const cmd of plan.commands) {
     console.log(dim(`  $ ${cmd}`));
@@ -672,13 +671,36 @@ export async function checkMongoConnection(uri) {
  * Returns { uri, custom } to continue with, or { exit: true } when the user declines — the
  * caller ends setup with the `gu clear` → `gu` hint.
  */
+/**
+ * A [Y/n] / [y/N] answer (GitHub #128). Enter → the default; y/yes → yes; n/no → no. Anything else
+ * ("3", "maybe") is NOT taken as an answer: the question is asked again with what to type —
+ * "3" at "Install MongoDB now? [Y/n]" used to install MongoDB. A closed input (null) is "no", as
+ * it always was. After three unrecognised answers the default is used.
+ */
+export function parseYesNo(raw, defaultYes) {
+  if (raw === null || raw === undefined) return false;
+  const a = String(raw).trim().toLowerCase();
+  if (!a) return defaultYes;
+  if (a === "y" || a === "yes") return true;
+  if (a === "n" || a === "no") return false;
+  return null;
+}
+
+export async function readYesNo(ask, prompt, defaultYes, say = (l) => console.log(l)) {
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const verdict = parseYesNo(await ask(prompt), defaultYes);
+    if (verdict !== null) return verdict;
+    say(dim(`  Type y or n (Enter = ${defaultYes ? "yes" : "no"}).`));
+  }
+  return defaultYes;
+}
+
 export async function askMongoCredentials(ask, askSecret = null) {
   const { host, port } = mongoHostPort(LOCAL_MONGO_URI);
   console.log(dim(`  MongoDB is answering at ${host}:${port}.`));
   console.log(dim("  If that is a MongoDB this machine already had, it may have its OWN"));
   console.log(dim("  username and password — which setup does not know, and cannot change."));
-  const yes = await ask("  Use the default (empty username and password)? [Y/n]: ");
-  if (!String(yes ?? "").trim().toLowerCase().startsWith("n")) {
+  if (await readYesNo(ask, "  Use the default (empty username and password)? [Y/n]: ", true)) {
     return { uri: LOCAL_MONGO_URI, custom: false };
   }
   // NO → the instance has its own credentials. Ask for them, and CHECK before any installing
@@ -700,15 +722,13 @@ export async function askMongoCredentials(ask, askSecret = null) {
     }
     if (verdict.unverifiable) {
       console.log("\n  " + yellow("⚠ could not verify: ") + dim(verdict.why));
-      const carryOn = await ask("  Continue with these credentials anyway? [Y/n]: ");
-      if (!String(carryOn ?? "").trim().toLowerCase().startsWith("n")) {
+      if (await readYesNo(ask, "  Continue with these credentials anyway? [Y/n]: ", true)) {
         return { uri, custom: true, unverified: true };
       }
     } else {
       console.log("\n  " + red("✗ Check Connection failed") + dim(` — ${verdict.why}`));
     }
-    const again = await ask("  Re-enter the username and password? [y/N]: ");
-    if (!String(again ?? "").trim().toLowerCase().startsWith("y")) return { exit: true };
+    if (!(await readYesNo(ask, "  Re-enter the username and password? [y/N]: ", false))) return { exit: true };
   }
   return { exit: true };
 }

package/gonext_agent_chat.py

@@ -4582,6 +4582,99 @@ def _strip_tool_tags(text: str) -> str:
     return "\n".join(out).strip()
 
 
+def _md_scalar(v) -> str:
+    if v is None or v == "" or v == [] or v == {}:
+        return "none"
+    if isinstance(v, bool):
+        return "yes" if v else "no"
+    return str(v)
+
+
+def _md_lines(value, depth=0):
+    """Nested dict/list -> markdown bullet lines (no raw braces, quotes or brackets)."""
+    pad = "  " * depth
+    lines = []
+    if isinstance(value, dict):
+        for k, v in value.items():
+            label = str(k).replace("_", " ").strip()
+            label = label[:1].upper() + label[1:]
+            if isinstance(v, (dict, list, tuple)) and v:
+                lines.append(f"{pad}- **{label}:**")
+                lines.extend(_md_lines(v, depth + 1))
+            else:
+                lines.append(f"{pad}- **{label}:** {_md_scalar(v)}")
+    else:
+        for item in value:
+            if isinstance(item, (dict, list, tuple)) and item:
+                lines.extend(_md_lines(item, depth + 1))
+            else:
+                lines.append(f"{pad}- {_md_scalar(item)}")
+    return lines
+
+
+def _fallback_recap(steps, last_text="") -> str:
+    """Task #131: the model ended its turn with no final text (e.g. only reasoning). Build a
+    short readable recap from the steps that did run instead of showing '[No result]'."""
+    tried = []
+    for st in (steps or [])[-8:]:
+        did = str(st.get("did") or "").strip().replace(chr(10), " ")
+        m = re.search(r"([a-z_]+\([^\n]{0,70})", did)
+        label = (m.group(1) if m else did)[:70].strip()
+        if label:
+            tried.append("- " + label)
+    last = str(last_text or "").strip()
+    if not tried and not last:
+        return ""
+    out = ["**Status:** the model finished without writing a summary."]
+    if tried:
+        out += ["", "**What was run**"] + tried
+    if last:
+        out += ["", "**Last result**", last[:600]]
+    return chr(10).join(out)
+
+
+def _humanize_answer(result) -> str:
+    """Task #131: a final answer that is a dict/list (or a string that is just a JSON /
+    Python-dict literal, as DeepSeek produces) is rendered as readable markdown instead of
+    being shown as its raw repr. Plain prose is returned untouched."""
+    if result is None:
+        return ""
+    data = result
+    if isinstance(result, str):
+        s = result.strip()
+        if len(s) < 2 or s[0] not in "{[" or s[-1] not in "}]":
+            return result
+        data = None
+        try:
+            data = json.loads(s)
+        except Exception:  # noqa: BLE001
+            try:
+                import ast
+                data = ast.literal_eval(s)
+            except Exception:  # noqa: BLE001
+                return result
+        if not isinstance(data, (dict, list)) or not data:
+            return result
+    elif isinstance(result, tuple):
+        data = list(result)
+    elif not isinstance(result, (dict, list)):
+        return str(result)
+    if isinstance(data, dict):
+        out = []
+        for k, v in data.items():
+            label = str(k).replace("_", " ").strip()
+            label = label[:1].upper() + label[1:]
+            if isinstance(v, (dict, list, tuple)) and v:
+                out.append("")
+                out.append(f"**{label}**")
+                out.extend(_md_lines(v, 0))
+            else:
+                out.append("")
+                out.append(f"**{label}:** {_md_scalar(v)}")
+        return chr(10).join(out).strip()
+    return chr(10).join(_md_lines(data, 0)).strip()
+
+
 _THINK_BLOCK = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
 
 # Malformed variants of smolagents' code-block tags. Weak coding models routinely
@@ -9538,7 +9631,8 @@ def run_agent_chat(cfg):
         "instead of stopping the block. Keep UNRELATED changes in separate blocks. Take a separate "
         "step only when a call depends on a result you have not seen yet (e.g. web_search to "
         "find a URL, THEN fetch_url to read it). You SEE the Observation before the next step. "
-        "When you have enough to answer, call final_answer(<your answer>) in a code block. "
+        "When you have enough to answer, call final_answer(<your answer>) in a code block — pass a readable "
+        "markdown/prose recap (what you did, what you verified, what is left), never a dict, list or JSON. "
         "Prefer FEWER steps, and never repeat a tool call that already succeeded.\n\n"
         "{{TOOL_LIST}}\n"  # filled in below, once from the REAL registered tool objects
         + _skills_mod.prompt_block(_skills)
@@ -14227,7 +14321,9 @@ def run_agent_chat(cfg):
             _emit({"type": "step", "text": _retr})
             _log(f"retrieval summary: {_c(_retr)}")
         _emit({"type": "step", "text": "Composing answer…"})
-        final_text = _strip_tool_tags(str(result).strip()) or "[No result]"
+        final_text = (_strip_tool_tags(_humanize_answer(result).strip())
+                      or _fallback_recap(_turn_steps, _last_obs.get("text"))
+                      or "[No result]")
         _log(f"done (deterministic, no summarizer call): {len(final_text)} chars")
         _emit({"type": "final", "text": final_text})
         # onTurnEnd (task #270): after the answer is out, so a slow hook never delays it.

package/gu-cli.mjs

@@ -11,7 +11,7 @@
  */
 // FIRST, before anything that could itself fail on an old runtime: npm only WARNS about
 // `engines`, so an unsupported Node installs fine and then breaks somewhere unrelated.
-import { requireSupportedNode } from "./node-version.mjs";
+import { localModeNodeProblem, requireSupportedNode } from "./node-version.mjs";
 // The brand accent, shared with the REPL — see accent.mjs.
 import { accent } from "./accent.mjs";
 import { paint } from "./theme.mjs";
@@ -1068,13 +1068,16 @@ if (args[0] === "fix-path") {
     console.log("  If `gu` is not found in PowerShell: gu-cli fix-powershell");
     process.exit(0);
   }
-  const { globalPrefixOf } = await import("./install-path.mjs");
+  const { fixPathPrefix } = await import("./install-path.mjs");
   const { fileURLToPath } = await import("node:url");
   const { dirname, join } = await import("node:path");
   const here = dirname(fileURLToPath(import.meta.url));
-  const prefix = globalPrefixOf(here);
+  // #94: under `npx @tiens.nguyen/gu-cli fix-path` this file runs from npx's cache; fixPathPrefix
+  // then falls back to npm's global prefix when gu is installed there.
+  const prefix = fixPathPrefix({ here });
   if (!prefix) {
-    console.log(`  This gu is not a global npm install (${here}) — there is no PATH to fix.`);
+    console.log(`  gu is not installed globally with npm (${here}) — there is no PATH to fix.`);
+    console.log("  Install it with: npm install -g @tiens.nguyen/gu-cli");
     process.exit(0);
   }
   const binDir = join(prefix, "bin");
@@ -1089,9 +1092,24 @@ if (args[0] === "fix-path") {
     env: { ...env, npm_config_prefix: prefix, npm_config_global: "true" },
   });
   const said = `${r.stdout ?? ""}${r.stderr ?? ""}`.trim();
-  // It prints only when it wrote something. Silence means the line is already in the profile
-  // and this terminal simply predates it.
-  console.log(said || `  Your shell profile already adds ${binDir} to PATH — open a new terminal.`);
+  // It prints only when it wrote something. Silence USUALLY means the line is already in the
+  // profile — but check (#94): it is also silent when it skipped (e.g. a temp-dir prefix), and
+  // saying "already adds" then is a lie the user acts on.
+  if (said) {
+    console.log(said);
+  } else {
+    const { existsSync, readFileSync } = await import("node:fs");
+    const { homedir } = await import("node:os");
+    const has = [".zshrc", ".bashrc", ".bash_profile", ".profile"].some((f) => {
+      const p = join(homedir(), f);
+      try { return existsSync(p) && readFileSync(p, "utf8").includes("# >>> gu-cli PATH >>>"); } catch { return false; }
+    });
+    if (has) console.log(`  Your shell profile already adds ${binDir} to PATH — open a new terminal.`);
+    else {
+      console.log(`  ${binDir} is not on your PATH and was not added to a shell profile. Add this line to it:`);
+      console.log(`  export PATH="${binDir}:$PATH"`);
+    }
+  }
   process.exit(r.status ?? 0);
 }
 
@@ -1285,14 +1303,24 @@ if (args[0] === "clear" || args[0] === "reset") {
   }
   // The DATABASE first, while ~/.gonext/api still exists — dropping it needs the mongodb
   // driver that ships inside the downloaded API, and clearState is about to delete that folder.
-  if (groups.includes("work") && dbItem) {
+  // GitHub #125: the API's mongodb 7 driver needs Node 20.19+. On Node 18 it died with a bare
+  // "crypto is not defined"; say what is wrong and what to do instead.
+  const dropNodeProblem = groups.includes("work") && dbItem ? localModeNodeProblem() : "";
+  if (dropNodeProblem) {
+    console.log(
+      "could not drop the local database — " + dropNodeProblem.split("\n")[0] +
+        "\n  Upgrade Node and run `gu clear` again to drop it; the next setup may inherit its settings."
+    );
+  } else if (groups.includes("work") && dbItem) {
+    // GitHub #126: the client is closed even when connect/drop throws — an open client keeps
+    // its sockets and timers alive.
+    let client = null;
     try {
       const ce = await import("./client-expert-api.mjs");
       const { MongoClient } = ce.loadMongoDriver(apiDirForDrop);
-      const client = new MongoClient(ce.localMongoUri(), { serverSelectionTimeoutMS: 8000 });
+      client = new MongoClient(ce.localMongoUri(), { serverSelectionTimeoutMS: 8000 });
       await client.connect();
       await client.db(ce.LOCAL_DB_NAME).dropDatabase();
-      await client.close();
       console.log("dropped the local database");
     } catch (e) {
       // Said out loud, not swallowed: a machine that keeps its old settings row will look
@@ -1300,10 +1328,18 @@ if (args[0] === "clear" || args[0] === "reset") {
       console.log(
         `could not drop the local database (${e.message}) — the next setup may inherit its settings`
       );
+    } finally {
+      if (client) {await client.close(true).catch(() => {});}
     }
   }
-  const removed = await cs.clearState(items);
-  console.log(`removed ${removed.length} item(s).`);
+  // GitHub #126: whatever clearState does, gu clear ends here and exits.
+  try {
+    const removed = await cs.clearState(items);
+    console.log(`removed ${removed.length} item(s).`);
+  } catch (e) {
+    console.log(`could not remove everything (${e.message})`);
+    process.exit(1);
+  }
   console.log(
     groups.includes("identity")
       ? "\nNext `gu` starts from the beginning — it will ask which mode to run.\n"

package/gu-repl.mjs

@@ -5294,7 +5294,8 @@ async function markInterrupted(cwd, history, task, how) {
   const status = interruptStatus(how);
   if (!status) return;
   last.status = status;
-  await saveSession(cwd, history, { unfinishedTask: sessionUnfinishedTask || task });
+  const keep = sessionUnfinishedTask || task;
+  await saveSession(cwd, history, { unfinishedTask: isResumeWord(keep) ? "" : keep }); // #201
 }
 
 async function rememberUnfinishedTask(cwd, task) {
@@ -6028,8 +6029,8 @@ async function reconfigureOllamaServer() {
   // with a single row is a question with one answer.
   let chat = "";
   if (agent) {
-    const cands = os.agentCandidates(agent.models);
-    const agentDefault = os.defaultAgentModel(
+    // 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()
     );
@@ -6239,7 +6240,9 @@ async function reconfigureOllamaServer() {
   // 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) : "";
-  if (agent && String(settings.ragEmbedModel ?? "") !== seededEmbed) {
+  // 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"));
@@ -6861,7 +6864,8 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
     rowId = ps.mintProviderId(existing.map((b) => String(b.id ?? "")));
     const { row } = as.rowForSave(role, { id: rowId, kind: target.dialect === "ollama" ? "ollama" : "openai", url: target.url, model, extras });
     rows = [...existing, row];
-  } else {
+  } else if (found) {
+    // A keyless agent/embed server with no row needs no row: the role's own setting holds its URL.
     const r = as.rowForSave(role, { existing: found.row, model });
     if (r.full) {
       console.log(yellow(`   ${host} already offers ${ps.MAX_MODELS_PER_SERVER} models — remove one in /model → manage providers first.\n`));
@@ -7102,6 +7106,14 @@ async function chooseModel() {
   const chosen = choices[idx];
   // 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).
+  const prevCoder = {
+    model: sessionCodingModel,
+    label: sessionCodingLabel,
+    url: sessionCodingUrl,
+    where: activeCoderWhere,
+    tail: sessionApiKeyTail,
+  };
   sessionCodingModel = chosen.id === def ? "" : chosen.id;
   setModelFallback(null); // #343: the warning named the coder that was just replaced
   // Remember the friendly name for the token footer, which should never show a raw
@@ -7143,7 +7155,23 @@ async function chooseModel() {
   // exactly this key (provider-scoped), so mirror it here; a keyless coder shows no tail.
   sessionApiKeyTail = ks.needsKey && !ks.missing && ks.stored ? ks.stored.slice(-4) : "";
   if (!ks.needsKey) keyChoicePending = false; // Ollama or local MLX — nothing to choose
-  if (ks.needsKey && ks.missing) await promptForCodingKey(sessionCodingModel);
+  if (ks.needsKey && ks.missing) {
+    try {
+      await promptForCodingKey(sessionCodingModel);
+    } catch (e) {
+      if (!wasPromptCancelled(e)) throw e;
+      // GitHub #130: Esc at the new coder's key prompt cancels the PICK, not just the key —
+      // otherwise gu is left on a coder it cannot use. Restore and re-save the previous one.
+      sessionCodingModel = prevCoder.model;
+      sessionCodingLabel = prevCoder.label;
+      sessionCodingUrl = prevCoder.url;
+      activeCoderWhere = prevCoder.where;
+      sessionApiKeyTail = prevCoder.tail;
+      await saveSessionCoding(resolve(process.cwd()));
+      console.log(dim("   (cancelled — the coding model was not changed)\n"));
+      return;
+    }
+  }
   else if (ks.needsKey) {
     // THIS FOLDER'S KEY, not the account's (task #222). ks.stored comes from GET /coding-key
     // with no job named, which answers with the account default — so after picking "accounting"
@@ -12806,6 +12834,9 @@ async function main() {
       if (chosen === "client-expert") {
         const { runClientExpertSetup } = await import("./client-expert-run.mjs");
         const setup = await runClientExpertSetup({ ask });
+        // GitHub #126: setup refused (too-old Node) and said why — stop here, do not carry on
+        // into a REPL that cannot work and leave gu running after its last line.
+        if (setup?.stoppedAt === "node") process.exit(1);
         if (setup?.complete) reloadWorkerEnv();
       }
     } else if (!st.chosenMode && !gate.available) {
@@ -12829,6 +12860,7 @@ async function main() {
         askStep: (q) => ask(q).catch(toSkipAll),
         askSecret: (q) => askSecret(q).catch(toSkipAll),
       });
+      if (setup?.stoppedAt === "node") process.exit(1); // GitHub #126, as above
       if (setup?.complete) reloadWorkerEnv();
       if (setup?.loadPreset) openPresetsAtStart = true;
     }
@@ -13654,7 +13686,7 @@ async function main() {
       // rl.prompt() still runs for the NON-frozen fallback path, where readline draws the
       // input line itself. With the zone frozen (#141) discardTypedInput has already
       // repainted it, and prompt()'s own _refreshLine lands on the same paintBar().
-      rl.prompt();
+      if (!_stdinClosed) rl.prompt(); // ERR_USE_AFTER_CLOSE: a menu may have closed readline
     }
   };
   process.on("SIGINT", onInterrupt);
@@ -13701,6 +13733,9 @@ async function main() {
     enableClickToPosition();
     announceCliUpdate(); // deferred if a 6h refresh landed mid-turn; harmless once shown
     announceScaffold(); // the startup scaffold line, if it arrived while a turn was running
+    // ERR_USE_AFTER_CLOSE (task #36): Escape/EOF inside a menu can close readline; prompt() on a
+    // closed interface throws from here with a Node stack trace. Input is over — leave the loop.
+    if (_stdinClosed) break;
     rl.prompt();
     // #302, found live: prompt() puts the cursor at column 0, and a stopped turn's question is
     // already in the line — so what was typed went IN FRONT of it and Ctrl+U erased nothing.
@@ -13724,6 +13759,10 @@ async function main() {
       // prompt() erases from the caret down, so the row is rewritten in place and the empty
       // submit becomes a visual no-op. Nothing to step back over if the line came from
       // _lineQueue (no keypress, no echo) — hence the `echoed` guard.
+      if (_stdinClosed) {
+        lineRaw = null; // readline closed while we waited — never prompt() it again
+        break;
+      }
       if (process.stdout.isTTY) {
         // Frozen input line: nothing was echoed, so there is nothing to undo — just re-render.
         if (barPinned()) {
@@ -14174,19 +14213,17 @@ async function main() {
     // actually succeeds — saveSession writes the now-empty value then — so a terminal killed
     // mid-retry still has something to resume next time.
     sessionUnfinishedTask = "";
-    const { task: taskLine, resumed, nothingToResume } = resumeTask(line, pendingResume);
+    const resumeResult = resumeTask(line, pendingResume);
+    const { resumed, nothingToResume } = resumeResult;
+    // Nothing pending: the bare word goes to the coding model AS TYPED, with the conversation
+    // history, so the model decides what "continue" means from context (no hardcoded reply).
+    // The #201 loop stays closed at the WRITE side: rememberUnfinishedTask, saveSession and
+    // markInterrupted never store a resume word, and unfinishedTaskFromSession rejects one.
+    const taskLine = nothingToResume ? String(line ?? "").trim() : resumeResult.task;
     // #302 part 3: "continue" after a lost connection FOLLOWS the job that may still be running,
     // rather than sending the question again. Anything else typed lets it go.
     const reattach = lostTurn && isResumeWord(line) && lostTurn.taskLine === taskLine ? lostTurn : null;
     lostTurn = null;
-    // "continue" with nothing behind it runs NOTHING (task #201). It used to be sent to the
-    // model as the literal word, which then got remembered as the unfinished task — so every
-    // later "continue" retried "continue". Worse than the loop: with no task the model invents
-    // one, and the reported run edited a file and ran migrations nobody asked for.
-    if (nothingToResume) {
-      console.log(GUTTER + dim("nothing to continue — ask a question first.\n"));
-      continue;
-    }
     if (resumed) {
       const shown = taskLine.length > 80 ? taskLine.slice(0, 80) + "…" : taskLine;
       console.log(GUTTER + dim(`↻ retrying: ${shown}\n`));

package/install-path.mjs

@@ -56,7 +56,7 @@ if (isEntryPoint) {
     main();
   } catch (e) {
     // A postinstall that throws uninstalls the package. Report, swallow, succeed.
-    console.log(`gu-cli: PATH setup skipped (${e.message}) — run \`gu-cli fix-path\` if \`gu\` is not found.`);
+    console.log(`gu-cli: PATH setup skipped (${e.message}) — run \`npx @tiens.nguyen/gu-cli fix-path\` if \`gu\` is not found.`);
   }
   process.exit(0);
 }
@@ -83,6 +83,27 @@ export function globalPrefixOf(packageDir) {
   return prefix.join("/") || "/";
 }
 
+/**
+ * The global prefix `gu-cli fix-path` should repair — or "" (issue #94).
+ *
+ * WHY A FALLBACK: when npm stops running the postinstall, `gu-cli` is not on PATH either, so the
+ * way out is `npx @tiens.nguyen/gu-cli fix-path`. npx runs a COPY from ~/.npm/_npx/<hash>/, which
+ * is not a global install, so globalPrefixOf(here) is "". npx (and npm exec) still pass npm's
+ * global prefix in the env; use it only when gu really is installed there.
+ * Lookup order: where this file lives → npm_config_global_prefix → npm_config_prefix.
+ */
+export function fixPathPrefix({ here = "", env = process.env, exists = existsSync } = {}) {
+  const own = globalPrefixOf(here);
+  if (own) return own;
+  for (const p of [env.npm_config_global_prefix, env.npm_config_prefix]) {
+    if (!p) continue;
+    const prefix = resolve(String(p));
+    if (prefix.split("/").includes("node_modules")) continue;       // a project, not global
+    if (exists(join(prefix, "lib", "node_modules", "@tiens.nguyen", "gu-cli"))) return prefix;
+  }
+  return "";
+}
+
 function main() {
   if (platform() === "win32") return;                 // registry PATH + PowerShell alias: not here
   if (process.env.CI) return;                          // no user shell to help in CI

package/ollama-setup.mjs

@@ -93,6 +93,22 @@ export function defaultAgentModel(models, preferred = "") {
   )[0].model;
 }
 
+/**
+ * The AGENT choices /model offers (task #36): the gemma4 family, PLUS the agent already saved on
+ * this machine when this box has it. /agent-model may save any model (qwen3:14b, say); leaving it out
+ * here made the gemma4 default the preselected row, so Enter in /model silently replaced it.
+ * Returns { cands, current } — current is the row to preselect.
+ */
+export function agentChoices(models, saved = "") {
+  const list = Array.isArray(models) ? models : [];
+  const cands = agentCandidates(list);
+  const name = String(saved ?? "").trim();
+  const own = name && list.find((m) => m.model === name && !isLikelyEmbedder(m));
+  if (own && !cands.some((m) => m.model === name)) cands.unshift(own);
+  const current = own ? name : defaultAgentModel(list, name);
+  return { cands, current };
+}
+
 /** "nomic-embed-text" and "nomic-embed-text:latest" are the same model to a person. */
 const sameModel = (a, b) => {
   const bare = (s) => String(s ?? "").trim().toLowerCase().replace(/:latest$/, "");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.814",
+  "version": "1.0.816",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",

package/proxy-dispatcher.mjs

@@ -14,6 +14,7 @@
  * when shouldProxy() says so.
  */
 import { shouldProxy, proxyUrl, redactSecrets } from "./proxy-config.mjs";
+import { nodeAtLeast } from "./node-version.mjs";
 
 /**
  * One ProxyAgent per dial string, kept for reuse.
@@ -25,6 +26,9 @@ import { shouldProxy, proxyUrl, redactSecrets } from "./proxy-config.mjs";
  */
 const agents = new Map();
 
+/** undici 7's engines floor (GitHub #127). */
+export const UNDICI_MIN_NODE = "20.18.1";
+
 let ProxyAgentCtor;
 let loadError = "";
 
@@ -38,6 +42,12 @@ let loadError = "";
  */
 async function proxyAgentCtor() {
   if (ProxyAgentCtor || loadError) return ProxyAgentCtor;
+  // GitHub #127: undici 7 needs Node 20.18.1+, while gu itself (Cloud mode) still runs on 18.
+  // Name the real cause instead of letting the import fail with an unrelated error.
+  if (!nodeAtLeast(process.version, UNDICI_MIN_NODE)) {
+    loadError = `the proxy needs Node ${UNDICI_MIN_NODE} or newer — this is ${process.version}`;
+    return ProxyAgentCtor;
+  }
   try {
     ({ ProxyAgent: ProxyAgentCtor } = await import("undici"));
   } catch (err) {

package/terminal-layout.mjs

@@ -1660,6 +1660,11 @@ export function classifyTurnFailure(message) {
   if (/The agent couldn't start|The agent's prompt (could not be loaded|could not be used)|agent's prompt templates could not be loaded/i.test(t)) {
     return "setup";
   }
+  // DEPS — the agent's Python framework is missing on this machine (GitHub #129). Every turn
+  // dies at import, before any model is called; neither retrying nor switching coder helps.
+  if (/No module named ['"]?(smolagents|openai)\b|ModuleNotFoundError:.*(smolagents|openai)/i.test(t)) {
+    return "deps";
+  }
   // CONFIG — the server is up and answering; it just has no model by that name (task #213).
   // Ollama says: model 'gemma4:e4b' not found  (and "…, try pulling it first" for embeddings).
   // Checked BEFORE the backend patterns because it arrives as a 404 from a perfectly healthy
@@ -1757,6 +1762,10 @@ export function retryAdvice({ resumable = true, failures = 1, kind = "task", min
       ? `gu's own machinery has failed ${failures} times in a row — not your question, and not the coding model. Check it before retrying: gu-cli api status, and gu-cli start if the worker is not running.`
       : 'that was gu\'s own machinery stopping, not your question — "continue" runs it again';
   }
+  if (kind === "deps") {
+    // GitHub #129: name the missing piece and the one step that fixes it.
+    return 'the agent framework (smolagents + openai) is not installed in this machine\'s Python, so nothing ran — run /doctor to install it, or restart gu and answer yes to "Install the agent framework now?", then "continue" sends your question again.';
+  }
   if (kind === "setup") {
     // Nothing ran, so there is nothing to diagnose in the model or the question — only the step the
     // message above names. "continue" is right AFTER that step, never before.