@tiens.nguyen/gu-cli 1.0.813 → 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

@@ -2628,6 +2628,10 @@ _RAG_STEP: dict = {"n": 0}
 #   "unavailable" — RAG isn't configured at all
 # A metric that cannot tell "it wasn't needed" from "it couldn't have worked" answers nothing.
 _RAG_STATE: dict = {"s": "unknown"}
+# Issue #120: mid-turn auto-compaction, per turn. n = passes that actually saved something,
+# tok = the prompt size (tokens) that triggered the latest one. Rides on the prompt breakdown
+# so the REPL can show a "compacting context" note on the bottom bar.
+_COMPACT_STATE: dict = {"n": 0, "tok": 0}
 # Is this turn's index on LOCAL disk? Module-level because _rag_known_sources() reads it from
 # outside run_agent_chat — and it had no module-level definition at all, so that function raised
 # NameError on EVERY call, in every mode. Found by testing the three storage modes (#180).
@@ -2979,6 +2983,9 @@ def _prompt_breakdown(messages, total_tokens: int, step: int = 0, ledger=None) -
         "grepCalls": int(_SEARCH_TALLY.get("grep") or 0),
         "grepHits": int(_SEARCH_TALLY.get("grep_hits") or 0),
         "readCalls": int(_SEARCH_TALLY.get("read") or 0),
+        # Issue #120: how often this turn auto-compacted, and at what size (tokens).
+        "compacted": int(_COMPACT_STATE.get("n") or 0),
+        "compactedAt": int(_COMPACT_STATE.get("tok") or 0),
     }
 
 
@@ -4575,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
@@ -8319,6 +8419,8 @@ def run_agent_chat(cfg):
     # credit RAG for tokens it never cost, and a wrong number is worse than none.
     _rag_ledger_reset()
     _RAG_STEP["n"] = 0
+    _COMPACT_STATE["n"] = 0
+    _COMPACT_STATE["tok"] = 0
     _overload_notified["yes"] = False
     try:
         from smolagents import CodeAgent, OpenAIServerModel, tool
@@ -9529,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)
@@ -10615,8 +10718,11 @@ def run_agent_chat(cfg):
                 # Yes/No before deep-compacting (the auto-trim above is always-on; THIS is
                 # the extra, opt-in aggressive pass). Only in the terminal (interactive) —
                 # web has no picker, so it just keeps the auto-trim.
-                if (_interactive_approval and _job_id and worker_api_base and worker_api_key
-                        and _compact_state["decision"] != "never"):
+                # Issue #120: this used to be gated on an interactive terminal AND read
+                # _compact_state["decision"], a key removed with the old Yes/No prompt — the
+                # KeyError was swallowed below as "memory-trim skip", so mid-turn compaction
+                # NEVER ran and the context grew past the model's window. Always on now.
+                if _steps:
                     # Size of the last request in prompt tokens (exact if the server
                     # reported it, else ~chars/4 of the current step memory).
                     _tu = getattr(step_log, "token_usage", None)
@@ -10652,6 +10758,12 @@ def run_agent_chat(cfg):
                                 f"{_VERBOSE_PREFIX}Context reached ~{_in_tok // 1000}k tokens — trimming older "
                                 "steps to stay fast (files are re-readable)")})
                         if _cs:
+                            _COMPACT_STATE["n"] += 1
+                            _COMPACT_STATE["tok"] = int(_in_tok)
+                            # Issue #120: tell the terminal NOW (not on the next request's
+                            # breakdown) so it can lock input and show the compacting bar.
+                            _emit({"type": "compact", "n": _COMPACT_STATE["n"],
+                                   "tok": _COMPACT_STATE["tok"]})
                             _log(f"context compact: saved ~{_cs} chars "
                                  f"(at ~{_in_tok} tok, threshold {_compact_at}, "
                                  f"window {_ctx_window or 'unknown'})")
@@ -14209,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"
@@ -4394,6 +4430,18 @@ async function runAgentChatJob(job) {
             }),
           }).catch(() => {});
         }
+      } else if (event.type === "compact" && Number.isFinite(event.n)) {
+        // Issue #120: a mid-turn compaction just landed — put it on the job straight away so
+        // the REPL locks input and shows its progress bar now, not at the next request.
+        latestPromptBreakdown = {
+          ...(latestPromptBreakdown || {}),
+          compacted: event.n,
+          ...(Number.isFinite(event.tok) ? { compactedAt: event.tok } : {}),
+        };
+        workerFetch(`/api/worker/jobs/${jobId}`, {
+          method: "PATCH",
+          body: JSON.stringify({ agentPromptBreakdown: latestPromptBreakdown }),
+        }).catch(() => {});
       } else if (event.type === "code_request") {
         // Task #155: the row is opened BEFORE the request goes out, so a step that is
         // cancelled, hangs, or is refused still leaves a readable record of exactly what was

package/gu-repl.mjs

@@ -62,6 +62,8 @@ import {
   thoughtBlockRows,
   ragSegmentLabel,
   ragBarNote,
+  compactBarNote,
+  compactProgressNote,
   searchSegmentLabel,
   runningDetailRows,
   formatThinkTime,
@@ -549,6 +551,8 @@ const brightText = (s) => s; // default terminal colour (un-dimmed) — the "pop
 // forward reference here is a startup crash, not a lint warning.
 const BULLET_STYLE = {
   fail: { mark: CROSS, markColor: red, textColor: brightText },
+  // A look-up (grep/pgrep/rg…) that found nothing: not an error — a dim grey ✗, dim text.
+  soft: { mark: CROSS, markColor: dim, textColor: dim },
   ok: { mark: CHECK, markColor: accent, textColor: dim },
   info: { mark: BULLET, markColor: dim, textColor: dim },
 };
@@ -2726,6 +2730,39 @@ const ragLineText = () => {
 // that counts rows with ESC[nA / ESC[nB (the #109 failure mode). Called fresh on every draw,
 // so a resize simply re-lays it out (task #138); the RAG row is verbose-only, which is why the
 // row COUNT is taken from this array rather than hard-coded anywhere.
+// Issue #120: while a mid-turn compaction runs, EVERYTHING is locked — keys are swallowed, the
+// turn's output is held back — and only the progress bar on the bottom bar moves. The trim
+// itself takes milliseconds, so the lock lasts a short fixed window the user can actually see.
+// Ctrl+C (SIGINT) still cancels the turn: a lock must never trap the user.
+const COMPACT_LOCK_MS = 1500;
+let compactLock = null;        // { startedAt, until } while locked
+let compactSeenPasses = 0;     // compaction passes already shown this turn
+let compactLockTimer = null;
+const compactLocked = () => !!compactLock && Date.now() < compactLock.until;
+function startCompactLock() {
+  const now = Date.now();
+  compactLock = { startedAt: now, until: now + COMPACT_LOCK_MS };
+  if (compactLockTimer) clearInterval(compactLockTimer);
+  compactLockTimer = setInterval(() => {
+    if (!compactLocked()) endCompactLock();
+    else if (barPinned()) paintBar();
+  }, 80);
+  if (barPinned()) paintBar();
+}
+function endCompactLock() {
+  if (compactLockTimer) clearInterval(compactLockTimer);
+  compactLockTimer = null;
+  const was = !!compactLock;
+  compactLock = null;
+  if (was && barPinned()) paintBar();
+}
+const compactLockNote = () =>
+  compactLock
+    ? compactProgressNote({
+        frac: (Date.now() - compactLock.startedAt) / COMPACT_LOCK_MS,
+        at: lastPromptBreakdown?.compactedAt,
+      })
+    : "";
 const footerRows = () =>
   buildFooterRows({
     width: process.stdout.columns || 80,
@@ -2736,7 +2773,8 @@ const footerRows = () =>
     mode: modeLineText(),
     // Task #34: "rag: embedder down → grep fallback" as a soft yellow note beside the mode, not an
     // alarming red segment on the token row. yellow goes through paint(), so NO_COLOR turns it off.
-    modeNote: ragBarNote(lastPromptBreakdown),
+    // Issue #120: an auto-compaction this turn outranks the rag note (same soft yellow slot).
+    modeNote: compactLockNote() || compactBarNote(lastPromptBreakdown) || ragBarNote(lastPromptBreakdown),
     notePaint: yellow,
     // How to paste here (issue #67): the platform's text key, plus gu's image key when the coder
     // can take an image.
@@ -4358,6 +4396,13 @@ if (process.stdin.isTTY) {
     // re-rendered the slash overlay (the line still starts with "/" from before the paste) and
     // re-walked the paste store. Same for a mouse report's characters, which are not keys.
     if (pasteBuffer !== null || inMouseKeyWindow()) return;
+    // Issue #120: compacting → every key is locked (Ctrl+C still arrives as SIGINT).
+    if (compactLocked()) {
+      rl.line = "";
+      rl.cursor = 0;
+      rl.historyIndex = -1;
+      return;
+    }
     // #247: the restored question was erased (Backspace, Ctrl+U, a picker taking the line) — it
     // is let go, exactly as with Ctrl+C, so the next message does not REPLACE it in history.
     if (prefillFor && (listPickerActive || restoredQuestionLetGo(rl.line, key))) prefillFor = null;
@@ -5249,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) {
@@ -5983,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()
     );
@@ -6194,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"));
@@ -6816,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`));
@@ -7057,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
@@ -7098,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"
@@ -11299,6 +11372,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
   following = true;
   followingAttached = attached;
   typedDuringTurn = false;
+  compactSeenPasses = 0; // issue #120: python counts passes per turn
   followAborted = false;
   currentJobId = jobId;
   jobIdForApprovalRace = jobId; // so an approval picker can watch THIS job for early end (#110)
@@ -12369,6 +12443,12 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
       if (job.agentPromptBreakdown && typeof job.agentPromptBreakdown === "object") {
         lastPromptBreakdown = job.agentPromptBreakdown;
         liveStepTokens = readStepTokens(job.agentPromptBreakdown);
+        // Issue #120: a NEW compaction pass this turn → lock everything and show the bar.
+        const compactPasses = Number.isFinite(job.agentPromptBreakdown.compacted) ? job.agentPromptBreakdown.compacted : 0;
+        if (compactPasses > compactSeenPasses) {
+          compactSeenPasses = compactPasses;
+          startCompactLock();
+        }
         // Persisted per folder so the next `gu` here starts from the real picture instead
         // of a zero that looks like a failure. Fire-and-forget: a bar value is never worth
         // delaying a turn for, and losing one is harmless. Shown while attached (it is what
@@ -12385,6 +12465,9 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
       // Mirror both into the bottom bar's token row so it counts UP live while the turn runs
       // (the bar rides under the status block now), instead of sitting on the last turn's
       // figures until this one finishes. The turn-end assignment writes the same numbers again.
+      // Issue #120: hold the turn's output while compacting — only the bar moves. Ctrl+C ends it.
+      while (compactLocked() && !cancelRequested && !followAborted) await sleep(80);
+      if (compactLock && (cancelRequested || followAborted)) endCompactLock();
       lastTurnInputTokens = latestCodeTokens;
       lastTurnOutputTokens = latestOutputTokens;
       lastTurnTotalOutput = globalOutputTokens + latestOutputTokens;
@@ -12621,6 +12704,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
     following = false;
     followingAttached = false;
     typedDuringTurn = false;
+    endCompactLock(); // issue #120: never leave the terminal locked after a turn
     currentJobId = null;
     // Drop anything typed (but not submitted) during the turn — echo was muted, so it's
     // invisible; without this it would surface on the next prompt.
@@ -12750,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) {
@@ -12773,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;
     }
@@ -13598,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);
@@ -13645,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.
@@ -13668,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()) {
@@ -14118,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.813",
+  "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

@@ -198,6 +198,34 @@ export function ragBarNote(b) {
   return ragSegmentLabel(b) || "";
 }
 
+/**
+ * Issue #120: the bottom bar's note while a turn has AUTO-COMPACTED its context, or "".
+ *
+ * python trims older steps mid-turn once the prompt reaches ~2/3 of the model's window and
+ * reports it on the prompt breakdown (compacted = passes this turn, compactedAt = tokens at
+ * the latest one). A stale breakdown reloaded from disk is not this turn, so it gets no note.
+ */
+export function compactBarNote(b) {
+  if (!b || typeof b !== "object" || b.stale) return "";
+  const n = Number.isFinite(b.compacted) ? b.compacted : 0;
+  if (n <= 0) return "";
+  const at = Number.isFinite(b.compactedAt) && b.compactedAt > 0
+    ? ` at ~${Math.round(b.compactedAt / 1000)}k` : "";
+  return `⟳ compacting context${at} — older steps trimmed${n > 1 ? ` (${n}×)` : ""}`;
+}
+
+/**
+ * Issue #120: the bottom bar's ANIMATED note while a compaction holds the terminal locked.
+ * `frac` 0..1 is how far through the lock window we are; `at` the prompt tokens at the trim.
+ */
+export function compactProgressNote({ frac = 0, at = 0, cells = 12 } = {}) {
+  const f = Math.max(0, Math.min(1, Number.isFinite(frac) ? frac : 0));
+  const full = Math.round(f * cells);
+  const bar = "█".repeat(full) + "░".repeat(cells - full);
+  const k = Number.isFinite(at) && at > 0 ? ` at ~${Math.round(at / 1000)}k` : "";
+  return `⟳ compacting context${k} ▕${bar}▏ ${Math.round(f * 100)}% — input locked`;
+}
+
 /** Cut plain text to `room` visible columns, ending with "…" when it was cut. */
 function fitPlain(s, room) {
   s = String(s ?? "");
@@ -1114,7 +1142,28 @@ export function trimWords(text, limit) {
   return toks.join(" ").trimEnd() + "…";
 }
 
+// A LOOK-UP command (grep, rg, pgrep, which, lsof…) exits non-zero when it simply finds
+// nothing. That is an answer ("not there"), not a fault — so a "Command failed → pgrep -f x"
+// must not pop as a red ✗ (#41's "the one thing you must not miss"). It is "soft": a dim
+// grey ✗ with dim text. Judged by the LAST segment of a chain/pipeline (its exit status is
+// the one reported): `ps aux | grep foo` and `cd src && rg Foo` are both look-ups.
+const SEARCH_CMDS = new Set([
+  "grep", "egrep", "fgrep", "zgrep", "rg", "ag", "ack", "pgrep", "which", "whereis", "lsof",
+]);
+export function isSoftFailCommand(cmd) {
+  const segs = String(cmd ?? "").split(/&&|\|\||[|;]/).map((s) => s.trim()).filter(Boolean);
+  if (!segs.length) return false;
+  const toks = segs[segs.length - 1].split(/\s+/);
+  let i = 0;
+  while (i < toks.length && (/^[A-Za-z_][A-Za-z0-9_]*=/.test(toks[i]) || ["env", "command", "time", "nice"].includes(toks[i]))) i++;
+  const prog = (toks[i] || "").split("/").pop();
+  if (SEARCH_CMDS.has(prog)) return true;
+  return prog === "git" && toks[i + 1] === "grep";
+}
+
 export function bulletKind(text) {
+  const mFail = /^Command failed → (.+)$/.exec(String(text ?? "").trim());
+  if (mFail && isSoftFailCommand(mFail[1])) return "soft";
   if (/\bfail(ed|s|ure)?\b|\berror(ed)?\b|→\s*(?:HTTP\s*)?[45]\d\d\b/i.test(text)) return "fail";
   if (/^(?:Command finished|Server up|App launched)\b|→\s*(?:HTTP\s*)?2\d\d\b|\b(?:passed|succeeded|ready)\b/i.test(text))
     return "ok";
@@ -1611,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
@@ -1708,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.