@tiens.nguyen/gu-cli 1.0.894 → 1.0.896

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-deps-preflight.mjs

@@ -14,6 +14,9 @@ import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 
+// Warnings are yellow text, no icon (GH #378: "⚠" draws as a broken emoji on Windows 11).
+const yellow = (s) => (process.stdout.isTTY && !process.env.NO_COLOR ? `\x1b[33m${s}\x1b[0m` : String(s));
+
 export const DECLINED_FILE = join(homedir(), ".gonext", "agent-deps-declined");
 
 /** Is this start one that should check? Interactive terminals only, and not when a test or script opts out. Pure. */
@@ -74,13 +77,13 @@ export async function agentDepsPreflight({
     const out = await install();
     const ok = out && (out.agentLibs === "installed" || out.agentLibs === "present");
     if (!ok) {
-      log("  ⚠ the agent framework did not install — run `gu-cli deps` to see why. Starting gu anyway.");
+      log(yellow("  the agent framework did not install — run `gu-cli deps` to see why. Starting gu anyway."));
       return "failed";
     }
     log("  ✓ the agent framework is installed.\n");
     return "installed";
   } catch (e) {
-    log(`  ⚠ ${e instanceof Error ? e.message : e}\n  Starting gu anyway — run \`gu-cli deps\` to retry.`);
+    log(yellow(`  ${e instanceof Error ? e.message : e}`) + `\n  Starting gu anyway — run \`gu-cli deps\` to retry.`);
     return "failed";
   }
 }

package/browser-command.mjs

@@ -140,36 +140,46 @@ export function allowIn(folder, allow = true) {
   writeFileSync(allowPath(), JSON.stringify({ folders }, null, 2));
 }
 
+/**
+ * WHICH LINES ARE WARNINGS, without an icon to say so (GH #378 — "⚠" draws broken on Windows 11).
+ * The report stays a plain string array; `.warnings` is the set of its lines the caller paints
+ * yellow.
+ */
+function withWarnings(lines, firstN = 0, extra = []) {
+  lines.warnings = new Set([...lines.slice(0, firstN), ...extra]);
+  return lines;
+}
+
 export function browserReport({ connected, version, installType, refused = [], running = true, error = "" }, { allowed = false, storeUrl = STORE_URL, storeInstalled = false } = {}) {
   // The bridge itself would not start (#170): that is gu's fault, and says so — not "nothing to install".
   if (!running && error) {
-    return [
-      `⚠ gu's browser bridge did not start: ${error}`,
-      "⚠ This is a problem in gu, not in Chrome — no browser needs installing.",
+    return withWarnings([
+      `gu's browser bridge did not start: ${error}`,
+      "This is a problem in gu, not in Chrome — no browser needs installing.",
       "Update gu: npm install -g @tiens.nguyen/gu-cli@latest — then restart gu.",
       "The bridge's log: ~/.gonext/browser-bridge.log",
-    ];
+    ], 2);
   }
   // Two copies installed (the store one next to a developer one): the bridge kept one (#148).
   const twoCopies = refused.length
-    ? [`⚠ A second gu extension (${refused.map((r) => r.id).join(", ")}) tried to connect and was`,
-      "⚠ turned away — two copies are installed. Keep one: /browser cleanup removes",
-      "⚠ the developer (unpacked) copy."]
+    ? [`A second gu extension (${refused.map((r) => r.id).join(", ")}) tried to connect and was`,
+      "turned away — two copies are installed. Keep one: /browser cleanup removes",
+      "the developer (unpacked) copy."]
     : [];
   const here = allowed
     ? "In this folder it may, without asking (/browser forget to undo)."
     : "In this folder it asks first (/browser allow to stop asking).";
   if (connected) {
     const kind = installType === "development" ? ", developer — loaded unpacked" : installType === "normal" ? ", Chrome Web Store" : "";
-    return [
+    return withWarnings([
       `✓ The gu Chrome extension is connected (v${version}${kind}).`,
       "The agent uses your Chrome, in its own tabs (the \"gu\" tab group) and tabs",
       "you share from the extension's icon → Let gu use this tab.",
       here,
       ...twoCopies,
-    ];
+    ], 0, twoCopies);
   }
-  return [
+  return withWarnings([
     "Nothing to install. When the agent needs a browser it asks you first, then",
     "opens gu's own Chrome window (a separate profile — not signed in to your",
     "accounts) and works in it with a real mouse and keyboard.",
@@ -184,7 +194,7 @@ export function browserReport({ connected, version, installType, refused = [], r
         : ["To let it use YOUR Chrome (your logins, a tab you share): /browser install"]),
     here,
     ...twoCopies,
-  ];
+  ], 0, twoCopies);
 }
 
 // /browser install — the extension, for the user's own Chrome. The store page when there is one;

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/client-expert-run.mjs

@@ -839,7 +839,7 @@ export async function askMongoCredentials(ask, askSecret = null) {
       return { uri, custom: true };
     }
     if (verdict.unverifiable) {
-      console.log("\n  " + yellow("⚠ could not verify: ") + dim(verdict.why));
+      console.log("\n  " + yellow("could not verify: ") + dim(verdict.why));
       if (await readYesNo(ask, "  Continue with these credentials anyway? [Y/n]: ", true)) {
         return { uri, custom: true, unverified: true };
       }
@@ -1425,7 +1425,7 @@ export async function runClientExpertSetup({
     }
   } catch (e) {
     // Non-fatal, but say so: a stale daemon is the difference between "set up" and "works".
-    console.log("\n  " + yellow("⚠ could not restart the background worker: ") + e.message);
+    console.log("\n  " + yellow("could not restart the background worker: ") + e.message);
     console.log(dim("  Run `gu-cli restart` — until you do, turns will be enqueued but"));
     console.log(dim("  never picked up, because the running worker is still polling the old API.\n"));
   }
@@ -1570,7 +1570,7 @@ export async function runClientExpertSetup({
       for (const r of await saveSetupKeys({ workerKey: creds.workerKey, models: chosenModels })) {
         console.log(r.ok
           ? "  " + cyan("✓ API key stored") + dim(` for ${r.host} — the server's default key`)
-          : "  " + yellow("⚠ could not store the key") + dim(` for ${r.host} — add it in /model with ctrl+k`));
+          : "  " + yellow("could not store the key") + dim(` for ${r.host} — add it in /model with ctrl+k`));
       }
     }
     if (skipModels) {
@@ -1614,7 +1614,7 @@ export async function runClientExpertSetup({
   } catch (e) {
     // NOT fatal: everything else works, and the model can be set from the terminal. But say so
     // clearly, because the symptom otherwise is the terminal refusing to start.
-    console.log("\n  " + yellow("⚠ could not seed the model settings: ") + e.message);
+    console.log("\n  " + yellow("could not seed the model settings: ") + e.message);
     console.log(dim("  The terminal may say no agent model is configured. Set one with `/model`,"));
     console.log(dim("  or run `gu doctor` to set up a local one.\n"));
     state = recordStep(state, "models", "failed", { reason: e.message });

package/embed-model-command.mjs

@@ -220,8 +220,8 @@ export function embedSaveFields({ url, model }) {
 /** The bar's row for a state that is not "on" — "" when RAG is on. One short row (#317). */
 export function embedNotice({ state, model } = {}) {
   if (state === "on") return "";
-  if (state === "off" && model) return `⚠ RAG is switched off — ${model} is set · /embed-model turns it on`;
-  return "⚠ no embed model — RAG is off · /embed-model";
+  if (state === "off" && model) return `RAG is switched off — ${model} is set · /embed-model turns it on`;
+  return "no embed model — RAG is off · /embed-model";
 }
 
 /**
@@ -233,9 +233,9 @@ export function embedNotice({ state, model } = {}) {
  *    a RAG tool, or the user opened /embed-model), then the embed row.
  */
 export function setupNoticeRows({ noModel = false, agentMissing = false, embedMissing = false, embedNeeded = false, embedWhy } = {}) {
-  if (noModel) return ["⚠ coding model not set · /model"];
+  if (noModel) return ["coding model not set · /model"];
   return [
-    ...(agentMissing ? ["⚠ agent model not set — using the coding model · /agent-model"] : []),
-    ...(embedMissing && embedNeeded ? [embedNotice(embedWhy) || "⚠ no embed model — RAG is off · /embed-model"] : []),
+    ...(agentMissing ? ["agent model not set — using the coding model · /agent-model"] : []),
+    ...(embedMissing && embedNeeded ? [embedNotice(embedWhy) || "no embed model — RAG is off · /embed-model"] : []),
   ];
 }

package/gonext_agent_chat.py

@@ -6519,6 +6519,17 @@ def _open_project_text(path: str):
     return open(path, "r", encoding=_sniff_text_encoding(path), errors="replace")
 
 
+def _rag_wanted_name(fn: str) -> bool:
+    """Is a file with this NAME one the project tools read (text type, not a lockfile/minified)? Pure.
+    One rule for the RAG walk and both grep engines, so ripgrep and Python see the same files (#380)."""
+    import os
+    ext = os.path.splitext(fn)[1].lower()
+    base = fn.lower()
+    if ext not in _RAG_TEXT_EXTS and base not in ("dockerfile", "makefile", ".gitignore"):
+        return False
+    return not (base in _RAG_SKIP_FILES or base.endswith(_RAG_SKIP_SUFFIXES))
+
+
 def _rag_iter_text_files(root: str):
     """Yield (abs_path, rel_path, ext) for indexable text files under root."""
     import os
@@ -6529,10 +6540,7 @@ def _rag_iter_text_files(root: str):
         dirnames[:] = [d for d in dirnames if d not in _RAG_SKIP_DIRS]
         for fn in filenames:
             ext = os.path.splitext(fn)[1].lower()
-            base = fn.lower()
-            if ext not in _RAG_TEXT_EXTS and base not in ("dockerfile", "makefile", ".gitignore"):
-                continue
-            if base in _RAG_SKIP_FILES or base.endswith(_RAG_SKIP_SUFFIXES):
+            if not _rag_wanted_name(fn):
                 continue
             abs_path = os.path.join(dirpath, fn)
             try:
@@ -6547,6 +6555,164 @@ def _rag_iter_text_files(root: str):
             yield abs_path, os.path.relpath(abs_path, root).replace(os.sep, "/"), ext
 
 
+# ---- grep: ripgrep when there is one, Python when not (#380) ---------------------------------
+#
+# Claude Code searches with ripgrep on every OS, Windows 11 included (#379). The Python walk below
+# needs nothing installed but decodes every line of every file in Python — slow on a big repo.
+# So grep_repo asks ripgrep first and keeps Python as the fallback. Both must return THE SAME hits:
+# the same files (skip dirs, text types, lockfiles, 2 MB cap — ripgrep's .gitignore handling is
+# OFF, because the Python walk never read .gitignore), the same line format, the same cap, and the
+# same "an invalid regex is searched as plain text". A regex ripgrep cannot run (Python-only
+# syntax such as look-around or back-references) falls back to Python instead of failing.
+
+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
+    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 ""
+    # 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 ""
+
+
+def _grep_hit(path: str, line_no: int, line: str) -> str:
+    """One hit, as both engines print it: ABSOLUTE path (read_file_lines resolves relative paths
+    against the WORKSPACE root, not the search root), line number, the line cut at 200 chars."""
+    return f"{path}:{line_no}: {line.rstrip()[:200]}"
+
+
+def _grep_hit_order(hit: str):
+    """Sort key: path, then line number as a number (so :9 comes before :10)."""
+    m = re.match(r"^(.*?):(\d+): ", hit)
+    return (m.group(1), int(m.group(2))) if m else (hit, 0)
+
+
+def _grep_compile(pattern: str):
+    """→ (compiled regex, literal?). An invalid regex is searched as plain text."""
+    try:
+        return re.compile(pattern), False
+    except re.error:
+        return re.compile(re.escape(pattern)), True
+
+
+def _grep_python(root: str, pattern: str, glob: str = "", limit: int = 100) -> list:
+    import fnmatch
+    import os
+    rx, _ = _grep_compile(pattern)
+    hits = []
+    for abs_path, rel, _ext in _rag_iter_text_files(root):
+        if glob and not fnmatch.fnmatch(os.path.basename(rel), glob) and not fnmatch.fnmatch(rel, glob):
+            continue
+        try:
+            with _open_project_text(abs_path) as fh:
+                for i, line in enumerate(fh, 1):
+                    if rx.search(line):
+                        hits.append(_grep_hit(abs_path, i, line))
+                        if len(hits) >= limit:
+                            return hits
+        except OSError:
+            continue
+    return hits
+
+
+def _grep_rg_args(rg: str, root: str, pattern: str, literal: bool) -> list:
+    """The ripgrep command line that selects the files the Python walk would. Pure."""
+    args = [rg, "--no-config", "--no-ignore", "--hidden", "--no-messages", "--null", "--line-number",
+            "--with-filename", "--no-heading", "--color=never", "--max-filesize", str(_RAG_MAX_FILE_BYTES)]
+    # No --sort: it makes ripgrep single-threaded — measured 12 s instead of 2.3 s over 85 GB of
+    # projects. The hits that come back are sorted instead; past the cap, which 100 is "first
+    # found", as it always was with the Python walk (directory order).
+    if literal:
+        args.append("--fixed-strings")
+    for d in sorted(_RAG_SKIP_DIRS):
+        args += ["--glob", f"!{d}/"]
+    for e in sorted(_RAG_TEXT_EXTS):
+        args += ["--iglob", f"*{e}"]
+    for n in ("dockerfile", "makefile", ".gitignore"):
+        args += ["--iglob", n]
+    return args + ["--regexp", pattern, "--", root]
+
+
+def _grep_rg(rg: str, root: str, pattern: str, glob: str = "", limit: int = 100, timeout: float = 60.0):
+    """→ hits, or None when ripgrep could not do it (missing, crashed, or a regex it does not support)
+    so the caller falls back to Python. The file list is filtered by the SAME rule as the walk."""
+    import fnmatch
+    import os
+    import subprocess
+    import time
+    _rx, literal = _grep_compile(pattern)
+    single_file = os.path.isfile(root)
+    try:
+        proc = subprocess.Popen(_grep_rg_args(rg, root, pattern, literal), stdout=subprocess.PIPE,
+                                stderr=subprocess.PIPE, stdin=subprocess.DEVNULL)
+    except OSError:
+        return None
+    hits = []
+    started = time.monotonic()
+    try:
+        for raw in proc.stdout:
+            name, sep, rest = raw.partition(b"\0")
+            if not sep:
+                continue
+            num, _, text = rest.partition(b":")
+            path = os.path.normpath(name.decode("utf-8", "surrogateescape"))
+            if not single_file:
+                base = os.path.basename(path)
+                if not _rag_wanted_name(base):
+                    continue
+                if glob:
+                    rel = os.path.relpath(path, root).replace(os.sep, "/")
+                    if not fnmatch.fnmatch(base, glob) and not fnmatch.fnmatch(rel, glob):
+                        continue
+            try:
+                line_no = int(num)
+            except ValueError:
+                continue
+            hits.append(_grep_hit(path, line_no, text.decode("utf-8", "replace")))
+            if len(hits) >= limit or time.monotonic() - started > timeout:
+                break
+    finally:
+        if proc.poll() is None:
+            proc.kill()
+        try:
+            err = proc.stderr.read().decode("utf-8", "replace")
+        except Exception:  # noqa: BLE001
+            err = ""
+        proc.wait()
+        proc.stdout.close()
+        proc.stderr.close()
+    # 0 = hits, 1 = none; 2 = an error. Killed on purpose after the cap → keep what we have.
+    if proc.returncode == 2 and not hits:
+        _log(f"grep: ripgrep could not search ({err.strip()[:200]}) — using the Python search")
+        return None
+    return sorted(hits, key=_grep_hit_order)
+
+
+def _grep_search(root: str, pattern: str, glob: str = "", limit: int = 100, env=None):
+    """→ (hits, engine) with engine "ripgrep" or "python"."""
+    rg = _rg_binary(env)
+    if rg:
+        hits = _grep_rg(rg, root, pattern, glob, limit)
+        if hits is not None:
+            return hits, "ripgrep"
+    return _grep_python(root, pattern, glob, limit), "python"
+
+
 def _rag_posix_chunk(c: dict, sep: str = "") -> dict:
     """Move a chunk from an index built with `\\` paths (Windows, before #490) to `/` paths.
 
@@ -15246,33 +15412,9 @@ def run_agent_chat(cfg):
             try:
                 _emit_running("Searching code",
                               _fmt_call("grep_repo", pattern=pattern, path=path, glob=glob))
-                import fnmatch
-                import os
                 root = _rag_read_allowed((path or "").strip() or _default_ws_root())
-                try:
-                    rx = re.compile(pattern)
-                except re.error:
-                    rx = re.compile(re.escape(pattern))
-                hits = []
-                for abs_path, rel, _ext in _rag_iter_text_files(root):
-                    if glob and not fnmatch.fnmatch(os.path.basename(rel), glob) \
-                            and not fnmatch.fnmatch(rel, glob):
-                        continue
-                    try:
-                        with _open_project_text(abs_path) as fh:
-                            for i, line in enumerate(fh, 1):
-                                if rx.search(line):
-                                    # ABSOLUTE path — read_file_lines/read_text_file resolve
-                                    # relative paths against the WORKSPACE root, not this
-                                    # search root, so a path relative to `root` (e.g. when
-                                    # searching a subfolder) would be silently wrong there.
-                                    hits.append(f"{abs_path}:{i}: {line.rstrip()[:200]}")
-                                    if len(hits) >= 100:
-                                        break
-                    except OSError:
-                        continue
-                    if len(hits) >= 100:
-                        break
+                # ripgrep when there is one (as Claude Code does, #379/#380), else the Python walk.
+                hits, _engine = _grep_search(root, pattern, glob, 100)
                 _search_tally_bump("grep", len(hits), pattern)
                 _emit({"type": "step", "text": f"Searching code → {pattern[:60]} ({len(hits)} hits)"})
                 if not hits:
@@ -17060,7 +17202,7 @@ def run_agent_chat(cfg):
         # "the real attempt never got to run" (seen live: workspace summarize request →
         # coding model timed out 3x on a slow/unreachable remote Ollama box → silent
         # fallback claimed "no access to your workspace").
-        note = f"⚠️ I couldn't finish the full investigation ({_clip(str(e), 120)}) — here's what I can say without it:\n\n{fallback}"
+        note = f"I couldn't finish the full investigation ({_clip(str(e), 120)}) — here's what I can say without it:\n\n{fallback}"
         # Append the workspace's ACTUAL top-level contents (computed locally, no model
         # call — see _workspace_overview) so the user sees their files are really there
         # even during a total coding-model outage, instead of trusting a plain-chat

package/gu-cli.mjs

@@ -486,7 +486,7 @@ if (["start", "stop", "status", "logs", "restart"].includes(args[0])) {
       if (!cfg.url) {
         lines.push([`  ${label}`, cfg.model || "(none)", "(not set)", "NOT CONFIGURED"]);
         notes.push(
-          `⚠ EMBEDDING MODEL NOT FOUND — no ${label} is configured, and there is no fallback\n` +
+          `EMBEDDING MODEL NOT FOUND — no ${label} is configured, and there is no fallback\n` +
             "  (chat/code model servers cannot embed). Set the embedding model folder in the web\n" +
             `  app (${tab}), or run \`gu-cli doctor\` to download and start it.`
         );
@@ -508,7 +508,7 @@ if (["start", "stop", "status", "logs", "restart"].includes(args[0])) {
         ]);
         if (!r.reachable) {
           notes.push(
-            `⚠ The ${label} (${tab}) is NOT reachable from this machine:\n` +
+            `The ${label} (${tab}) is NOT reachable from this machine:\n` +
               `  ${cfg.url} — ${r.error}.\n` +
               "  Check the address, the network/tunnel, and that the server is listening on a\n" +
               "  routable interface (127.0.0.1 on another machine is not reachable from here)."
@@ -532,7 +532,7 @@ if (["start", "stop", "status", "logs", "restart"].includes(args[0])) {
       const ours = !clientHere &&
         (cfg.configured === false || cfg.port === md.DEFAULT_CHAT_PORT || cfg.port === md.EMBED_PORT);
       notes.push(
-        `⚠ The ${label} (${tab}) is NOT answering on this machine:\n` +
+        `The ${label} (${tab}) is NOT answering on this machine:\n` +
           `  ${cfg.model ? `${cfg.model} ` : ""}should be at ${cfg.url}, but nothing responded there.\n` +
           (cfg.source.startsWith("not set")
             ? `  Note: no ${label} URL is set, so the agent ${cfg.source.replace("not set — falls back to", "falls back to")}.\n`

package/gu-repl.mjs

@@ -46,6 +46,7 @@ import dotenv from "dotenv";
 import {
   clipVisible,
   createMouseKeyWindow,
+  createTurnTypingDetector,
   promptBreakdownRows,
   promptTotal,
   resumeTask,
@@ -117,6 +118,7 @@ import {
   syncPrevRowsForResize,
   isToolStepSummary,
   bulletKind,
+  stripWarnMark,
   workspaceScopeWarning,
   isLocalApiBase,
   apiVersionSuffix,
@@ -599,6 +601,9 @@ const BULLET_STYLE = {
   // wait for approval — so its text is white. Look-ups and finished commands are activity and go
   // into the dim counted group instead (step-group.mjs); they never reach this style.
   info: { mark: BULLET, markColor: dim, textColor: brightText },
+  // GH #378: a warning is YELLOW TEXT and no icon — "⚠" draws as a broken wide emoji on Windows
+  // 11. The mark slot stays (a space), so the text column does not move.
+  warn: { mark: " ", markColor: (s) => s, textColor: yellow },
 };
 const classifyBullet = (text) => BULLET_STYLE[bulletKind(text)];
 
@@ -3030,7 +3035,7 @@ const footerBuilt = () =>
     modeHint: pasteHint({ images: coderTakesImages() }),
     // Its own row (#54), sized to the window so the fix it names is never the part cut off.
     notice: imageNotice
-      ? orange("⚠ " + fitImageNotice(imageNotice, (process.stdout.columns || 80) - visibleLen(GUTTER) - 1))
+      ? orange(fitImageNotice(imageNotice, (process.stdout.columns || 80) - visibleLen(GUTTER) - 1))
       : stopNotice
         ? dim(clipVisible(stopNotice, (process.stdout.columns || 80) - visibleLen(GUTTER) - 1))
         : "",
@@ -3232,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
@@ -3242,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,
@@ -4738,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 = "";
@@ -4785,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();
       }
@@ -7035,7 +7045,7 @@ async function useCoderInThisFolder({ ps, rows, beforeChoices, url, host, locali
     ])
   );
   if (lost.length) {
-    console.log(yellow(` ⚠ this API dropped ${lost.length === 1 ? "a provider" : `${lost.length} providers`} when saving:`));
+    console.log(yellow(` this API dropped ${lost.length === 1 ? "a provider" : `${lost.length} providers`} when saving:`));
     for (const u of lost) console.log(GUTTER + dim(`    ${u}`));
     if (ps.apiKeysBackendsByKind(after?.codingChoices)) {
       console.log(GUTTER + dim("this API identifies a backend by its KIND, so it holds ONE"));
@@ -8865,8 +8875,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;
@@ -10194,7 +10209,7 @@ async function showBrowser() {
   const st = await bridgeStatus().catch(() => ({ running: false, connected: false }));
   const lines = browserReport(st, { allowed: allowedIn(resolve(process.cwd())) });
   console.log("");
-  for (const [i, l] of lines.entries()) console.log(GUTTER + (i === 0 && st.connected ? accent(l) : l.startsWith("⚠") ? yellow(l) : dim(l)));
+  for (const [i, l] of lines.entries()) console.log(GUTTER + (i === 0 && st.connected ? accent(l) : lines.warnings?.has(l) ? yellow(l) : dim(l)));
   console.log("");
   paintBar();
 }
@@ -11144,11 +11159,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
@@ -11214,7 +11246,7 @@ function drawApprovalOptions(redraw) {
 /** #204: the command block of the open Yes/No prompt — Ctrl+O toggles it (a click does too). */
 let approvalCommandBlock = null;
 /**
- * Print "⚠ Allow running this command?" and the command (#204): every line indented, long lines
+ * Print "Allow running this command?" (yellow, no icon — GH #378) and the command (#204): every line indented, long lines
  * wrapped under that indent instead of at column 0, and a tall command collapsed to its first
  * rows with "click to expand". Registered as a clickable block only when it has two forms and
  * `toggle` is set (a list picker below cannot survive the repaint); otherwise shown whole.
@@ -11223,7 +11255,7 @@ function printApprovalCommand(shown, { toggle = true } = {}) {
   const canToggle = toggle && barPinned();
   const block = { kind: "command", from: 0, to: 0, text: shown, collapsed: canToggle };
   const painted = paintThoughtRows(block, false);
-  process.stdout.write("\n" + markLine(yellow("⚠")) + yellow("Allow running this command?") + "\n" + painted.join("\n") + "\n");
+  process.stdout.write("\n" + markLine(" ") + yellow("Allow running this command?") + "\n" + painted.join("\n") + "\n");
   if (!canToggle || !blockCanToggle(block)) return null;
   block.to = transcript.dropped() + transcript.length() - 2;
   block.from = block.to - painted.length + 1;
@@ -12265,7 +12297,7 @@ function announceScaffold() {
     // ONE yellow line (#222): the steps are the token question's own, behind "?" there.
     console.log(GUTTER + yellow("! " + text));
   } else {
-    console.log(GUTTER + (kind === "ok" ? accent("✓ " + text) : kind === "warn" ? yellow("⚠ " + text) : red("✗ " + text)));
+    console.log(GUTTER + (kind === "ok" ? accent("✓ " + text) : kind === "warn" ? yellow(text) : red("✗ " + text)));
   }
   if (barPinned()) paintBar();
 }
@@ -12528,7 +12560,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
   // warn nobody, which is the bug agent-payload-shape.test.mjs exists to catch.
   if (!skipAsk && codingKeyMissingKnown === true) {
     console.log(
-      GUTTER + orange("⚠ no API key for the coding model") +
+      GUTTER + orange("no API key for the coding model") +
         dim(" — coding is running on your chat model. ctrl+k to set it.\n")
     );
   }
@@ -12542,6 +12574,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;
@@ -13471,15 +13504,18 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
         // hangs in the gutter (markLine); a long bullet wraps with every continuation row
         // re-indented to the SAME gutter, so it shares one text column with the prompt/answer.
         // Paths under this folder are shown relative to it (#326): the folder is on the bar.
-        const stepText = relativizePaths(line.trim(), turnCwd);
+        const rawStep = relativizePaths(line.trim(), turnCwd);
+        // GH #378: the agent's "⚠" marks a warning; it is shown as colour, never as the icon.
+        const stepWarn = bulletKind(rawStep) === "warn";
+        const stepText = stepWarn ? stripWarnMark(rawStep) : rawStep;
         // A LOOK-UP joins the turn's open group — one counted row, a click away from the lines
         // it stands for — instead of printing a line of its own.
-        if (isGroupableStep(stepText, bulletKind(stepText))) {
+        if (!stepWarn && isGroupableStep(stepText, bulletKind(stepText))) {
           addLookupStep(stepText);
           lastWasBlank = false;
           continue;
         }
-        const st = classifyBullet(stepText);
+        const st = stepWarn ? BULLET_STYLE.warn : classifyBullet(stepText);
         // A finished/failed command fits ONE row, trimmed at a word boundary with "…" (task #20).
         const mCmd = /^(Command (?:finished|failed) → )(.+)$/.exec(stepText);
         const shown = mCmd
@@ -13873,7 +13909,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
           localDaemonRunning
             ? GUTTER +
                 dim("waiting for a free slot — the worker is busy with another folder's turn\n")
-            : red("\n⚠ no worker has claimed the job — is `gu-cli` running?\n")
+            : red("\nno worker has claimed the job — is `gu-cli` running?\n")
         );
       }
       await sleep(700);
@@ -13894,6 +13930,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
@@ -14469,7 +14506,7 @@ async function main() {
                 agreed: ["agentLibs"],
               });
               if (depsOut?.python3 === "missing") {
-                console.log(yellow("  ⚠ Without Python the agent cannot answer. Setup goes on, but install Python 3 and run `gu doctor` before your first question.\n"));
+                console.log(yellow("  Without Python the agent cannot answer. Setup goes on, but install Python 3 and run `gu doctor` before your first question.\n"));
               }
               // The worker reads worker.env ONCE at startup, so a daemon that is already
               // running still has the OLD python — the packages would look "not installed"
@@ -14868,6 +14905,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.
@@ -14974,6 +15012,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();
@@ -15015,7 +15058,7 @@ async function main() {
       if (!entries.length) continue;
       shellRecap = true;
       alignOutputToLineStart();
-      console.log("\n" + GUTTER + dim(`⏺ background ${entries.length === 1 ? "shell" : "shells"} finished — ${entries.map((e) => `${e.rec.id} ${shellStatusText(e.st)}`).join(", ")} · gu asks the agent to recap`));
+      console.log("\n" + GUTTER + dim(`background ${entries.length === 1 ? "shell" : "shells"} finished — ${entries.map((e) => `${e.rec.id} ${shellStatusText(e.st)}`).join(", ")} · gu asks the agent to recap`));
       lineRaw = recapQuestion(entries);
     }
     // /resume (#285): show where the last unfinished session stopped; on "yes" the line becomes the

package/model-doctor.mjs

@@ -237,7 +237,7 @@ async function ensureVenv(log) {
   });
   if (made && existsSync(py)) return py;
   // Debian/Ubuntu split venv into its own package, so this is a real and common outcome.
-  log("  ⚠ could not create a virtualenv (on Debian/Ubuntu: sudo apt install python3-venv)");
+  log(yellow("  could not create a virtualenv (on Debian/Ubuntu: sudo apt install python3-venv)"));
   return "";
 }
 
@@ -282,7 +282,7 @@ async function pipInstall(pkgs, log) {
   // (GU_PIP_SYSTEM=1 keeps the old behaviour.)
   if (process.platform === "win32" && process.env.GU_PIP_SYSTEM !== "1") {
     if (await intoVenv()) return;
-    log("  ⚠ could not use a private environment — trying the system Python instead");
+    log(yellow("  could not use a private environment — trying the system Python instead"));
   }
 
   log(`  installing ${pkgs.join(" ")} … (pip, this can take a minute)`);
@@ -327,7 +327,7 @@ export function chatRamWarningLines(repo, totalBytes) {
   const ramGb = Math.round((Number(totalBytes) || 0) / 1024 ** 3);
   const name = String(repo).split("/").pop();
   const out = [
-    yellow(`  ⚠ ${name} needs a Mac with at least ${MIN_CHAT_RAM_GB} GB of RAM to run well.`),
+    yellow(`  ${name} needs a Mac with at least ${MIN_CHAT_RAM_GB} GB of RAM to run well.`),
   ];
   if (ramGb > 0 && ramGb < MIN_CHAT_RAM_GB) {
     out.push(
@@ -1121,7 +1121,7 @@ export async function runDoctor({ apiBase, workerKey, log, confirm, prompt, mode
       // Only a REAL configured name is an expectation. "default_model" is mlx_lm's "whatever I
       // loaded" sentinel, so it agrees with anything by construction.
       if (namesAModel(modelId) && !sameModelName(modelId, served.name)) {
-        log(`  ⚠ your account asks for "${modelId}", but that server is running`);
+        log(yellow(`  your account asks for "${modelId}", but that server is running`));
         log(`    "${served.name}". Stop it and re-run doctor, or change the model in the web app.`);
       }
     } else {
@@ -1132,7 +1132,7 @@ export async function runDoctor({ apiBase, workerKey, log, confirm, prompt, mode
     chat = "already-running";
   } else if (configuredChat && !isLocalModelUrl(chatUrl)) {
     // Configured but REMOTE and not answering — we can't start a model on another machine.
-    log(`  ⚠ your chat model server (${modelRoot(chatUrl)}) isn't answering.`);
+    log(yellow(`  your chat model server (${modelRoot(chatUrl)}) isn't answering.`));
     log("    It's remote, so start it there — this machine can't launch it.");
     chat = "remote";
   } else {
@@ -1142,7 +1142,7 @@ export async function runDoctor({ apiBase, workerKey, log, confirm, prompt, mode
     if (!dirReady && !chatRepo) {
       // A specifically-named, non-default model we don't know how to fetch — DON'T
       // substitute the default. Tell the user how to bring their own (review H2).
-      log(`  ⚠ your account uses the chat model "${modelId}", which isn't the built-in`);
+      log(yellow(`  your account uses the chat model "${modelId}", which isn't the built-in`));
       log(`    default, so I can't auto-download it. Put it at ${dir} (or any dir) and run:`);
       log(`      mlx_lm.server --model <that dir> --port ${chatPort}`);
       chat = "unknown-model";
@@ -1163,7 +1163,7 @@ export async function runDoctor({ apiBase, workerKey, log, confirm, prompt, mode
           await downloadModel({ repo: chatRepo, dir, log });
           dirReady = true;
         } catch (e) {
-          log(`  ⚠ ${e instanceof Error ? e.message : e}`);
+          log(yellow(`  ${e instanceof Error ? e.message : e}`));
           chat = "download-failed";
         }
       }
@@ -1200,7 +1200,7 @@ export async function runDoctor({ apiBase, workerKey, log, confirm, prompt, mode
           log(`    the first answer may take a minute). Watch it: gu-cli logs`);
           chat = "loading";
         } else {
-          log(`  ⚠ ${r.reason}`);
+          log(yellow(`  ${r.reason}`));
           chat = "start-failed";
         }
       }
@@ -1224,12 +1224,12 @@ export async function runDoctor({ apiBase, workerKey, log, confirm, prompt, mode
     if (codeOk) {
       log(`  ✓ code model server is up at ${modelRoot(codeUrl)}.`);
     } else if (codeIsLocal) {
-      log(`  ⚠ local code model server (${modelRoot(codeUrl)}) isn't answering.`);
+      log(yellow(`  local code model server (${modelRoot(codeUrl)}) isn't answering.`));
       if (codeModel) log(`    Start Ollama and pull it:  ollama serve &  ollama pull ${codeModel}`);
     } else {
       // Unreachable AND remote: this machine can't start it, and `ollama pull` is only
       // meaningful if that server is actually Ollama — don't assume it is.
-      log(`  ⚠ your code model (${modelRoot(codeUrl)}) is not reachable from this machine.`);
+      log(yellow(`  your code model (${modelRoot(codeUrl)}) is not reachable from this machine.`));
       log("    It's remote, so start it there / check the network — this machine can't launch it.");
     }
   }
@@ -1369,11 +1369,11 @@ export async function ensureAgentDeps({ log, confirm, modelHost = canHostMlxMode
       const install = installPython ?? (await import("./python-windows.mjs")).installPythonWindows;
       const r = await install({});
       if (r.ok) log("  ✓ Python 3.12 installed");
-      else log(`  ⚠ could not install Python: ${r.error ?? "unknown error"}`);
+      else log(yellow(`  could not install Python: ${r.error ?? "unknown error"}`));
     }
   }
   if (!(await pyHasModule("sys"))) {
-    log(`  ⚠ ${python3Bin()} not found. Install Python 3 — ${pythonInstallHint()} —`);
+    log(yellow(`  ${python3Bin()} not found. Install Python 3 — ${pythonInstallHint()} —`));
     log("    then run `gu-cli doctor` again.");
     out.python3 = "missing";
     return out; // nothing else can be installed without python
@@ -1394,7 +1394,7 @@ export async function ensureAgentDeps({ log, confirm, modelHost = canHostMlxMode
       await pipInstall(pkgs, log);
       out[key] = "installed";
     } catch (e) {
-      log(`  ⚠ ${e instanceof Error ? e.message : e}`);
+      log(yellow(`  ${e instanceof Error ? e.message : e}`));
       out[key] = "failed";
     }
   };
@@ -1425,7 +1425,7 @@ export async function ensureAgentDeps({ log, confirm, modelHost = canHostMlxMode
     "Install the agent framework (smolagents + openai) — required to run the agent?"
   );
   if (out.agentLibs === "skipped" || out.agentLibs === "failed") {
-    log(yellow("  ⚠ Without smolagents + openai the agent can't run — install them before asking a question."));
+    log(yellow("  Without smolagents + openai the agent can't run — install them before asking a question."));
   }
   if (out.agentLibs === "installed") {
     // Make the daemon use the interpreter these packages actually landed in. ONLY after a
@@ -1504,7 +1504,7 @@ export async function ensureRag({
         await pipInstall(["boto3"], log);
         out.boto3 = "installed";
       } catch (e) {
-        log(`  ⚠ ${e instanceof Error ? e.message : e}`);
+        log(yellow(`  ${e instanceof Error ? e.message : e}`));
         out.boto3 = "failed";
       }
     } else out.boto3 = "skipped";
@@ -1538,7 +1538,7 @@ export async function ensureRag({
   // A LOCAL embedder that is down is the opposite case and must still fall through: setting
   // one up is precisely what the doctor is for.
   if (configuredEmbedUrl && !isLocalModelUrl(configuredEmbedUrl)) {
-    log(`  ⚠ your embeddings server (${modelRoot(configuredEmbedUrl)}) is remote and isn't`);
+    log(yellow(`  your embeddings server (${modelRoot(configuredEmbedUrl)}) is remote and isn't`));
     log("    answering. Start it there — this machine can't launch it.");
     log("    Leaving the setting alone — nothing here can serve a remote embedder.");
     out.embed = "remote";
@@ -1570,7 +1570,7 @@ export async function ensureRag({
     log(
       savedToAccount
         ? `  ✓ saved to your account — visible in the web app under Settings → Agent → RAG.`
-        : `  ⚠ couldn't save that path to your account (using it for this machine anyway).`
+        : yellow(`  couldn't save that path to your account (using it for this machine anyway).`)
     );
   }
   const embedDir = configuredDir || EMBED_DIR;
@@ -1589,7 +1589,7 @@ export async function ensureRag({
   // local, so probing embedUrl first let a locally-running server mask a dead remote one
   // and report "already running" for a machine the user can't even reach.
   if (configuredEmbed && !isLocalModelUrl(configuredEmbed)) {
-    log(`  ⚠ your embeddings server (${modelRoot(configuredEmbed)}) is remote and isn't`);
+    log(yellow(`  your embeddings server (${modelRoot(configuredEmbed)}) is remote and isn't`));
     log("    answering. Start it there — this machine can't launch it.");
     out.embed = "remote";
     return out;
@@ -1619,7 +1619,7 @@ export async function ensureRag({
   // don't know what it is — so say what's wrong instead of silently serving a different model.
   if (!(await modelDirReady(embedDir))) {
     if (embedIsCustom) {
-      log(`  ⚠ the embedding model folder you set in the web app doesn't exist here:`);
+      log(yellow(`  the embedding model folder you set in the web app doesn't exist here:`));
       log(`      ${embedDir}`);
       log("    Fix the path in Settings → Agent → RAG, or download the model into it:");
       log(`      hf download <repo> --local-dir ${embedDir}`);
@@ -1636,7 +1636,7 @@ export async function ensureRag({
     try {
       await downloadModel({ repo: EMBED_REPO, dir: embedDir, log });
     } catch (e) {
-      log(`  ⚠ ${e instanceof Error ? e.message : e}`);
+      log(yellow(`  ${e instanceof Error ? e.message : e}`));
       out.embed = "download-failed";
       return out;
     }
@@ -1657,7 +1657,7 @@ export async function ensureRag({
     log(`  … ${modelDisplayName(embedDir)} is loading in the background on port ${embedPort}.`);
     out.embed = "loading";
   } else {
-    log(`  ⚠ ${r.reason}`);
+    log(yellow(`  ${r.reason}`));
     out.embed = "start-failed";
   }
   return out;

package/model-fallback.mjs

@@ -67,7 +67,7 @@ function parts(fb, { fromMax = Infinity, toMax = Infinity } = {}) {
 }
 
 const join = ({ subject, verb, outcome }, reason) =>
-  `⚠ ${subject} ${verb}${reason ? ` (${reason})` : ""} — ${outcome}`;
+  `${subject} ${verb}${reason ? ` (${reason})` : ""} — ${outcome}`;
 
 /**
  * The bar's row for a fallback, FITTED to `width` columns (after the gutter): every bar row must
@@ -109,11 +109,11 @@ export function fallbackHistoryLine(fb) {
 export function keyMissingNotice({ coder = "", width = 80, gutter = "   " } = {}) {
   const room = Math.max(20, (width || 80) - 1 - gutter.length);
   const tail = " — coding with the chat model · ctrl+k";
-  const named = `⚠ no API key for coder ${text(coder)}${tail}`;
+  const named = `no API key for coder ${text(coder)}${tail}`;
   if (text(coder) && named.length <= room) return named;
-  const plain = `⚠ no API key for the coding model${tail}`;
+  const plain = `no API key for the coding model${tail}`;
   if (plain.length <= room) return plain;
-  return clipName("⚠ no coder API key — on the chat model · ctrl+k", room);
+  return clipName("no coder API key — on the chat model · ctrl+k", room);
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.894",
+  "version": "1.0.896",
   "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/preset-apply.mjs

@@ -86,7 +86,7 @@ export async function applyTransfer(value, { api, io, fromLine = "", carriesSecr
     : plan.lines;
   for (const l of lines) say(l);
   if (summary && plan.replaces) say(`replaces the ${plan.replaces} coding provider${plan.replaces === 1 ? "" : "s"} on this account.`);
-  for (const w of new Set(warnings)) say("⚠ " + w, "warn");
+  for (const w of new Set(warnings)) say(w, "warn");
   if (carriesSecrets) say("this file contains API keys in plain text — delete it when you are done.", "warn");
   const go = String((await io.ask("apply this? [y/N] ")) ?? "").trim().toLowerCase();
   if (go !== "y" && go !== "yes") {

package/quick-models.mjs

@@ -55,9 +55,9 @@ export function quickWarning(quick, activeId, { width = 80, gutter = "   " } = {
   const q = normalizeQuick(quick);
   if (q.length === 0 || isQuickActive(q, activeId)) return "";
   const full = q.length === QUICK_MAX
-    ? `⚠ not on a quick model — ← → goes to ${q[0].model} · /quick-models`
-    : "⚠ not on your quick model · pick 2 with /quick-models to use ← →";
-  const short = "⚠ not on a quick model · /quick-models";
+    ? `not on a quick model — ← → goes to ${q[0].model} · /quick-models`
+    : "not on your quick model · pick 2 with /quick-models to use ← →";
+  const short = "not on a quick model · /quick-models";
   const room = Math.max(8, (width || 80) - 1 - gutter.length);
   const pick = full.length <= room ? full : short;
   return pick.length <= room ? pick : pick.slice(0, Math.max(1, room - 1)) + "…";

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.
  *
@@ -1253,6 +1315,16 @@ export function syncPrevRowsForResize(rl) {
 // signature — a tool's own line never contains it.
 export const isToolStepSummary = (line) => / \| → /.test(line);
 
+/**
+ * A WARNING STEP (GH #378). The agent marks one with a leading "⚠" ("⚠ RAG unavailable …").
+ * The terminal shows it as yellow text with NO icon: Windows 11 terminals draw "⚠" as a wide
+ * colour emoji, which broke the row and looked amateur next to the plain marks. The "⚠" stays
+ * in the protocol (it is how a warning is recognised, and the web app shows it); only the
+ * terminal drops it, here.
+ */
+export const WARN_MARK_RE = /^\s*⚠\uFE0F?\s*/;
+export const stripWarnMark = (text) => String(text ?? "").replace(WARN_MARK_RE, "");
+
 // Glyph vocabulary for an action line: a FAILURE pops (✗, full-bright), a completed
 // action recedes (✓, dim), anything else is neutral (●, dim). Returns the KIND only —
 // the REPL owns the colours, so this stays pure and testable.
@@ -1302,6 +1374,7 @@ export function isSoftFailCommand(cmd) {
 }
 
 export function bulletKind(text) {
+  if (WARN_MARK_RE.test(String(text ?? ""))) return "warn";
   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";
@@ -2826,7 +2899,7 @@ export function identityRow(
   const where = String(folder ?? "").trim();
   // The mark only means anything beside a named coder: with none shown there is nothing for it
   // to be about, and it would read as a fault in the folder.
-  const mark = name && keyUnchosen ? red(" ⚠ key not chosen") : "";
+  const mark = name && keyUnchosen ? red(" key not chosen") : "";
   // API key tail: show the last 4 characters of the API key when available (e.g., "| abcd")
   const keyIndicator = apiKeyTail ? dim(" | ") + dim(apiKeyTail) : "";
   return (name ? orange(name) + mark + keyIndicator + dim(" | ") : "") + cyan(where);

package/theme.mjs

@@ -7,8 +7,13 @@
  *   Windows (win32) with no TERM/COLORTERM/WT_SESSION       -> ask stdout.getColorDepth()
  *     (conhost on Windows 11 supports 24-bit but advertises nothing).
  *
- * Variants: GU_THEME=dark (default) | light | mono.  GU_ASCII=1 swaps the "⏺" glyph for "*"
- * (older Windows console fonts lack U+23FA).
+ * Variants: GU_THEME=dark (default) | light | mono.
+ *
+ * NO ICON BEFORE A CARD (GH #378). The header was "⏺ Update(path)"; Windows 11 terminals draw "⏺"
+ * as a wide colour emoji, which broke the row and looked amateur. The coloured verb — green
+ * Create, yellow Update, red Delete — already says what happened, so the glyph is a space that
+ * keeps the text column, on every platform. ("⏺" is still the line protocol from
+ * gonext_agent_chat.py: it is how a header is RECOGNISED, never what is drawn.)
  *
  * Rules every caller relies on:
  *  - background tiers fill a row by PADDING SPACES (measured with visibleLen), never ESC[K,
@@ -102,7 +107,8 @@ const EMPTY_SIGN = { row: "", sign: "", signOff: "", wordOn: "", wordOff: "" };
 
 /** Every escape sequence the edit card uses, for one tier + variant. "" = nothing to emit. */
 export function makeTheme(tier = "16", variant = "dark", { ascii = false, syntax = false } = {}) {
-  const glyph = ascii ? "*" : "⏺";
+  void ascii; // GU_ASCII used to swap "⏺" for "*"; nothing is drawn now (GH #378)
+  const glyph = " ";
   if (tier === "none") {
     return {
       tier, variant, glyph, fill: false, reset: "", lineNo: "", lineNoOff: "", grey: "",