@tiens.nguyen/gu-cli 1.0.893 → 1.0.895

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

@@ -21,7 +21,7 @@ import { join } from "node:path";
 import { promisify } from "node:util";
 import { createHash } from "node:crypto";
 import { localModeNodeProblem } from "./node-version.mjs";
-import { downloadMongodExe, startPortableMongod, portableMongoInstalled, mongoWinPaths, mongodCommandLine, MONGO_WIN_VERSION } from "./mongo-windows.mjs";
+import { downloadMongodExe, startPortableMongod, portableMongoInstalled, mongoWinPaths, mongodCommandLine, MONGO_WIN_VERSION, mongodRuns, isDllNotFoundExit, installVcRuntime, VC_REDIST_URL } from "./mongo-windows.mjs";
 import {
   apiDepsInstalled,
   installApiDeps,
@@ -415,7 +415,7 @@ export function runInTerminal(cmd, { platform = process.platform, spawnFn = spaw
  * administrator prompt. Shown, asked, then done, like the other platforms. If the download fails
  * the winget commands are printed as the way out.
  */
-export async function ensureNativeMongoWindows(ask, mongo, { log = (l) => console.log(l), plan = null, waitFor = null, download = downloadMongodExe, start = startPortableMongod } = {}) {
+export async function ensureNativeMongoWindows(ask, mongo, { log = (l) => console.log(l), plan = null, waitFor = null, download = downloadMongodExe, start = startPortableMongod, runs = mongodRuns, installRuntime = installVcRuntime } = {}) {
   const installing = !mongo.installed;
   const paths = mongoWinPaths();
   const { host, port } = mongoHostPort(LOCAL_MONGO_URI);
@@ -445,6 +445,32 @@ export async function ensureNativeMongoWindows(ask, mongo, { log = (l) => consol
       return { ok: false, explained: true };
     }
   }
+  // A new Windows 11 has no Visual C++ runtime, and mongod.exe then dies at once with 0xC0000135 — started
+  // detached, that shows up only as "not answering". Ask mongod itself first, and say the real reason (GH #363).
+  const probe = await runs(paths);
+  if (!probe.ok && isDllNotFoundExit(probe.code)) {
+    log("\n  " + red("✗ ") + "MongoDB cannot start: this Windows is missing Microsoft's Visual C++ runtime");
+    log(dim("    (mongod.exe stops with 0xC0000135, \"a DLL was not found\"). It is a free Microsoft download, about 25 MB;"));
+    log(dim("    installing it asks for administrator permission once.   " + VC_REDIST_URL));
+    const ok = await readYesNo(ask, "  Install the Visual C++ runtime now? [Y/n]: ", true, log);
+    if (!ok) {
+      log(dim("\n  Not installed — install it from the link above, then run gu again."));
+      return { ok: false, explained: true };
+    }
+    log("\n  " + bold("Installing the Visual C++ runtime"));
+    const vc = await installRuntime({});
+    if (!vc.ok) {
+      log("\n  " + red("✗ ") + `could not install the Visual C++ runtime: ${vc.error ?? "unknown error"}`);
+      log(dim("  Install it yourself from " + VC_REDIST_URL + " , then run gu again."));
+      return { ok: false, explained: true };
+    }
+    log("  " + cyan("✓ Visual C++ runtime installed"));
+    const again = await runs(paths);
+    if (!again.ok) {
+      log("\n  " + red("✗ ") + "mongod.exe still cannot run" + (again.code != null ? ` (exit code ${again.code})` : "") + ". A restart of Windows may be needed; then run gu again.");
+      return { ok: false, explained: true };
+    }
+  }
   let started;
   try {
     started = await start({ port, paths });
@@ -813,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 };
       }
@@ -1399,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"));
   }
@@ -1544,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) {
@@ -1588,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

@@ -2800,7 +2800,7 @@ def _lexical_fallback_search(query: str, files, max_files: int = 8, per_file: in
     total = 0
     for abs_path, _rel in files:
         try:
-            with open(abs_path, "r", encoding="utf-8", errors="replace") as fh:
+            with _open_project_text(abs_path) as fh:
                 found, hits, lines = set(), 0, []
                 for i, line in enumerate(fh, 1):
                     matched = [t for t, rx in rxs if rx.search(line)]
@@ -5798,11 +5798,23 @@ _RAG_TEXT_EXTS = {
     ".html", ".htm", ".css", ".scss", ".sass", ".less", ".xml", ".yaml", ".yml",
     ".toml", ".ini", ".cfg", ".conf", ".env", ".sh", ".bash", ".zsh", ".sql",
     ".graphql", ".proto", ".gradle", ".dockerfile", ".tsv", ".csv",
+    # WINDOWS / .NET (#490). This list is also what grep_repo can SEE, so a file type missing
+    # here is invisible to search and RAG alike — on a Windows project that was the scripts,
+    # the project files and half the UI: a .csproj, a web.config, a .xaml view, a .ps1 build
+    # step could not be found by any tool, and nothing said so.
+    ".ps1", ".psm1", ".psd1", ".bat", ".cmd", ".vb", ".fs", ".fsx", ".razor", ".cshtml",
+    ".vbhtml", ".xaml", ".axaml", ".csproj", ".vbproj", ".fsproj", ".vcxproj", ".sln",
+    ".props", ".targets", ".config", ".resx", ".manifest", ".reg",
+    # Other common source types the list never had.
+    ".dart", ".scala", ".lua", ".pl", ".pm", ".r", ".ex", ".exs", ".erl", ".hs", ".clj",
+    ".m", ".mm", ".tf", ".hcl", ".cmake", ".groovy", ".kts", ".astro", ".prisma",
 }
 _RAG_SKIP_DIRS = {
     "node_modules", ".git", ".svn", ".hg", "__pycache__", ".venv", "venv",
     "dist", "build", ".next", ".nuxt", "out", ".cache", "bin", "obj", ".idea",
     ".gradle", "vendor", "target",
+    # Visual Studio's per-machine cache (IntelliSense DBs, solution state) — never project code.
+    ".vs",
     # ANOTHER AGENT'S SESSION LOG IS NOT PROJECT STATE. Reported live: asked to "continue",
     # the agent listed .claude-memory/, read latest-checkpoint.md, and reasoned from it —
     # "a partial session about d365-sharepoint-upload … 25 edits … resume from memory" — as if
@@ -6480,6 +6492,44 @@ def _rag_unzip(zip_path: str, dest_dir: str = "") -> tuple:
     return dest_dir, names, False
 
 
+def _sniff_text_encoding(path: str) -> str:
+    """The encoding to read a project file with: a BOM decides, else UTF-8.
+
+    WINDOWS WRITES UTF-16 (#490). Windows PowerShell 5.1's `>` and Out-File write UTF-16LE, and
+    some Visual Studio / Notepad files are UTF-16 too. Read as UTF-8, every character carries a
+    NUL after it, so no pattern ever matched and the index embedded noise. UTF-8 WITH a BOM
+    (Visual Studio's default for .cs) read fine except line 1, which began with U+FEFF and so
+    never matched `^using`. Only a BOM is trusted: guessing UTF-16 from NUL counts would also
+    "detect" it in binary files.
+    """
+    try:
+        with open(path, "rb") as fh:
+            head = fh.read(4)
+    except OSError:
+        return "utf-8"
+    if head.startswith(b"\xef\xbb\xbf"):
+        return "utf-8-sig"
+    if head.startswith(b"\xff\xfe") or head.startswith(b"\xfe\xff"):
+        return "utf-16"  # the codec reads the BOM and picks LE/BE
+    return "utf-8"
+
+
+def _open_project_text(path: str):
+    """Open a project file for READING ONLY, in the encoding its BOM names (see above)."""
+    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
@@ -6490,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:
@@ -6501,7 +6548,181 @@ def _rag_iter_text_files(root: str):
                     continue
             except OSError:
                 continue
-            yield abs_path, os.path.relpath(abs_path, root), ext
+            # "/" ON EVERY OS (#490). This is the RAG index's key for the file, and what search
+            # results show. With os.sep it was `src\a.py` on Windows and `src/a.py` elsewhere,
+            # so an index could not be shared between the two, and results printed differently
+            # per machine. Windows accepts "/" in every path the tools take.
+            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
+    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")
+    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.
+
+    In place and without re-embedding: only the file key and the location line at the top of
+    its text change, so an existing Windows index keeps its vectors instead of re-embedding
+    the whole project once. A no-op off Windows, where `\\` can be part of a real file name.
+    """
+    if (sep or os.sep) != "\\":
+        return c
+    f = c.get("file")
+    if isinstance(f, str) and "\\" in f:
+        new = f.replace("\\", "/")
+        t = c.get("text")
+        if isinstance(t, str) and t.startswith(f + ":"):
+            c["text"] = new + t[len(f):]
+        c["file"] = new
+    return c
 
 
 # A line that STARTS a definition — where a chunk should be cut, and what names it. Kept
@@ -8376,6 +8597,30 @@ def _pipe_hidden_failure_note(line: str, ps: bool = False) -> str:
             + ("." if ps else ", or start the line with `set -o pipefail;`."))
 
 
+# A UNIX SEARCH COMMAND IN POWERSHELL (#490). Windows has no grep/rg/xargs, and its `find` is
+# FIND.EXE — a different program that answers `find . -name x` with "Parameter format not
+# correct". The model learned search as a shell habit, so it reaches for these anyway; the
+# error alone sends it to guess at Select-String syntax next. grep_repo / list_dir do the same
+# job inside gu on every OS, so the failure names them.
+_PS_NO_SEARCH_TOOL_RE = re.compile(
+    r"The term '(grep|egrep|fgrep|rg|ag|ack|xargs|locate|fd)' is not recognized"
+    r"|^(FIND): (?:Parameter format not correct|Invalid switch)",
+    re.M | re.I)
+
+
+def _ps_search_tool_hint(out: str) -> str:
+    """A pointer to grep_repo when PowerShell could not run a Unix search command, else ""."""
+    m = _PS_NO_SEARCH_TOOL_RE.search(out or "")
+    if not m:
+        return ""
+    prog = (m.group(1) or m.group(2) or "").lower()
+    what = ("`find` here is Windows' FIND.EXE, not Unix find" if prog == "find"
+            else f"`{prog}` does not exist on Windows")
+    return (f"\n\nNOTE — {what}. Search file CONTENTS with grep_repo(pattern, path, glob) "
+            "and list files with list_dir(path); both run inside gu on every OS. Do not retry "
+            "with Select-String or Get-ChildItem -Recurse.")
+
+
 # THE PROJECT'S OWN TEST COMMANDS (#360 review). The model guessed `python3 -m pytest` in a repo
 # whose package.json says `python3 -m unittest discover tests -v && node --test` — pytest was not
 # even installed. The manifests already say how each part of the project is tested; reading them
@@ -9320,11 +9565,15 @@ def _ws_write_file(path: str, content: str, action: str, backup) -> None:
     import tempfile
     _ws_record_change(action, path, backup)
     target = os.path.realpath(path)
+    # KEEP THE FILE'S ENCODING (#490). Reads decode a BOM'd UTF-8 or UTF-16 file, so an edit
+    # must write it back the same way — a UTF-16 .resx rewritten as UTF-8 is a different file to
+    # Visual Studio, and dropping a BOM shows up as a whole-file diff. No BOM = UTF-8, as before.
+    enc = _sniff_text_encoding(target) if os.path.isfile(target) else "utf-8"
     _STOP["writing"] += 1
     try:
         fd, tmp = tempfile.mkstemp(prefix=".gu-write-", suffix=".tmp", dir=os.path.dirname(target) or ".")
         try:
-            with os.fdopen(fd, "w", encoding="utf-8") as fh:
+            with os.fdopen(fd, "w", encoding=enc) as fh:
                 fh.write(content)
                 fh.flush()
                 os.fsync(fh.fileno())
@@ -9340,7 +9589,7 @@ def _ws_write_file(path: str, content: str, action: str, backup) -> None:
             except PermissionError:
                 if not _IS_WINDOWS:
                     raise
-                with open(target, "w", encoding="utf-8") as fh:
+                with open(target, "w", encoding=enc) as fh:
                     fh.write(content)
                 os.unlink(tmp)
             _agent_created_add(target)
@@ -14480,7 +14729,7 @@ def run_agent_chat(cfg):
                     _emit_read("Reading file", path, "skipped — already read, unchanged")
                     _last_obs["text"] = _rb
                     return _rb
-                with open(rp, "r", encoding="utf-8", errors="replace") as fh:
+                with _open_project_text(rp) as fh:
                     data = fh.read(max(500, min(int(max_chars or 20000), 100000)))
                 out = _ws_cap_obs(data or "(empty file)", cap=_OBS_CAPS["read"])
                 _emit_read("Reading file", path, f"{data.count(chr(10)) + 1} line(s)"
@@ -14546,7 +14795,7 @@ def run_agent_chat(cfg):
             # drop what was deleted. Nothing extra is needed to catch the agent's OWN edits:
             # writing a file changes its mtime.
             import os as _os_idx
-            _prev = _rag_load_all(source_key) if not replaced else []
+            _prev = [_rag_posix_chunk(_c) for _c in (_rag_load_all(source_key) if not replaced else [])]
             _prev_stamp = {}
             for _c in _prev:
                 _st = _c.get("stamp")
@@ -14576,7 +14825,7 @@ def run_agent_chat(cfg):
                     unchanged_files += 1
                     continue
                 try:
-                    with open(abs_path, "r", encoding="utf-8", errors="replace") as fh:
+                    with _open_project_text(abs_path) as fh:
                         text = fh.read()
                 except OSError:
                     skipped += 1
@@ -15156,33 +15405,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(abs_path, "r", encoding="utf-8", errors="replace") 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:
@@ -15220,7 +15445,7 @@ def run_agent_chat(cfg):
                 defs, calls, tests = [], [], []
                 for abs_path, rel, _ext in _rag_iter_text_files(root):
                     try:
-                        with open(abs_path, "r", encoding="utf-8", errors="replace") as fh:
+                        with _open_project_text(abs_path) as fh:
                             text = fh.read()
                     except OSError:
                         continue
@@ -15302,7 +15527,7 @@ def run_agent_chat(cfg):
                                         start_line=int(start_line or 1),
                                         end_line=int(end_line or 0)))
                 rp = _rag_read_allowed((path or "").strip())
-                with open(rp, "r", encoding="utf-8", errors="replace") as fh:
+                with _open_project_text(rp) as fh:
                     lines = fh.readlines()
                 s = max(1, int(start_line or 1))
                 e = int(end_line or 0) or len(lines)
@@ -15350,7 +15575,7 @@ def run_agent_chat(cfg):
                     _last_obs["text"] = msg
                     return msg
                 backup = _ws_snapshot(rp)
-                with open(rp, "r", encoding="utf-8", errors="replace") as fh:
+                with _open_project_text(rp) as fh:
                     lines = fh.readlines()
                 s, e = int(start_line), int(end_line)
                 if not (1 <= s <= e <= len(lines)):
@@ -15403,7 +15628,7 @@ def run_agent_chat(cfg):
                     msg = f"Error: not a file: {path}"
                     _last_obs["text"] = msg
                     return msg
-                with open(rp, "r", encoding="utf-8", errors="replace") as fh:
+                with _open_project_text(rp) as fh:
                     text = fh.read()
                 n = text.count(old_string)
                 if n == 0:
@@ -15964,6 +16189,8 @@ def run_agent_chat(cfg):
                             result += _pipe_hidden_failure_note(_hidden, ps=_ps)
                             _emit({"type": "step", "text":
                                    f"Command failed behind a pipe → {_trim_words(_hidden)}"})
+                        if _ps:
+                            result += _ps_search_tool_hint(out)
                         if rc != 0 and _use_shell and (_PS_QUOTE_ERR_RE if _ps else _SHELL_QUOTE_ERR_RE).search(out or ""):
                             result += _PS_HEREDOC_HINT if _ps else _HEREDOC_HINT
                         # Say where the shell now is, so a next `cd sub` is not done twice (#362).
@@ -16968,7 +17195,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