@tiens.nguyen/gu-cli 1.0.895 → 1.0.897

package/README.md

@@ -188,7 +188,7 @@ gu fix-path | fix-powershell   repair PATH / remove PowerShell's `gu` alias
 | --- | --- | --- |
 | **Free trial** | 30 days, from the first run | nothing: the token is created for you |
 | **Free plan** | 3 more months on that computer | a free account at [gucli.com](https://gucli.com) |
-| **Pro** | **$4 a month** or **$40 a year** (+ VAT where it applies) | hosted models (no model server to run), up to 5 computers, provider budgets |
+| **Pro** | **$4 a month** or **$40 a year** (+ VAT where it applies) | hosted models (no model server to run), any number of computers, provider budgets |
 
 On Pro, the hosted models and the hosted API run on gu's servers, so the prompts and code you
 send through them go there. A free install keeps everything on your computer.

package/agent-model-command.mjs

@@ -119,6 +119,11 @@ export function agentModelRows(models, current) {
  * model is always named, because that is the one fact still true when the network is not.
  */
 export function describeTagsFailure({ url, current, error, proxied = false } = {}) {
+  // NOTHING CONFIGURED IS NOT A FAILURE (GH #397). There was no list to fetch, so "couldn't fetch
+  // the model list from (no agent model URL configured)", its echo and a /proxy hint were three
+  // ways of saying one thing — and the proxy cannot help with a URL that does not exist. Same
+  // sentence /model uses for the same state.
+  if (!url && !current) return ["No agent model configured."];
   const lines = [
     `couldn't fetch the model list from ${url || "(no agent model URL configured)"}`,
   ];
@@ -355,6 +360,16 @@ export function agentRecoveryOptions({ keyProblem = false, host = "" } = {}) {
   ];
 }
 
+/**
+ * Which recovery row the cursor starts on (GH #397). A key problem → the key row. NOTHING SET UP →
+ * "add a provider": the only way forward there, and what /model already highlights for its own
+ * "No coding model configured." Otherwise "leave it", so Enter on an unreachable box changes nothing.
+ */
+export function agentRecoveryDefault(options, { keyProblem = false, configured = true } = {}) {
+  const want = keyProblem ? "key" : configured ? "leave" : "provider";
+  return Math.max(0, options.findIndex((o) => o.action === want));
+}
+
 // ---------------------------------------------------------------------------------------------
 // #44 — WHAT TO CHANGE comes first.
 // ---------------------------------------------------------------------------------------------

package/cli-token.mjs

@@ -622,7 +622,8 @@ export function barNotice({ token, publicKeyB64, mode, now = new Date(), attempt
     // SHORT AND CALM (#292: "make it simpler … seems so serious"): the fact, then the one thing to
     // do. `urgent` is what the bar colours by — only these two need the user to act.
     if (ended) return { kind: "plan-ended", urgent: true, text: `Pro ended ${shortDate(p.paidUntil)} · renew at ${pricingUrl}` };
-    if (Number.isInteger(p.activeDevices) && p.activeDevices > p.deviceLimit) {
+    // Pro has no computer limit (GH #371): an over-limit line is for the other plans only.
+    if (p.plan !== "pro" && Number.isInteger(p.activeDevices) && p.activeDevices > p.deviceLimit) {
       return {
         kind: "over-limit",
         urgent: true,
@@ -728,7 +729,10 @@ export function tokenSummary(payload, now = new Date()) {
   }
   if (Number.isInteger(payload.activeDevices)) {
     const n = payload.activeDevices;
-    lines.push(`Used on ${computers(n)} in the last 30 days — the ${planName(payload.plan)} allows ${payload.deviceLimit}.`);
+    const paidPro = payload.plan === "pro" && payload.paidUntil && Date.parse(payload.paidUntil) > now.getTime();
+    lines.push(paidPro
+      ? `Used on ${computers(n)} in the last 30 days — Pro has no computer limit.`
+      : `Used on ${computers(n)} in the last 30 days — the ${planName(payload.plan)} allows ${payload.deviceLimit}.`);
   }
   lines.push(`Issued ${shortDate(payload.issuedAt)}.`);
   return lines;
@@ -827,7 +831,8 @@ export function enforcementDecision({ token, publicKeyB64, now = new Date(), sit
       );
     }
   }
-  if (Number.isInteger(p.activeDevices) && p.activeDevices > p.deviceLimit) {
+  // PRO HAS NO COMPUTER LIMIT (GH #371) — not even with a token from a server that still sends a count.
+  if (!paid && Number.isInteger(p.activeDevices) && p.activeDevices > p.deviceLimit) {
     return {
       enforced: true,
       allowed: false,

package/coding-provider-setup.mjs

@@ -729,7 +729,7 @@ const NOT_A_CHAT_MODEL = [
   /moderation/i,
   /\btts\b|-tts|text-to-speech/i,
   /whisper|transcribe|audio|realtime|voice/i,
-  /image|vision-preview|dall-?e|sora/i,
+  /image|vision-preview|dall-?e|sora|video/i,
   /search(-preview|-api)?$|-search-/i,
   /rerank|guard|classifier/i,
   // OpenAI's original completion endpoints — they take a prompt, not messages.

package/daemon-control.mjs

@@ -18,7 +18,8 @@ import {
   spawnSurviving,
 } from "./platform-tools.mjs";
 import { isLocalApiBase } from "./terminal-layout.mjs";
-const PROC_LIST = processListCommand();
+// Only this user's processes (GH #396): another account's gu daemon is not "ours is running".
+const PROC_LIST = processListCommand(process.platform, { ownUser: true });
 
 const DIR = join(homedir(), ".gonext");
 export const PID_FILE = join(DIR, "worker.pid");

package/doctor-check.mjs

@@ -63,6 +63,47 @@ export function rolesFromSettings(s) {
   ];
 }
 
+/**
+ * THE MODELS A TURN ACTUALLY RUNS ON (GH #397), from the agent-payload the turn itself fetches.
+ *
+ * rolesFromSettings reads the legacy single-provider fields. /model now stores the coder as a
+ * provider row (agentCodingBackends), so on a machine set up with today's /model the coder read
+ * as "not configured" while turns ran on it fine — and the chat model was probed WITHOUT its key,
+ * so a working Qwen/OpenAI setup showed "HTTP 401 No API-key provided". Asking the same endpoint
+ * a turn asks means /doctor checks what a turn uses, key included.
+ *
+ * `codingKey` is fetched separately (the payload never carries the coder's key). The embedder is
+ * not in the payload, so it still comes from settings. Returns null when there is no payload, so
+ * the caller can fall back to rolesFromSettings.
+ */
+export function rolesFromPayload(payload, settings, codingKey = "") {
+  if (!payload || typeof payload !== "object") return null;
+  const str = (v) => String(v ?? "").trim();
+  // "local" is the API's "no key needed" marker, not a credential.
+  const realKey = (k) => (str(k) && str(k) !== "local" ? str(k) : "");
+  const [, , embed] = rolesFromSettings(settings);
+  const agentSet = payload.agentMissing !== true;
+  return [
+    {
+      role: "chat",
+      label: "chat model",
+      why: "answers and routes every turn",
+      url: agentSet ? str(payload.agentBaseURL) : "",
+      model: agentSet ? str(payload.agentModelId) : "",
+      apiKey: agentSet ? realKey(payload.agentApiKey) : "",
+    },
+    {
+      role: "code",
+      label: "coding model",
+      why: "writes the code",
+      url: str(payload.codingBaseURL),
+      model: str(payload.codingModelId),
+      apiKey: realKey(codingKey),
+    },
+    embed,
+  ];
+}
+
 /**
  * WHY a model that will not answer is not answering, when the host is an Ollama.
  *
@@ -166,7 +207,8 @@ export async function checkRole(
   try {
     res = await fetchImpl(endpoint, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      // The key goes in the header only — never into the result, which is printed.
+      headers: { "Content-Type": "application/json", ...(r.apiKey ? { Authorization: `Bearer ${r.apiKey}` } : {}) },
       body: JSON.stringify(body),
       signal: AbortSignal.timeout(timeoutMs),
     });
@@ -245,3 +287,23 @@ export function doctorLines(results) {
   }
   return out;
 }
+
+/**
+ * THE VERDICT LINE (GH #397). "✓ every configured model answered." was printed when NOTHING was
+ * configured — vacuously true, and green on a machine that cannot answer a single question. The
+ * check mark is only earned by a model that answered; with none set up the verdict says so and
+ * names where to start. Returns { tone: "ok" | "warn" | "bad", text }.
+ */
+export function doctorSummary(results) {
+  const list = Array.isArray(results) ? results : [];
+  const bad = list.filter((r) => r.status !== "ok" && r.status !== "unset");
+  const ok = list.filter((r) => r.status === "ok");
+  const unset = list.filter((r) => r.status === "unset");
+  if (bad.length) return { tone: "bad", text: `✗ ${bad.length} of ${list.length} did not answer.` };
+  if (!ok.length) return { tone: "warn", text: "· no model is set up yet, so nothing was checked — start with /model." };
+  if (unset.length) {
+    const names = unset.map((r) => r.label).join(", ");
+    return { tone: "warn", text: `✓ ${ok.length} answered · not set up: ${names}.` };
+  }
+  return { tone: "ok", text: "✓ every configured model answered." };
+}

package/gonext_agent_chat.py

@@ -1707,7 +1707,9 @@ def _coding_backend_flags(backend):
         # — it applies whenever a folder is registered, i.e. every coding session — and 20 was
         # far too low for real work: a NestJS feature routinely spends that on reading and
         # installing before it has written a line, so the run stopped to ask mid-task
-        # (user, 2026-08-10: "lets increase it to 100 instead of 20").
+        # (user, 2026-08-10: "lets increase it to 100 instead of 20"). Then 200 for the same reason
+        # (GH #395, user, 2026-11-06: "increase step per turn to 200 instead of 100, only if reach 200
+        # steps it will ask for permission to continue"): the __MAXSTEP__ question is only asked at 200.
         #
         # Raising it is cheap because the budget is a STOP, not a reservation: a turn that needs
         # 12 steps still takes 12. What it changes is how often a working run is interrupted to
@@ -1716,7 +1718,7 @@ def _coding_backend_flags(backend):
         #
         # The no-workspace defaults stay small on purpose: without a registered folder there are
         # no file tools, so a long run there is a model looping rather than making progress.
-        "budget": (20, 100) if backend == "openai" else (10, 100) if backend == "ollama" else (5, 40),
+        "budget": (20, 200) if backend == "openai" else (10, 200) if backend == "ollama" else (5, 40),
     }
 
 
@@ -6569,17 +6571,24 @@ def _rg_binary(env=None):
     """The ripgrep to use, or "" for none. GU_RG=0 turns it off; GU_RG=<path> picks one; then PATH,
     then gu's own copy in ~/.gonext/bin."""
     import os
-    import shutil
     env = os.environ if env is None else env
     want = (env.get("GU_RG") or "").strip()
     if want.lower() in ("0", "off", "false", "no"):
         return ""
     if want:
         return want if os.path.isfile(want) and os.access(want, os.X_OK) else ""
-    found = shutil.which("rg", path=env.get("PATH"))
-    if found:
-        return found
-    own = os.path.join(os.path.expanduser("~"), ".gonext", "bin", "rg.exe" if os.name == "nt" else "rg")
+    # PATH by hand, not shutil.which: on Windows which() looks in the CURRENT folder first, and
+    # gu runs inside the user's project — a repo that ships its own rg.exe would be executed.
+    # Relative PATH entries ("", ".") are skipped for the same reason.
+    exe = "rg.exe" if os.name == "nt" else "rg"
+    for d in (env.get("PATH") or "").split(os.pathsep):
+        d = d.strip().strip('"')
+        if not d or not os.path.isabs(d):
+            continue
+        cand = os.path.join(d, exe)
+        if os.path.isfile(cand) and os.access(cand, os.X_OK):
+            return cand
+    own = os.path.join(os.path.expanduser("~"), ".gonext", "bin", exe)
     return own if os.path.isfile(own) and os.access(own, os.X_OK) else ""
 
 

package/gu-repl.mjs

@@ -46,6 +46,7 @@ import dotenv from "dotenv";
 import {
   clipVisible,
   createMouseKeyWindow,
+  createTurnTypingDetector,
   promptBreakdownRows,
   promptTotal,
   resumeTask,
@@ -1435,7 +1436,7 @@ rl._ttyWrite = (str, key) => {
     }
     if (verdict.action === "consume") {
       mouseClearTimer();
-      applyMouseReport(verdict.report);
+      if (verdict.report) applyMouseReport(verdict.report); // null: focus in/out, a win32 record
       return;
     }
     if (verdict.action === "replay") {
@@ -3236,8 +3237,8 @@ function frozenZone() {
     // #258: typing during a turn is not sent — the row says so (an ask() label still comes first).
     prompt: secretInput && secretPrompt
       ? accent(secretPrompt)
-      : following && typedDuringTurn && !inlinePrompt
-        ? yellow(typedNotice(width))
+      : turnRowNotice(width) && !inlinePrompt
+        ? yellow(turnRowNotice(width))
         : inlinePrompt ? accent(inlinePrompt) : PROMPT,
     // WHILE A SECRET IS OPEN, THIS ROW IS THE PROMPT — "kimi-k3 API key: ••••" rather than
     // ">> ••••". Same row, same masking; what changes is that it now says what it wants. The
@@ -3246,8 +3247,8 @@ function frozenZone() {
     promptCols:
       secretInput && secretPrompt
         ? visibleLen(secretPrompt)
-        : following && typedDuringTurn && !inlinePrompt
-          ? visibleLen(typedNotice(width))
+        : turnRowNotice(width) && !inlinePrompt
+          ? visibleLen(turnRowNotice(width))
           : inlinePrompt
             ? visibleLen(inlinePrompt)
             : PROMPT_COLS,
@@ -4742,7 +4743,11 @@ if (process.stdin.isTTY) {
     // are part of a payload readline never sees. Without this, every pasted character also
     // 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;
+    if (pasteBuffer !== null) return;
+    if (inMouseKeyWindow()) {
+      turnTyping.reset(); // a held "[" was the start of that report (GH #382)
+      return;
+    }
     // Issue #120: compacting → every key is locked (Ctrl+C still arrives as SIGINT).
     if (compactLocked()) {
       rl.line = "";
@@ -4789,8 +4794,9 @@ if (process.stdin.isTTY) {
       if (key && key.name === "tab" && key.shift) switchEditMode();
       // A printable key (or Enter after one) means the user is typing a question that will not
       // be sent — say so in the input row now, not after they have typed the whole thing (#258).
-      const printable = typeof _ch === "string" && _ch.length > 0 && !/[\x00-\x1f\x7f]/.test(_ch) && !key?.ctrl && !key?.meta;
-      if (printable && !typedDuringTurn) {
+      // Not every printable key is typing: a mouse report or cursor reply whose ESC came alone
+      // arrives as "[", "^[[", "[12;5R" (Windows, GH #382) — the detector sits those out.
+      if (turnTyping.feed(_ch, key) && !typedDuringTurn) {
         typedDuringTurn = true;
         if (barPinned()) paintBar();
       }
@@ -6190,7 +6196,11 @@ async function runModelDoctor() {
     return;
   }
   console.log(dim("   Asking each model to answer — the real request, not just a ping."));
-  const roles = dc.rolesFromSettings(settings);
+  // The SAME models, URLs and keys a turn gets (GH #397): this folder's /model pick included.
+  const turnPayload = await fetchAgentPayload([{ role: "user", content: "ping" }], sessionCodingModel).catch(() => null);
+  const p = turnPayload?.payload ?? null;
+  const codingKey = p?.codingBackendId ? (await fetchKeyForBackend(p.codingBackendId))?.apiKey ?? "" : "";
+  const roles = dc.rolesFromPayload(p, settings, codingKey) ?? dc.rolesFromSettings(settings);
   const results = [];
   for (const r of roles) {
     // One at a time, and SAID one at a time: these share a GPU, so a check can take a while and
@@ -6207,13 +6217,8 @@ async function runModelDoctor() {
       console.log(GUTTER + (res.status === "ok" ? dim(l) : res.status === "unset" ? dim(l) : yellow(l)));
     }
   }
-  const bad = results.filter((r) => r.status !== "ok" && r.status !== "unset");
-  console.log(
-    "\n" + GUTTER +
-      (bad.length === 0
-        ? accent("✓ every configured model answered.")
-        : red(`✗ ${bad.length} of ${results.length} did not answer.`))
-  );
+  const verdict0 = dc.doctorSummary(results);
+  console.log("\n" + GUTTER + (verdict0.tone === "ok" ? accent : verdict0.tone === "bad" ? red : yellow)(verdict0.text));
   // THE GU SERVICE TOO (#413): every model can answer and a coding turn still fail, because its
   // instructions come from the gu service — reported on a Windows VM where only "hi" worked.
   const sc = await import("./service-check.mjs");
@@ -6286,10 +6291,16 @@ async function doctorFetch(url, init) {
  * Returns [] when there is nothing to offer, or null when the user cancelled — which the caller
  * must treat as "abandon", not as "offer none", or Escape would silently save something.
  */
-async function pickExtraModels(rest, preChecked = []) {
-  if (rest.length === 0) return [];
-  console.log(dim(`   Also offer these in /model?  (up to ${MAX_ALT_CODERS} · ${PICK_MANY_HINT}):`));
+async function pickExtraModels(rest0, preChecked = []) {
+  // The SAME non-coding filter as the main pick (GH #397): the extras are coders too, and this
+  // list offered image, audio and video models the picker just above had hidden.
   const already = new Set(preChecked);
+  const { codingModelCandidates } = await import("./coding-provider-setup.mjs");
+  const keep = new Set(codingModelCandidates(rest0).models);
+  const rest = rest0.filter((m) => keep.has(m) || already.has(m));
+  if (rest.length === 0) return [];
+  console.log(dim(`   Also offer these in /model?  (up to ${MAX_ALT_CODERS})`));
+  console.log(dim(`   ${PICK_MANY_HINT}`));
   const ticks = await pickManyFromList(
     rest,
     rest.map((m, i) => (already.has(m) ? i : -1)).filter((i) => i >= 0),
@@ -6327,11 +6338,11 @@ async function chooseCodingModelFrom(ps, all, question, current, { back = false
     // Opens on the CURRENT model where there is one — a long list that opens at the top tells the
     // reader nothing about which one they are already using.
     const at = typeof current === "string" ? list.indexOf(current) : Number(current) || 0;
-    console.log(
-      dim(`  ${question}  (${PICK_HINT})`) +
-        (showingAll || !filtered ? "" : dim(`  ·  ${filtered} non-coding models hidden`))
-    );
-    const idx = await pickFromList(rows, at >= 0 ? at : 0, { back });
+    // A HEADER, not a printed line (GH #397): erased with the list, so a finished pick leaves
+    // "→ model" behind instead of a question nobody is being asked any more.
+    const head = [dim(`   ${question}  (${PICK_HINT})`)];
+    if (!showingAll && filtered) head.push(dim(`   ${filtered} non-coding models hidden — "show all" is the last row`));
+    const idx = await pickFromList(rows, at >= 0 ? at : 0, { back, header: () => head, headerRows: head.length });
     if (idx === PICK_BACK) return BACK;
     if (idx < 0) return null;
     if (idx === list.length) {
@@ -6343,6 +6354,7 @@ async function chooseCodingModelFrom(ps, all, question, current, { back = false
       showingAll = true;
       continue;
     }
+    console.log(dim(`   → ${list[idx]}`));
     return list[idx];
   }
 }
@@ -6363,14 +6375,18 @@ async function chooseCodingModelFrom(ps, all, question, current, { back = false
 async function chooseFromModelList(all, question, current = 0, { back = false } = {}) {
   const rows = [...all, "type a model name…"];
   const at = typeof current === "string" ? all.indexOf(current) : Number(current) || 0;
-  console.log(dim(`   ${question}  (${PICK_HINT})`));
-  const idx = await pickFromList(rows, at >= 0 ? at : 0, { back });
+  const idx = await pickFromList(rows, at >= 0 ? at : 0, {
+    back,
+    header: () => [dim(`   ${question}  (${PICK_HINT})`)],
+    headerRows: 1,
+  });
   if (idx === PICK_BACK) return BACK;
   if (idx < 0) return null;
   if (idx === all.length) {
     const typed = (await ask("   model name: ")).trim();
     return typed || null;
   }
+  console.log(dim(`   → ${all[idx]}`));
   return all[idx];
 }
 
@@ -6399,8 +6415,13 @@ async function manageCodingProviders({ back = false } = {}) {
     );
     const ADD = labels.length;
     labels.push(actionRow("add another provider — Claude API, OpenAI, Kimi…"));
-    console.log(dim(`   Providers — pick one to change it, or add another  (${PICK_HINT}):`));
-    const idx = await pickFromList(labels, selAt, { back });
+    // Headers, not printed lines (GH #397): going one level deeper must not leave the level above
+    // stacked on screen.
+    const idx = await pickFromList(labels, selAt, {
+      back,
+      header: () => [dim(`   Providers — pick one to change it, or add another  (${PICK_HINT}):`)],
+      headerRows: 1,
+    });
     if (idx === PICK_BACK) return BACK;
     if (idx < 0) {
       console.log(dim("   (cancelled)\n"));
@@ -6414,11 +6435,10 @@ async function manageCodingProviders({ back = false } = {}) {
 
     const p = providers[idx];
     for (;;) {
-      console.log("\n" + GUTTER + dim(`${p.host}  ·  ${p.model || "no model set"}`));
       const action = await pickFromList(
         [dim("keep it"), "change the model…", "change the URL…", "remove this provider…"],
         1,
-        { back: true }
+        { back: true, header: () => [GUTTER + dim(`${p.host}  ·  ${p.model || "no model set"}`)], headerRows: 1 }
       );
       if (action === PICK_BACK) break; // → the provider list
       if (action <= 0) {
@@ -6542,7 +6562,7 @@ async function changeProviderModel(ps, rows, p) {
     await syncActiveCoderWhere();
     console.log(GUTTER + dim("this folder's pick named the old model — cleared it."));
   }
-  console.log(accent(` ✓ ${p.host} → ${model}`) + dim("  ·  pick it in /model\n"));
+  console.log(accent(`   ✓ ${p.host} now uses ${model}`) + dim("  ·  /model switches between its models\n"));
 }
 
 /** Point a provider at a different URL, keeping its id so saved picks still resolve. */
@@ -6633,6 +6653,18 @@ async function removeCodingProvider(ps, rows, p) {
     );
     console.log(GUTTER + dim("  they will be deleted too; a key with no provider can never be used again.\n"));
   }
+  // THE AGENT MAY TALK THROUGH THIS PROVIDER TOO (GH #397). Removing the row and its key left
+  // agentModelUrl pointing at it: the banner still named the model, every question failed on a
+  // missing key, and /agent-model probed the URL as an Ollama (…/api/tags → 404). So the agent
+  // model goes with it — said before the question, like the keys.
+  const settings = await fetchWorkerSettings().catch(() => null);
+  const sameUrl = (u) => u && ps.ensureV1Root(String(u)).toLowerCase() === ps.ensureV1Root(String(p.url ?? "")).toLowerCase();
+  const agentUses = sameUrl(settings?.agentModelUrl);
+  if (agentUses) {
+    const name = String(settings.agentModelName || settings.agentModel || "").trim();
+    console.log(GUTTER + orange(`  the agent model uses it too${name ? ` — ${name}` : ""}`));
+    console.log(GUTTER + dim("  it will be unset; pick another with /agent-model.\n"));
+  }
   const yes = await askYesNo(
     `Remove ${p.host} (${p.model || "no model set"})? This cannot be undone.`,
     false
@@ -6644,6 +6676,7 @@ async function removeCodingProvider(ps, rows, p) {
   const saved = await withPendingStatus("removing", () =>
     md.saveWorkerSettings(apiBase, workerKey, {
       agentCodingBackends: ps.removeProvider(rows, p.id),
+      ...(agentUses ? { agentModelUrl: "", agentModelName: "", agentModel: "" } : {}),
     })
   );
   if (!saved) {
@@ -6660,6 +6693,7 @@ async function removeCodingProvider(ps, rows, p) {
       sessionCodingKeyId = "";
       await saveSessionCodingKeyId(resolve(process.cwd()));
     }
+    if (k.id === sessionAgentKeyId) await saveFolderKeyPick("agent", "");
   }
   // This folder may have been pointed at the removed provider.
   if (sessionCodingUrl === p.url || sessionCodingModel.startsWith(`${p.id}::`)) {
@@ -6673,8 +6707,21 @@ async function removeCodingProvider(ps, rows, p) {
   console.log(
     accent(` ✓ removed ${p.host}`) +
       (stranded.length ? dim(`  ·  ${deleted} key${deleted === 1 ? "" : "s"} deleted`) : "") +
+      (agentUses ? dim("  ·  agent model unset") : "") +
       "\n"
   );
+  // The bar named the removed coder (the account default is held in memory): read it back.
+  if (sameUrl(defaultCodingUrl)) {
+    defaultCodingModel = "";
+    defaultCodingUrl = "";
+  }
+  const after = (await fetchAgentPayload([{ role: "user", content: "." }]).catch(() => null))?.payload;
+  if (after) {
+    seedDefaultCoder(after);
+    agentMissing = after.agentMissing === true;
+    noModelAtAll = nothingToAnswerWith(after);
+  }
+  if (barPinned()) paintBar();
 }
 
 /**
@@ -6730,7 +6777,8 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
   const providerPicker = !presetUrl && dialect === "openai";
   const ec = role === "embed" ? await import("./embed-model-command.mjs") : null;
   let target, host, found, need, key, keyName, typedKey, models, model;
-  for (;;) {
+  let lastPick = 0; // GH #397: back from the key re-opens the list ON the provider just chosen
+  providerLoop: for (;;) {
     // --- 1. the server --------------------------------------------------------------------
     target = null;
     // The dialect the URL prompt reads the address in: the caller's, or Ollama's when that row was picked.
@@ -6748,22 +6796,31 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
       const presets = ps.providerPresets(role);
       // #244: an Ollama on this machine or the network is a row here, like the hosted ones — the
       // menus no longer have a separate "use an Ollama server…" entrance. It asks for the address.
-      const OLLAMA_HERE = presets.length;
+      // OLLAMA FIRST (GH #397): first-run setup lists "Ollama server — this machine or your own"
+      // first and these pickers listed it seventh, so the same choice moved between two screens.
+      // gu is local-first; the hosted providers follow in their usual order.
+      const OLLAMA_HERE = 0;
       const rowsShown = [
-        ...presets.map((p) => `${p.name}${dim(`  · ${p.url}`)}`),
         `Ollama — this machine or your network…${dim("  · e.g. 127.0.0.1:11434")}`,
+        ...presets.map((p) => `${p.name}${dim(`  · ${p.url}`)}`),
         "another URL…",
       ];
       // A preset names its own dialect (Ollama cloud is "ollama"); the rest are OpenAI-compatible.
-      console.log(dim(`   Which provider?  (${PICK_HINT})`));
-      const pi = await pickFromList(rowsShown, 0, { back });
+      // The question is the picker's HEADER, erased with it (GH #397): printed above, it stayed in
+      // the history every time "← back" re-opened this list — "Which provider?" stacked up.
+      const pi = await pickFromList(rowsShown, lastPick, { back, header: () => [dim(`   Which provider?  (${PICK_HINT})`)], headerRows: 1 });
       if (pi === PICK_BACK) return BACK;
       if (pi < 0) {
         console.log(dim("   (nothing saved)\n"));
         return;
       }
-      if (pi < presets.length) target = as.serverTarget(presets[pi].dialect ?? "openai", presets[pi].url);
+      lastPick = pi;
+      const preset = pi > OLLAMA_HERE && pi <= presets.length ? presets[pi - 1] : null;
+      if (preset) target = as.serverTarget(preset.dialect ?? "openai", preset.url);
       else if (pi === OLLAMA_HERE) askDialect = "ollama";
+      // SAY WHAT WAS PICKED (GH #397): the list is erased on Enter, and what followed ("… needs an
+      // API key", "key name:") never named the provider — the choice was nowhere on screen.
+      console.log(GUTTER + dim(`→ ${preset ? preset.name : pi === OLLAMA_HERE ? "Ollama" : "another URL"}`));
     }
     if (!target && !presetUrl) {
       const dflt = as.defaultServerUrl(role, askDialect, settings, existing);
@@ -6829,8 +6886,19 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
         if (key) console.log(GUTTER + dim(`using the key "${inUse.name}" already saved for ${host}.`));
       }
     }
-    const askKey = async () => {
-      const t = await askServerKey({ host, optional: need === "optional" });
+    // ESC AT THE KEY GOES BACK ONE STEP (GH #397): with a provider picker behind it, Esc at
+    // "key name:" / "API key:" returns to "Which provider?" — it used to unwind the whole command,
+    // so choosing the wrong provider meant starting /agent-model or /model again. Nothing is saved
+    // before step 5, so going back leaves nothing behind. Without a picker it still cancels.
+    const BACK_TO_PROVIDERS = Symbol("back");
+    const askKey = async ({ again = false } = {}) => {
+      let t;
+      try {
+        t = await askServerKey({ host, optional: need === "optional", escBack: providerPicker, ...(again && typedKey ? { name: keyName } : {}) });
+      } catch (e) {
+        if (wasPromptCancelled(e) && providerPicker) return BACK_TO_PROVIDERS;
+        throw e;
+      }
       key = t.secret;
       keyName = t.name;
       typedKey = Boolean(t.secret);
@@ -6838,7 +6906,9 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
     };
     if (!key && (need !== "none" || newKey)) {
       if (need === "required") console.log(GUTTER + dim(`${host} needs an API key.`));
-      if (!(await askKey())) return;
+      const got = await askKey();
+      if (got === BACK_TO_PROVIDERS) continue providerLoop;
+      if (!got) return;
     }
 
     // --- 3. its models, listed with that key ----------------------------------------------
@@ -6855,10 +6925,18 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
           }
         });
       let probe = await list();
-      // THE STORED KEY WAS REFUSED — ask for the right one once, rather than saving nothing.
-      if ((probe.status === 401 || probe.status === 403) && !typedKey && key) {
-        console.log(yellow(`   ${host} refused the stored key (HTTP ${probe.status}) — enter the right one.`));
-        if (!(await askKey()) || !key) return;
+      // A REFUSED KEY IS ASKED FOR AGAIN, HERE (GH #397). The stored one always was; a TYPED one
+      // ended the command with "check the key and try again" — which meant /model, the provider and
+      // the key name all over again for one mistyped character. Two more tries, then stop.
+      for (let retry = 0; retry < 2 && (probe.status === 401 || probe.status === 403) && key; retry++) {
+        // Two short lines, not one long one: at 80 columns the single sentence wrapped mid-word.
+        console.log(yellow(typedKey
+          ? `   ${host} rejected that key (HTTP ${probe.status}).`
+          : `   ${host} refused the stored key (HTTP ${probe.status}).`));
+        console.log(GUTTER + dim(providerPicker ? "paste the right one — Esc goes back to the providers." : "paste the right one — Esc cancels."));
+        const got = await askKey({ again: true });
+        if (got === BACK_TO_PROVIDERS) continue providerLoop;
+        if (!got || !key) return;
         probe = await list();
       }
       if (probe.status || probe.err) {
@@ -6935,6 +7013,7 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
   }
 
   // --- 5. save: the server, its key, then the role --------------------------------------
+  let alsoInModel = false;
   let rowId = found?.id ?? "";
   let rows = existing;
   // A NEW ROW ONLY WHEN SOMETHING NEEDS ONE: the coder is picked through its row, and a key is
@@ -6961,7 +7040,8 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
       console.log(GUTTER + dim("if this machine's local API is old, restart it with `gu api restart`.\n"));
       return;
     }
-    if (!found && role !== "coding" && as.serverRole(role).rowModel) console.log(GUTTER + dim(`${host} is also offered in /model now.`));
+    // Said AFTER the ✓ (GH #397) — printed here it came before the result it is a footnote to.
+    if (!found && role !== "coding" && as.serverRole(role).rowModel) alsoInModel = true;
   }
   if (typedKey) {
     const id = await withPendingStatus("saving the key", () => addCodingKey(keyName, key, rowId));
@@ -6974,14 +7054,15 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
     // the stored one was refused: it is the server's key from now on, for every role and folder.
     if (found) await setServerDefaultKey(rowId, id);
   }
-  const keyLine = key ? dim(`    API key ${keyName || "saved"} ····${key.slice(-4)}  ·  ${host}'s key`) : "";
+  const keyLine = key ? dim(`   API key ${keyName || "saved"} ····${key.slice(-4)}`) : "";
 
   if (role === "agent") {
     // A MACHINE SETTING, not a folder pick: the agent is what gu talks to in every folder. Saved
     // as URL + NAME, the pair app.ts matches back to the server row to find the key.
-    if (await saveAgentModel(target.roleUrl("agent"), model, host)) {
-      if (keyLine) console.log(keyLine + "\n");
-      console.log(GUTTER + dim("the banner shows the new model next time gu starts.\n"));
+    // ONE BLOCK under the ✓ (GH #397): the key, then the footnotes — not three loose paragraphs.
+    const extra = [keyLine, alsoInModel ? dim(`   ${host} is also offered as a coding model in /model.`) : ""];
+    if (await saveAgentModel(target.roleUrl("agent"), model, host, extra.filter(Boolean))) {
+      /* said */
     } else if (rows !== existing || typedKey) {
       // The SERVER landed — say so, or the user re-enters a key that is already stored.
       console.log(yellow(`   ${host} was saved, but the agent model was not pointed at it.`));
@@ -7175,11 +7256,13 @@ async function chooseModel() {
     // choices while still occupying its URL, so sending this branch straight to the ADD flow
     // would meet "already configured here" and dead-end. The manager fixes such a row, and falls
     // through to add when there is genuinely nothing there.
-    console.log(dim("   No coding model configured."));
+    // As the picker's header (GH #397), so "← back" re-opening this menu does not stack it.
     const go = await pickFromList(
       [dim("leave it"), "add or change a provider — Claude API, OpenAI, Kimi…"],
-      1
+      1,
+      { header: () => [dim("   No coding model configured.")], headerRows: 1 }
     );
+    if (go !== 1) console.log(dim("   No coding model configured."));
     if (go === 1 && (await manageCodingProviders({ back: true })) === BACK) return chooseModel();
     if (go !== 1) console.log("");
     return;
@@ -7233,8 +7316,11 @@ async function chooseModel() {
   // enough in name to have already been mixed up. The fix is to say which one THIS is — not to
   // print the other two here: the agent model and the embedder are independent settings with
   // their own commands, and listing them together implies a relationship that does not exist.
-  console.log(dim(`   Choose the CODING model — the one that writes code  (${PICK_ARROWS}):`));
-  const idx = await pickFromList(labels, activeIdx >= 0 ? activeIdx : 0, { footer: ESC_FOOTER });
+  const idx = await pickFromList(labels, activeIdx >= 0 ? activeIdx : 0, {
+    footer: ESC_FOOTER,
+    header: () => [dim(`   Choose the CODING model — the one that writes code  (${PICK_ARROWS}):`)],
+    headerRows: 1,
+  });
   if (idx < 0) {
     console.log(dim("   (cancelled)\n"));
     return;
@@ -8869,8 +8955,13 @@ async function refreshLogsSize() {
 // What is collected and how it is sent is support-bundle.mjs; this is the terminal half only.
 let supportBusy = false;
 async function runSupport() {
+  // DURING A TURN (GH #382): it used to print one dim line into the turn's output — easy to
+  // miss, then nothing happened, and a stuck turn is exactly when someone wants support. Now it
+  // is QUEUED: the input row says so (with the way out, Ctrl-C) and it opens when the turn ends.
   if (following) {
-    console.log("\n" + GUTTER + dim("A turn is running - /support is available when it finishes (Ctrl-C stops it)."));
+    supportAfterTurn = true;
+    if (barPinned()) paintBar();
+    else console.log("\n" + GUTTER + yellow(SUPPORT_AFTER_TURN_NOTICE.trim()));
     return;
   }
   if (supportBusy || listPickerActive || approvalActive || askWaiting) return;
@@ -9153,7 +9244,14 @@ async function chooseEmbedModel() {
   if (keyRequired) labels.push(actionRow(`API keys for ${host || currentUrl} — switch, add or remove…`));
   const ADD = labels.length;
   labels.push(actionRow("add a provider — OpenAI, Ollama…"));
-  const head = `   Embedding model (now ${current} on ${host || currentUrl})`;
+  // NOTHING SET IS SAID AS NOTHING SET (GH #397). "now nomic-embed-text:latest on 127.0.0.1:11434"
+  // was the DEFAULT, printed as if it were in use — on a Mac with no Ollama, where /doctor said
+  // "embedder (no model) — no server configured" a moment later. The default still drives the
+  // cursor and the "pick another model on …" row; the header only claims what is set.
+  const embedConfigured = isSet || Boolean(String(settings.ragEmbedUrl ?? "").trim());
+  const head = embedConfigured
+    ? `   Embedding model (now ${current} on ${host || currentUrl})`
+    : "   Embedding model — none set up yet, so RAG is off. Pick one";
   const hint = `(${PICK_ARROWS}):`;
   const cols = Math.max(20, process.stdout.columns || 80);
   console.log(dim(head.length + 2 + hint.length < cols ? `${head}  ${hint}` : `${head}\n   ${hint}`));
@@ -9207,7 +9305,7 @@ async function chooseEmbedModel() {
 }
 
 /** Save the agent model on this machine: the URL the API sends turns to, and the model name. */
-async function saveAgentModel(agentUrl, model, host) {
+async function saveAgentModel(agentUrl, model, host, extra = []) {
   const md = await import("./model-doctor.mjs");
   const ok = await withPendingStatus("pointing the agent model at it", () =>
     md.saveWorkerSettings(apiBase, workerKey, { agentModelUrl: agentUrl, agentModelName: model, agentModel: model })
@@ -9218,6 +9316,7 @@ async function saveAgentModel(agentUrl, model, host) {
     return false;
   }
   console.log(accent(` ✓ agent model → ${model}`) + dim(`  · ${host}`));
+  for (const l of extra) console.log(l);
   console.log(dim("   takes effect on your next question.\n"));
   return true;
 }
@@ -9226,7 +9325,9 @@ async function saveAgentModel(agentUrl, model, host) {
  * Ask for a key's NAME — and refuse the key itself as a name: names are printed wherever keys are
  * listed, so a pasted secret there is a secret on screen (reported: "API key sk-E8Iv…  ····3E66").
  */
-async function askKeyName(prompt = "  key name: ") {
+// "(optional)" because nothing said so (GH #397): a bare "key name:" with no default reads as a
+// required field, while Enter has always meant "no name".
+async function askKeyName(prompt = "  key name (optional): ") {
   const am = await import("./agent-model-command.mjs");
   for (let attempt = 0; attempt < 2; attempt++) {
     const name = (await ask(prompt)).trim();
@@ -9247,13 +9348,15 @@ async function askKeyName(prompt = "  key name: ") {
  * "no key" (a local vLLM answers anonymously). `host` names the server in the prompt and decides
  * the shape check's locality: a local server accepts any string, so "abc" is not questioned there.
  */
-async function askServerKey({ host = "", optional = false } = {}) {
+async function askServerKey({ host = "", optional = false, escBack = false, name: knownName = null } = {}) {
   const ps = await import("./coding-provider-setup.mjs");
   // Esc is said here (#249): the prompt that follows is bare text, with nothing on it saying a
   // way out exists — Esc cancels the whole add, nothing saved. (The line explaining what a key
   // name is for was removed on request.)
-  console.log("\n" + GUTTER + dim("Esc to cancel."));
-  const name = (await askKeyName()).trim();
+  // GH #397: where a provider list is behind this prompt, Esc returns to it — and says so.
+  // A RETRY KEEPS THE NAME (GH #397): only the secret was wrong, so only the secret is asked.
+  if (knownName === null) console.log("\n" + GUTTER + dim(escBack ? "Esc goes back to the providers." : "Esc to cancel."));
+  const name = knownName === null ? (await askKeyName()).trim() : String(knownName);
   console.log(GUTTER + dim(SECRET_KEY_HINT));
   const secret = (await askSecret(`   API key${host ? ` for ${host}` : ""}${name ? ` (${name})` : ""}: `)).trim();
   if (!secret) {
@@ -9488,7 +9591,7 @@ async function agentModelOnServer({ back = false, start = "menu" } = {}) {
     const options = am.agentRecoveryOptions({ keyProblem, host: listHost });
     const go = await pickFromList(
       options.map((o, i) => (i === 0 ? dim(o.label) : o.label)),
-      keyProblem ? 1 : 0,
+      am.agentRecoveryDefault(options, { keyProblem, configured: Boolean(url || current) }),
       { back }
     );
     if (go === PICK_BACK) return BACK;
@@ -11148,11 +11251,28 @@ let following = false;
 // typed while the previous one was still queued simply vanished. Now the input row says so the
 // moment a key lands, and keeps saying it until the turn ends. Nothing is queued or sent.
 let typedDuringTurn = false;
+const turnTyping = createTurnTypingDetector(); // what counts as typing during a turn (GH #382)
 const TYPED_DURING_TURN_NOTICE = "(a turn is running — typing is not sent; type it again when it finishes) ";
 const TYPED_DURING_TURN_SHORT = "(turn running — not sent) ";
+// "? support" clicked during a turn (GH #382): it opens when the turn ends; Ctrl-C ends it now.
+let supportAfterTurn = false;
+const SUPPORT_AFTER_TURN_NOTICE = "(support opens when this turn ends — Ctrl-C stops the turn now) ";
+const SUPPORT_AFTER_TURN_SHORT = "(support after this turn — Ctrl-C) ";
+// After the first Ctrl-C the turn is stopping; a worker that never answers needs a second one.
+const SUPPORT_AFTER_STOP_NOTICE = "(support opens when this turn ends — Ctrl-C again to stop waiting) ";
+const SUPPORT_AFTER_STOP_SHORT = "(support after this turn — Ctrl-C again) ";
 /** The notice that fits: the input row must never wrap because of its label (#109/#132). */
 const typedNotice = (width) =>
   visibleLen(TYPED_DURING_TURN_NOTICE) + 12 <= width ? TYPED_DURING_TURN_NOTICE : TYPED_DURING_TURN_SHORT;
+/** What the input row says during a turn instead of ">>", or "" — queued support comes first. */
+const turnRowNotice = (width) =>
+  !following
+    ? ""
+    : supportAfterTurn
+      ? cancelRequested
+        ? visibleLen(SUPPORT_AFTER_STOP_NOTICE) + 12 <= width ? SUPPORT_AFTER_STOP_NOTICE : SUPPORT_AFTER_STOP_SHORT
+        : visibleLen(SUPPORT_AFTER_TURN_NOTICE) + 12 <= width ? SUPPORT_AFTER_TURN_NOTICE : SUPPORT_AFTER_TURN_SHORT
+      : typedDuringTurn ? typedNotice(width) : "";
 // Is the turn we are following one this terminal STARTED, or another terminal's that we merely
 // attached to (task #211)? `attached` is local to runAgentTurn, and onInterrupt — which lives in
 // main() — had no way to ask. So Ctrl+C while watching somebody else's agent took the "cancel my
@@ -12546,6 +12666,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
   following = true;
   followingAttached = attached;
   typedDuringTurn = false;
+  turnTyping.reset();
   compactSeenPasses = 0; // issue #120: python counts passes per turn
   followAborted = false;
   currentJobId = jobId;
@@ -13901,6 +14022,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
     following = false;
     followingAttached = false;
     typedDuringTurn = false;
+    turnTyping.reset();
     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
@@ -14171,7 +14293,12 @@ async function main() {
       // local mongodb is unreachable. Cloud mode failing to reach the hosted API means the
       // computer has lost its internet connection. Two different messages, one per mode.
       dbUnreachable = true;
-      if (isLocalApiBase(apiBase)) {
+      if (isLocalApiBase(apiBase) && (isNetworkError(err) || isTimeout(err))) {
+        // THE API ITSELF IS NOT ANSWERING (GH #397) — MongoDB was not even asked. Blaming the
+        // database here sent the reader to check mongod while it was fine; the message right after
+        // this one names the API and starts it.
+        console.error(dim("(the local API isn't answering — your saved model/key choice is unavailable)"));
+      } else if (isLocalApiBase(apiBase)) {
         console.error(dim("(cannot access local mongodb — your saved model/key choice is unavailable)"));
       } else {
         console.error(dim("(your computer has lost its internet connection — your saved model/key choice is unavailable)"));
@@ -14742,6 +14869,19 @@ async function main() {
         );
       } else {
         const started = await tryStartLocalApi();
+        // CARRY ON INSTEAD OF "run gu again" (GH #397). tryStartLocalApi waited for the API to
+        // answer, so the only thing left is the startup this process already abandoned — and the
+        // simplest correct way to redo it is to BE a fresh gu: execve keeps the pid, the terminal
+        // and the arguments. Where execve is missing (Node < 22.15, Windows) the old sentence stays.
+        // ONCE: an API that answers the health check and then dies would otherwise loop forever.
+        if (started && !process.env.GU_API_REOPENED && typeof process.execve === "function" && process.platform !== "win32" && process.stdin.isTTY) {
+          console.error(dim("   Started it — opening gu…\n"));
+          try {
+            process.execve(process.execPath, [process.execPath, ...process.execArgv, ...process.argv.slice(1)], { ...process.env, GU_API_REOPENED: "1" });
+          } catch {
+            /* not allowed here — fall through to the sentence below */
+          }
+        }
         console.error(
           started
             ? dim("   Started it — run `gu` again.\n")
@@ -14764,6 +14904,7 @@ async function main() {
     }
     process.exit(1);
   }
+  delete process.env.GU_API_REOPENED; // GH #397: started — the next start may re-open again
   console.log(wrapGutter("Ask about this repo. Type / to see commands (Tab completes). Ctrl-C aborts a running turn.", dim) + "\n");
   // #221: gu runs, but its own npm folder is not on PATH (npm skipped the postinstall that adds it).
   try {
@@ -14875,6 +15016,7 @@ async function main() {
         // not just detach. The worker sees the "cancelled" status and kills the Python
         // agent; the poll loop then returns cleanly with the "(cancelled)" note.
         cancelRequested = true;
+        if (supportAfterTurn && barPinned()) paintBar(); // its row now says "Ctrl-C again" (GH #382)
         const jobId = currentJobId;
         // #307: while the question is still held (nothing printed yet), nothing goes to the
         // transcript either — a quick change of mind leaves no trace.
@@ -14981,6 +15123,11 @@ async function main() {
     // the turn ends; a queued line carries no Enter keypress, so its re-prompt overwrites
     // in place (\r + refresh) rather than stacking ">> >> >> " on one row.
     let lineRaw;
+    // "? support" was clicked during the turn that just ended (GH #382) — however it ended.
+    if (supportAfterTurn) {
+      supportAfterTurn = false;
+      _lineQueue.unshift("/support");
+    }
     mainPromptWaiting = true; // a finished background shell may start a recap turn now (#362)
     for (;;) {
       lineRaw = await nextLine();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.895",
+  "version": "1.0.897",
   "description": "gu: the coding agent in your terminal. It reads your repo, makes the change and runs the tests, with your own models (Ollama or any OpenAI-compatible provider). Free installs run entirely on your machine. macOS, Linux and Windows.",
   "keywords": [
     "ai",

package/platform-tools.mjs

@@ -30,8 +30,15 @@ const run = (cmd, args, opts = {}) =>
 
 /* ------------------------------------------------------------------ process listing ----- */
 
-/** The command that lists every process with its full command line. */
-export function processListCommand(platform = process.platform) {
+/**
+ * The command that lists every process with its full command line.
+ *
+ * `ownUser` (GH #396): only THIS user's processes, on macOS and Linux. Another account on the same machine has its
+ * own HOME, worker.env and daemon: counting its gu daemon as "ours is running" meant a second account's daemon
+ * was never started (found on a Mac shared by two accounts: "start it with `gu start`"), and it is not ours to stop.
+ * Windows keeps the full list: a daemon started by a scheduled task runs in a different session than the terminal.
+ */
+export function processListCommand(platform = process.platform, { ownUser = false, uid = process.getuid?.() } = {}) {
   return platform === "win32"
     ? {
         // CIM over WMIC: wmic is deprecated and absent from newer Windows 11 images, and
@@ -43,7 +50,7 @@ export function processListCommand(platform = process.platform) {
           "Get-CimInstance Win32_Process | ForEach-Object { \"$($_.ProcessId) $($_.CommandLine)\" }",
         ],
       }
-    : { cmd: "ps", args: ["-A", "-o", "pid=,command="] };
+    : { cmd: "ps", args: [...(ownUser && Number.isInteger(uid) ? ["-U", String(uid)] : ["-A"]), "-o", "pid=,command="] };
 }
 
 /**

package/terminal-layout.mjs

@@ -434,6 +434,68 @@ export function promptBreakdownRows(b) {
     }));
 }
 
+/**
+ * DID THE USER TYPE DURING THE TURN? (GH #382) — for the "(a turn is running — typing is not
+ * sent …)" notice. A printable key used to be enough, but the terminal also sends text nobody
+ * typed: a mouse report or a cursor-position reply already on its way when Enter started the
+ * turn. On Windows its ESC often comes alone (node gives it up after 500ms) and the rest arrives
+ * as ordinary characters — "[", "^[[", "[12;5R" — which showed the notice with no key pressed.
+ *
+ * A lone Esc, "[" or "^" starts a held run. It stays a reply while the characters fit a mouse
+ * report or cursor reply ("[", "<", "^", digits, ";") and ends silently on its "M", "m" or "R".
+ * Anything else means it was typing after all: `feed` → true. Enter after a held "[" too.
+ * The joined mouse shape never gets here (createMouseKeyWindow); the caller calls `reset()` for
+ * the keys that window takes, which includes the rest of a split report after its "[".
+ */
+export function createTurnTypingDetector({ maxRun = 32 } = {}) {
+  let active = false;
+  let held = "";
+  const reset = () => {
+    active = false;
+    held = "";
+  };
+  return {
+    /** → true when this key shows the user typed. Feed every key of the turn, in order. */
+    feed(ch, key) {
+      if (key?.name === "escape") {
+        active = true;
+        held = "";
+        return false;
+      }
+      if (key && (key.name === "return" || key.name === "enter")) {
+        const typed = active && held !== "";
+        reset();
+        return typed;
+      }
+      const printable =
+        typeof ch === "string" && ch.length > 0 && !/[\x00-\x1f\x7f]/.test(ch) && !key?.ctrl && !key?.meta;
+      if (!printable) {
+        reset();
+        return false;
+      }
+      if (!active) {
+        if (ch === "[" || ch === "^") {
+          active = true;
+          held = ch;
+          return false;
+        }
+        return true;
+      }
+      if (/^[MmR]$/.test(ch) && held.includes("[")) {
+        reset();
+        return false;
+      }
+      if (/^[[<^\d;]$/.test(ch) && held.length < maxRun && (held !== "" || ch === "[" || ch === "^")) {
+        held += ch;
+        return false;
+      }
+      reset();
+      return true;
+    },
+    reset,
+  };
+}
+
 /**
  * A MOUSE REPORT IS NOT TYPING — the window in which keypress events belong to the mouse.
  *
@@ -495,26 +557,50 @@ export function createMouseKeyWindow({ maxRun = 24 } = {}) {
  * "^" is only held while the terminal is reporting the mouse (`plainLeads`), so typing them is
  * not slowed down otherwise.
  */
-const MOUSE_LEADS = ["\x1b[<", "^[[<", "[<"];
 const MOUSE_BODY_DONE = /^(\d+;\d+;\d+[Mm])$/;
 const MOUSE_BODY_PART = /^\d*(?:;\d*){0,2}$/;
+// Windows "win32-input-mode" key records: ESC [ Vk ; Sc ; Uc ; Kd ; Cs ; Rc _ (six numbers).
+const WIN32_BODY_DONE = /^\d+(?:;\d+){5}_$/;
+const WIN32_BODY_PART = /^\d*(?:;\d*){0,5}$/;
+/**
+ * What `text` (the held keys, ESC written as "\x1b") is so far. Leads: a real ESC, ESC spelled
+ * "^[", or no ESC at all. The last two only while the mouse is reported (`plainLeads`), and a
+ * bare "[" only for a MOUSE report: "[I" or "[1;2" are things people type.
+ *   done + report "35;114;22M"  a mouse report
+ *   done + report null          a terminal message with nothing to do: focus in/out ("I"/"O",
+ *                               sent when the window is minimised and restored — GH #365) or a
+ *                               win32 key record the console let through
+ */
 function mouseTextVerdict(text, plainLeads) {
-  for (const lead of MOUSE_LEADS) {
-    if (!plainLeads && lead !== "\x1b[<") continue;
+  for (const lead of ["\x1b[", "^[[", "["]) {
+    if (!plainLeads && lead !== "\x1b[") continue;
     if (lead.startsWith(text)) return { kind: "partial" };
     if (!text.startsWith(lead)) continue;
     const body = text.slice(lead.length);
-    if (MOUSE_BODY_DONE.test(body)) return { kind: "done", report: body };
-    if (body.length <= 20 && MOUSE_BODY_PART.test(body)) return { kind: "partial" };
+    if (body.startsWith("<")) {
+      const m = body.slice(1);
+      if (MOUSE_BODY_DONE.test(m)) return { kind: "done", report: m };
+      if (m.length <= 20 && MOUSE_BODY_PART.test(m)) return { kind: "partial" };
+      continue;
+    }
+    if (lead === "[") {
+      if (body === "") return { kind: "partial" };
+      continue;
+    }
+    if (body === "I" || body === "O" || WIN32_BODY_DONE.test(body)) return { kind: "done", report: null };
+    if (body.length <= 40 && WIN32_BODY_PART.test(body)) return { kind: "partial" };
   }
   return { kind: "bad" };
 }
 export function createMouseReportReader() {
   let held = null; // [str, key] pairs
+  // A CSI node could not name ("\x1b[I", or "\x1b[17;29" with the rest still to come) is held
+  // by its sequence; a named one (an arrow, F3, Ctrl+Up) is a key and never starts a report.
+  const unnamedCsi = (key) => key?.name === "undefined" && /^\x1b\[/.test(key?.sequence ?? "");
   const textOf = (str, key) =>
-    key?.code === "[<" ? "\x1b[<" : key?.name === "escape" ? "\x1b" : typeof str === "string" ? str : "";
+    key?.code === "[<" ? "\x1b[<" : unnamedCsi(key) ? key.sequence : key?.name === "escape" ? "\x1b" : typeof str === "string" ? str : "";
   const startsOne = (str, key, plainLeads) =>
-    key?.code === "[<" || key?.name === "escape" || (plainLeads && (str === "[" || str === "^"));
+    key?.code === "[<" || unnamedCsi(key) || key?.name === "escape" || (plainLeads && (str === "[" || str === "^"));
   return {
     holding: () => held !== null,
     /**
@@ -533,6 +619,8 @@ export function createMouseReportReader() {
         const v = mouseTextVerdict(textOf(str, key), plainLeads);
         if (v.kind === "partial") return { action: "hold" };
         held = null;
+        // Whole in one key ("\x1b[O"): node would drop it anyway, but it is ours to drop.
+        if (v.kind === "done") return { action: "consume", report: v.report };
         return { action: "pass" };
       }
       held.push([str, key]);
@@ -564,7 +652,9 @@ export function createMouseReportReader() {
 
 /** Last line of defence at submit: a report that got past every reader is not a question. */
 export function stripLeakedMouseReports(line) {
-  return String(line).replace(/(?:\x1b|\^\[)?\[<\d+;\d+;\d+[Mm]/g, "");
+  return String(line)
+    .replace(/(?:\x1b|\^\[)?\[<\d+;\d+;\d+[Mm]/g, "")
+    .replace(/(?:\x1b|\^\[)\[(?:[IO]|\d+(?:;\d+){5}_)/g, "");
 }
 
 /**