@tiens.nguyen/gu-cli 1.0.810 → 1.0.812

package/diff-syntax.mjs

@@ -0,0 +1,75 @@
+/**
+ * OPT-IN SYNTAX COLOUR FOR EDIT CARDS (task #30) — enabled only with GU_DIFF_SYNTAX=1, and only
+ * on background tiers (truecolor/256). The 16-colour tier draws whole rows in green/red text,
+ * so token colours there would erase the add/delete signal; NO_COLOR never gets any.
+ *
+ * A deliberately small, SINGLE-LINE tokenizer: diff rows arrive one at a time, so a block
+ * comment or a multi-line string that started on an earlier row is not tracked. That is
+ * accepted: a wrong colour on one row is cheap, a stateful lexer per language is not.
+ *
+ * highlightSyntax(text, lang) -> [[start, end, role]] with role in keyword|string|comment|number.
+ */
+
+const JS_KW = "await break case catch class const continue debugger default delete do else export extends false finally for from function if import in instanceof let new null of return static super switch this throw true try typeof undefined var void while with yield async interface type enum implements private protected public readonly as";
+const PY_KW = "and as assert async await break class continue def del elif else except False finally for from global if import in is lambda None nonlocal not or pass raise return self True try while with yield match case";
+const SH_KW = "if then else elif fi for while until do done case esac in function return local export readonly set unset echo exit source";
+const JSON_KW = "true false null";
+
+const words = (s) => s.split(/\s+/).join("|");
+const NUM = String.raw`\b(?:0[xX][0-9a-fA-F_]+|\d[\d_]*(?:\.\d+)?(?:[eE][+-]?\d+)?)\b`;
+const DQ = String.raw`"(?:[^"\\]|\\.)*"?`;
+const SQ = String.raw`'(?:[^'\\]|\\.)*'?`;
+const BQ = String.raw`\x60(?:[^\x60\\]|\\.)*\x60?`;
+
+// Each grammar: ordered [role, source] pairs, joined into one alternation (earliest match wins,
+// so a "#" inside a string stays part of the string).
+const GRAMMARS = {
+  js: [["comment", String.raw`\/\/.*|\/\*.*?(?:\*\/|$)`], ["string", `${DQ}|${SQ}|${BQ}`], ["number", NUM], ["keyword", String.raw`\b(?:${words(JS_KW)})\b`]],
+  py: [["comment", "#.*"], ["string", `[rRbBfFuU]{0,2}(?:${DQ}|${SQ})`], ["number", NUM], ["keyword", String.raw`\b(?:${words(PY_KW)})\b`]],
+  sh: [["comment", String.raw`(?:^|(?<=\s))#.*`], ["string", `${DQ}|${SQ}`], ["number", NUM], ["keyword", String.raw`\b(?:${words(SH_KW)})\b`]],
+  json: [["string", DQ], ["number", String.raw`-?${NUM}`], ["keyword", String.raw`\b(?:${words(JSON_KW)})\b`]],
+  md: [["keyword", String.raw`^\s{0,3}#{1,6}\s.*`], ["string", String.raw`\x60[^\x60]*\x60?`], ["comment", String.raw`^\s*>.*`]],
+};
+
+const COMPILED = Object.fromEntries(
+  Object.entries(GRAMMARS).map(([lang, g]) => [
+    lang,
+    { roles: g.map(([r]) => r), re: new RegExp(g.map(([, s]) => `(${s})`).join("|"), "g") },
+  ])
+);
+
+const EXT = {
+  js: "js", mjs: "js", cjs: "js", jsx: "js", ts: "js", tsx: "js", mts: "js", cts: "js",
+  py: "py", pyw: "py",
+  json: "json", jsonc: "json",
+  sh: "sh", bash: "sh", zsh: "sh",
+  md: "md", markdown: "md",
+};
+
+/** "src/app.ts" -> "js"; unknown extensions -> null (no syntax colour). */
+export function langFromPath(path) {
+  const m = /\.([A-Za-z0-9]+)\s*$/.exec(String(path ?? "").replace(/\r/g, ""));
+  return m ? EXT[m[1].toLowerCase()] || null : null;
+}
+
+export const MAX_SYNTAX_LINE = 500;
+
+export function highlightSyntax(text, lang) {
+  const g = COMPILED[lang];
+  const s = String(text ?? "");
+  if (!g || !s || s.length > MAX_SYNTAX_LINE) return [];
+  const out = [];
+  g.re.lastIndex = 0;
+  let m;
+  while ((m = g.re.exec(s))) {
+    if (!m[0]) { g.re.lastIndex++; continue; }
+    const k = m.slice(1).findIndex((x) => x !== undefined);
+    out.push([m.index, m.index + m[0].length, g.roles[k]]);
+  }
+  return out;
+}
+
+/** true when the env asks for syntax colour (GU_DIFF_SYNTAX=1|true|yes|on). */
+export function syntaxEnabled(env = process.env) {
+  return /^(1|true|yes|on)$/i.test(String(env.GU_DIFF_SYNTAX ?? "").trim());
+}

package/edit-card-render.mjs

@@ -0,0 +1,334 @@
+/**
+ * EDIT CARD RENDERER (task #29) — pure, no I/O. Turns the line protocol written by
+ * _render_edit_card (gonext_agent_chat.py) into coloured terminal rows:
+ *
+ *   ⏺ Update(src/app.js)                      <- coloured verb, bold path
+ *     └ Replaced lines 98-100 with 3 lines · +3 -3   <- grey summary, green/red counts
+ *        98 - old text                         <- line-number gutter (padded by Python),
+ *        99 + new text                            tinted row background, changed words brighter
+ *       … (+3 more)                            <- grey
+ *
+ * Keep the shapes in sync with _render_edit_card. Robustness rules:
+ *  - a trailing "\r" (Windows CRLF pipes) is ignored, and "\r" inside a row's text (CRLF
+ *    source files) is dropped, so it cannot move the cursor back over the row;
+ *  - the card ENDS on the first line that cannot belong to it: a blank line, a second
+ *    "└" summary, a diff row whose number width differs from the card's, a "-" row after
+ *    "+" rows, or a line number that does not increase. This stops normal output such as
+ *    "    3 + 4 = 7" right after a card being painted as a diff row.
+ */
+import { visibleLen, wrapDiffText } from "./terminal-layout.mjs";
+import { highlightSyntax, langFromPath } from "./diff-syntax.mjs";
+
+export const EDIT_CARD_ACTIONS = ["Update", "Create", "Delete", "Write"];
+const HEADER_RE = /^⏺ (Update|Create|Delete|Write)\((.+)\)/;
+/** "    98 - text": 4-space indent, a (space-padded) line number, the sign, the text. */
+export const EDIT_DIFF_RE = /^(\s{4})( *\d+) ([-+]) (.*)$/;
+const SUMMARY_RE = /^(\s*)└ (.*)$/;
+const MORE_RE = /^\s{4}… /;
+
+// Every CR goes: a trailing one (Windows pipes) and inner ones (CRLF source files) alike —
+// `.` in EDIT_DIFF_RE does not match "\r", and a drawn CR jumps the cursor to column 0.
+const clean = (line) => String(line ?? "").replace(/\r/g, "");
+
+export const isEditCardHeader = (line) => HEADER_RE.test(clean(line));
+export const isEditCardBody = (line) => {
+  const c = clean(line);
+  return SUMMARY_RE.test(c) || EDIT_DIFF_RE.test(c) || MORE_RE.test(c);
+};
+
+// ---------------------------------------------------------------- word-level diff
+
+/** Words, runs of whitespace, and single punctuation marks. */
+export function tokenize(s) {
+  return String(s ?? "").match(/[\p{L}\p{N}_]+|\s+|[^\p{L}\p{N}_\s]/gu) || [];
+}
+
+const MAX_LINE = 500;
+const MAX_CELLS = 40000;
+
+/**
+ * Changed character ranges ([start, end) in JS string indices) of `a` vs `b`, by a token LCS.
+ * Returns null when skipped (lines too long). Returns empty ranges when the two lines share no
+ * real token — highlighting a whole line inside an already-tinted row only adds noise.
+ */
+export function wordDiff(a, b) {
+  a = String(a ?? "");
+  b = String(b ?? "");
+  if (a.length > MAX_LINE || b.length > MAX_LINE) return null;
+  const ta = tokenize(a);
+  const tb = tokenize(b);
+  const n = ta.length;
+  const m = tb.length;
+  if (n * m > MAX_CELLS) return null;
+  const dp = Array.from({ length: n + 1 }, () => new Uint16Array(m + 1));
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) {
+      dp[i][j] = ta[i] === tb[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
+    }
+  }
+  const keepA = new Array(n).fill(false);
+  const keepB = new Array(m).fill(false);
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (ta[i] === tb[j]) { keepA[i] = keepB[j] = true; i++; j++; }
+    else if (dp[i + 1][j] >= dp[i][j + 1]) i++;
+    else j++;
+  }
+  const sharesWord = ta.some((t, k) => keepA[k] && /\S/.test(t));
+  if (!sharesWord) return { a: [], b: [] };
+  return { a: changedRanges(ta, keepA), b: changedRanges(tb, keepB) };
+}
+
+function changedRanges(tokens, keep) {
+  const out = [];
+  let pos = 0;
+  for (let k = 0; k < tokens.length; k++) {
+    const len = tokens[k].length;
+    if (!keep[k]) {
+      const last = out[out.length - 1];
+      if (last && last[1] === pos) last[1] = pos + len;
+      else out.push([pos, pos + len]);
+    }
+    pos += len;
+  }
+  return out;
+}
+
+/**
+ * Word highlights (a BACKGROUND, on/off) and syntax spans (a FOREGROUND per span, [s, e, sgr],
+ * ended with fgOff) over one piece of a row. Both use positions in the row's full text.
+ */
+function styleText(text, offset, ranges, on, off, spans = null, fgOff = "\x1b[39m") {
+  const useWords = !!(ranges && ranges.length && on);
+  const useSyntax = !!(spans && spans.length);
+  if (!useWords && !useSyntax) return text;
+  let out = "";
+  let inWord = false;
+  let curFg = "";
+  for (let k = 0; k < text.length; k++) {
+    const p = offset + k;
+    if (useWords) {
+      const w = ranges.some(([s, e]) => p >= s && p < e);
+      if (w !== inWord) { out += w ? on : off; inWord = w; }
+    }
+    if (useSyntax) {
+      const sp = spans.find(([s, e]) => p >= s && p < e);
+      const f = sp ? sp[2] : "";
+      if (f !== curFg) { out += f || fgOff; curFg = f; }
+    }
+    out += text[k];
+  }
+  if (curFg) out += fgOff;
+  if (inWord) out += off;
+  return out;
+}
+
+// ---------------------------------------------------------------- rows
+
+/**
+ * One diff row → one or more physical rows, none wider than width-1 columns. Continuation
+ * rows hang under the text column; with a background tier every row is padded to width-1
+ * in the row colour and ends with a full reset.
+ */
+export function renderDiffRow(row, { theme, gutter = "", width = 80, words = null, lang = null } = {}) {
+  const t = theme;
+  const W = Math.max(1, Math.floor(width) || 80);
+  const prefixW = visibleLen(gutter) + row.indent.length + row.no.length + 1 + 2;
+  const room = Math.max(2, W - 1 - prefixW);
+  const text = String(row.text ?? "").replace(/\r/g, "").replace(/\t/g, "  ");
+  const pieces = wrapDiffText(text, room);
+  let cursor = 0;
+  const offsets = pieces.map((p) => {
+    const at = p ? text.indexOf(p, cursor) : cursor;
+    const o = at < 0 ? cursor : at;
+    cursor = o + p.length;
+    return o;
+  });
+  const s = row.sign === "+" ? t.add : t.del;
+  // Opt-in syntax colour (task #30): only when the theme carries a syntax palette.
+  const spans = t.syntax && lang
+    ? highlightSyntax(text, lang).map(([a, b, role]) => [a, b, t.syntax[role] || ""]).filter((x) => x[2])
+    : null;
+  return pieces.map((p, k) => {
+    const lead = k === 0 ? `${t.lineNo}${row.no}${t.lineNoOff}` : " ".repeat(row.no.length);
+    const sign = k === 0 ? `${s.sign}${row.sign}${s.signOff}` : " ";
+    const body = styleText(p, offsets[k], words, s.wordOn, s.wordOff, spans, t.fgOff);
+    const pad = t.fill ? " ".repeat(Math.max(0, W - 1 - prefixW - visibleLen(p))) : "";
+    return `${gutter}${row.indent}${lead} ${s.row}${sign} ${body}${pad}${t.reset}`;
+  });
+}
+
+export function renderHeader(action, path, theme) {
+  const t = theme;
+  return `${t.verb[action] || ""}${action}${t.verb[action] ? t.fgOff : ""}(${t.bold}${path}${t.boldOff})`;
+}
+
+/** Cut plain text to `room` visible columns, ending with "…" when it was cut (task #31 / B6). */
+export function fitText(s, room) {
+  s = String(s ?? "");
+  if (visibleLen(s) <= room) return s;
+  if (room <= 1) return room === 1 ? "…" : "";
+  let out = "";
+  for (const ch of s) {
+    if (visibleLen(out + ch) > room - 1) break;
+    out += ch;
+  }
+  return out + "…";
+}
+
+export function renderSummary(line, { theme, gutter = "", width = Infinity } = {}) {
+  const t = theme;
+  const m = SUMMARY_RE.exec(clean(line));
+  if (!m) return gutter + clean(line);
+  const [, lead, body] = m;
+  let main = body;
+  let tail = "";
+  const k = body.lastIndexOf(" · ");
+  if (k >= 0) {
+    const cand = body.slice(k + 3).trim();
+    if (cand && /^(\+\d+)?\s?(-\d+)?$/.test(cand)) { main = body.slice(0, k); tail = cand; }
+  }
+  // Never wider than width-1: shorten the text first, drop the counts only if even they don't fit.
+  const room = Math.floor(width) - 1 - visibleLen(gutter) - lead.length - 2;
+  if (Number.isFinite(room)) {
+    if (tail && room - (3 + tail.length) < 4) tail = "";
+    main = fitText(main, Math.max(1, room - (tail ? 3 + tail.length : 0)));
+  }
+  let out = `${gutter}${lead}${t.grey}└ ${main}${t.fgOff}`;
+  if (tail) {
+    const parts = tail.split(/\s+/).map((p) =>
+      p.startsWith("+") ? `${t.countAdd}${p}${t.fgOff}` : `${t.countDel}${p}${t.fgOff}`
+    );
+    out += `${t.grey} · ${t.fgOff}${parts.join(" ")}`;
+  }
+  return out;
+}
+
+export function renderMore(line, { theme, gutter = "", width = Infinity } = {}) {
+  const room = Math.floor(width) - 1 - visibleLen(gutter);
+  const c = Number.isFinite(room) ? fitText(clean(line), Math.max(1, room)) : clean(line);
+  return `${gutter}${theme.grey}${c}${theme.fgOff}`;
+}
+
+// ---------------------------------------------------------------- streaming state
+
+const MAX_PAIR_RUN = 50;
+
+/**
+ * The card as it streams in, one line at a time. Diff rows are BUFFERED (so each "-" run can
+ * be paired with its "+" run for word highlights) until flush(), the card's end, or the end of
+ * the current chunk — the caller flushes at chunk end, so nothing waits for a newline that is
+ * never coming.
+ */
+export class EditCardStream {
+  constructor({ theme, gutter = "", width = () => 80 } = {}) {
+    this.theme = theme;
+    this.gutter = gutter;
+    this.width = typeof width === "function" ? width : () => width;
+    this.rows = [];
+    this.pending = [];
+    this.lastSign = null;
+    this.lastNo = { "-": -Infinity, "+": -Infinity };
+    this.noWidth = null;
+    this.sawSummary = false;
+    this.sawDiff = false;
+    this.ended = false;
+    this.lang = null; // set by header() from the file extension (syntax colour, task #30)
+  }
+
+  /** The header text after the glyph (coloured verb + bold path). */
+  header(line) {
+    const c = clean(line);
+    const m = HEADER_RE.exec(c);
+    if (m) this.lang = langFromPath(m[2]);
+    return m ? renderHeader(m[1], m[2], this.theme) + c.slice(m[0].length) : c.slice(1).trim();
+  }
+
+  /** true = the line belonged to the card; false = the card has ENDED (render the line normally). */
+  accept(line) {
+    if (this.ended) return false;
+    const c = clean(line);
+    if (SUMMARY_RE.test(c)) {
+      if (this.sawSummary || this.sawDiff) return this.end();
+      this.sawSummary = true;
+      this.rows.push(renderSummary(c, { theme: this.theme, gutter: this.gutter, width: this.width() }));
+      return true;
+    }
+    const m = EDIT_DIFF_RE.exec(c);
+    if (m) {
+      const no = parseInt(m[2], 10);
+      const sign = m[3];
+      if (this.noWidth != null && m[2].length !== this.noWidth) return this.end();
+      if (this.lastSign === "+" && sign === "-") return this.end();
+      if (no <= this.lastNo[sign]) return this.end();
+      this.noWidth = m[2].length;
+      this.lastSign = sign;
+      this.lastNo[sign] = no;
+      this.sawDiff = true;
+      this.pending.push({ kind: "diff", indent: m[1], no: m[2], sign, text: m[4].replace(/\r/g, "") });
+      return true;
+    }
+    if (MORE_RE.test(c) && (this.sawDiff || this.sawSummary)) {
+      this.pending.push({ kind: "more", line: c });
+      return true;
+    }
+    return this.end();
+  }
+
+  end() {
+    this.ended = true;
+    this.flushPending();
+    return false;
+  }
+
+  flushPending() {
+    if (!this.pending.length) return;
+    const dels = this.pending.filter((r) => r.kind === "diff" && r.sign === "-");
+    const adds = this.pending.filter((r) => r.kind === "diff" && r.sign === "+");
+    const words = new Map();
+    if (dels.length && adds.length && dels.length <= MAX_PAIR_RUN && adds.length <= MAX_PAIR_RUN) {
+      for (let i = 0; i < Math.min(dels.length, adds.length); i++) {
+        const d = wordDiff(dels[i].text, adds[i].text);
+        if (d) { words.set(dels[i], d.a); words.set(adds[i], d.b); }
+      }
+    }
+    const opts = { theme: this.theme, gutter: this.gutter, width: this.width(), lang: this.lang };
+    for (const r of this.pending) {
+      if (r.kind === "more") this.rows.push(renderMore(r.line, opts));
+      else this.rows.push(...renderDiffRow(r, { ...opts, words: words.get(r) || null }));
+    }
+    this.pending = [];
+  }
+
+  /** Rows ready to print (buffered diff rows stay buffered). */
+  drain() {
+    const r = this.rows;
+    this.rows = [];
+    return r;
+  }
+
+  /** Everything, including buffered diff rows. */
+  flush() {
+    this.flushPending();
+    return this.drain();
+  }
+}
+
+/**
+ * A whole card → rows (header first). For tests and golden screens; gu-repl streams the same
+ * thing line by line through EditCardStream.
+ */
+export function renderEditCard(lines, { theme, width = 80, gutter = "", glyph = (g) => g } = {}) {
+  const list = Array.isArray(lines) ? lines : String(lines).split("\n");
+  if (!list.length || !isEditCardHeader(list[0])) return list.map(clean);
+  const card = new EditCardStream({ theme, gutter, width });
+  const out = [`${gutter}${glyph(theme.glyph)} ${card.header(list[0])}`];
+  let i = 1;
+  for (; i < list.length; i++) {
+    if (!card.accept(list[i])) break;
+  }
+  out.push(...card.flush());
+  out.push(...list.slice(i).map(clean));
+  return out;
+}

package/gonext_agent_chat.py

@@ -53,6 +53,11 @@ import urllib.error
 for _stream in (sys.stdin, sys.stdout, sys.stderr):
     with contextlib.suppress(Exception):  # already-UTF-8, or replaced by a non-TextIOWrapper
         _stream.reconfigure(encoding="utf-8", errors="replace")
+# Windows: a text stream turns "\n" into "\r\n" on write, and the REPL's line protocols
+# (edit cards, NDJSON) are parsed per "\n" — a stray "\r" broke the diff-row regex (task #29).
+for _stream in (sys.stdout, sys.stderr):
+    with contextlib.suppress(Exception):
+        _stream.reconfigure(newline="\n")
 
 # Capture stdout before anything can redirect it.  _emit() must always write
 # to the real fd-1 so the Node worker's readline loop sees NDJSON even while
@@ -6853,9 +6858,11 @@ def _render_edit_card(action: str, path: str, summary: str,
                       max_removed: int = 8, max_added: int = 12) -> str:
     """Multi-line terminal-friendly summary of a file edit, emitted as ONE step event.
 
-    The line shapes are a small stable protocol the REPL colorizes (bold header,
-    red '-' lines, green '+' lines, dim line numbers) — keep them in sync with the
-    isEditCardHeader/EDIT_DIFF_RE regexes in gu-repl.mjs. The web thinking panel
+    The line shapes are a small stable protocol the REPL colorizes (coloured verb,
+    bold path, green/red tinted rows, grey line numbers) — keep them in sync with
+    isEditCardHeader/EDIT_DIFF_RE in edit-card-render.mjs (task #29). Line numbers are
+    right-aligned to ONE width per card so the sign column lines up; the summary ends
+    with " · +A -R" counts that the REPL colours. The web thinking panel
     shows the same text as-is (the 4-space indent renders as a monospace block in
     markdown), so no web change is needed.
 
@@ -6865,7 +6872,14 @@ def _render_edit_card(action: str, path: str, summary: str,
             19 +     ...new text...
     """
     import os
-    lines = [f"⏺ {action}({os.path.basename(path)})", f"  └ {summary}"]
+    removed = list(removed or [])
+    added = list(added or [])
+    counts = " ".join(c for c in (f"+{len(added)}" if added else "",
+                                  f"-{len(removed)}" if removed else "") if c)
+    head = f"  └ {summary}" + (f" · {counts}" if counts else "")
+    lines = [f"⏺ {action}({os.path.basename(path)})", head]
+    shown = removed[:max_removed] + added[:max_added]
+    width = max((len(str(no)) for no, _ in shown), default=1)
 
     def _fmt(entries, sign, cap):
         out = []
@@ -6878,7 +6892,8 @@ def _render_edit_card(action: str, path: str, summary: str,
             t = txt.rstrip()
             if len(t) > 160:
                 t = t[:159] + "…"
-            out.append(f"    {no} {sign} {t}")
+            t = t.replace("\r", "")  # CRLF sources: a bare CR would jump the cursor
+            out.append(f"    {str(no).rjust(width)} {sign} {t}")
         return out
 
     if removed:
@@ -12789,7 +12804,7 @@ def run_agent_chat(cfg):
                 _RAG_STATE["s"] = "fallback"
             _emit({"type": "step",
                    "text": f"⚠ RAG unavailable ({why}) → falling back to keyword search"})
-            _log(f"RAG fallback: {why} — answering {query[:80]!r} with a lexical search")
+            _log(f"RAG fallback: {why} — answering {_c(query, 80)} with a lexical search")
             try:
                 root = _rag_read_allowed(_default_ws_root())
                 res = _lexical_fallback_search(

package/gu-cli.mjs

@@ -14,6 +14,7 @@
 import { requireSupportedNode } from "./node-version.mjs";
 // The brand accent, shared with the REPL — see accent.mjs.
 import { accent } from "./accent.mjs";
+import { paint } from "./theme.mjs";
 requireSupportedNode();
 import { mkdir, mkdtemp, readFile, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { execFile as execFileCallback, spawn } from "node:child_process";
@@ -1398,8 +1399,8 @@ if (
   // resolver. That precise shape has crashed this CLI before.
   const bold = (t) => `\x1b[1m${t}\x1b[0m`;
   const cyan = (t) => accent(t);
-  const red = (t) => `\x1b[31m${t}\x1b[0m`;
-  const dim = (t) => `\x1b[2m${t}\x1b[0m`;
+  const red = paint(31); // honours NO_COLOR like accent (task #29 B1)
+  const dim = paint(2);
   console.log("\n" + bold("proxy") + dim("  — can this machine route model calls through a proxy?\n"));
   const { ok, checks } = await runProxySelfTest({
     onStep: ({ title, ok: good, detail }) =>
@@ -1429,8 +1430,8 @@ if (args[0] === "rag" && (args.includes("--test") || args[1] === "test")) {
   // crashed this CLI before.
   const bold = (t) => `\x1b[1m${t}\x1b[0m`;
   const cyan = (t) => accent(t);
-  const red = (t) => `\x1b[31m${t}\x1b[0m`;
-  const dim = (t) => `\x1b[2m${t}\x1b[0m`;
+  const red = paint(31); // honours NO_COLOR like accent (task #29 B1)
+  const dim = paint(2);
   console.log("\n" + bold("rag") + dim("  — can this machine embed and retrieve?\n"));
   const { ok, checks } = await runRagSelfTest({
     onStep: ({ title, ok: good, detail }) =>

package/gu-repl.mjs

@@ -175,6 +175,9 @@ import { ACCEPTED_EMBED_MODELS, REQUIRED_AGENT_MODEL, REQUIRED_AGENT_PREFIX } fr
 // plain SGR code: terminals disagree about colour, so accent.mjs picks 24-bit, 256 or the
 // sixteen-colour magenta from what this one actually claims to support.
 import { accent } from "./accent.mjs";
+// Task #29: colour tiers that honour NO_COLOR (paint) and the colourful edit-card renderer.
+import { paint, CARD_THEME } from "./theme.mjs";
+import { EditCardStream, isEditCardHeader } from "./edit-card-render.mjs";
 // Task #240: what a failed agent-payload call means, and when a rejected key may be recovered
 // from in place instead of ending the session.
 import { payloadError, recoveryPlan } from "./credential-recovery.mjs";
@@ -216,10 +219,12 @@ const ENV_FILE = join(homedir(), ".gonext", "worker.env");
 const WS_FILE = join(homedir(), ".gonext", "workspaces.json");
 const SESSIONS_DIR = join(homedir(), ".gonext", "sessions");
 
-const dim = (s) => `\x1b[2m${s}\x1b[0m`;
-const red = (s) => `\x1b[31m${s}\x1b[0m`;
-const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
-const white = (s) => `\x1b[37m${s}\x1b[0m`;
+// Through paint() so NO_COLOR / GU_ACCENT=off / TERM=dumb turn ALL of them off, not only the
+// accent (task #29 bug B1 — red '-' rows stayed red under NO_COLOR).
+const dim = paint(2);
+const red = paint(31);
+const yellow = paint(33);
+const white = paint(37);
 // Left gutter so terminal output doesn't hug the edge (task #128, Phase 1). A terminal has
 // no CSS padding — a "left margin" is just a space prefix on every printed line, applied
 // consistently at the prompt, the ● bullets, plain replies, the banner and the live status
@@ -397,8 +402,8 @@ const LINE_SPACING = "\n";
 const STREAM_PLAIN_REPLY = false;
 // ANSI 90 ("bright black") — a reliable neutral grey across terminal themes, unlike
 // code 34 (blue) which many dark-theme palettes render as purple/indigo instead.
-const codeColor = (s) => `\x1b[90m${s}\x1b[0m`;
-const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const codeColor = paint(90);
+const bold = paint(1);
 // Hover highlight for the clickable thinking line (task #96): just shift the color a little
 // toward white (no bold/underline/anchor) so it subtly signals "hovered" without looking like
 // a link. 97 = bright white.
@@ -434,19 +439,12 @@ const isRoutingLine = (line) =>
   /^(Routing your request…|Choosing a tool…|Composing a reply…|→ Agent mode.*|→ Chat reply)$/.test(
     line.trim()
   );
-// The edit tools (edit_lines/edit_file/create_file) emit a multi-line "edit card"
-// as one step event — a small stable line protocol rendered here as a colored diff
-// (bold header, red '-' / cyan '+' lines, dim line numbers). Shapes must stay in
-// sync with _render_edit_card in gonext_agent_chat.py:
-//   ⏺ Update(XeroForwardService.java)
-//     └ Replaced lines 19-19 with 1 line
-//       19 -     ...old...
-//       19 +     ...new...
-//       … (+3 more)
-const isEditCardHeader = (line) => /^⏺ (Update|Create)\(.+\)/.test(line);
-const EDIT_DIFF_RE = /^(\s{4})(\d+) ([-+]) (.*)$/;
-const isEditCardBody = (line) =>
-  /^\s*└ /.test(line) || EDIT_DIFF_RE.test(line) || /^\s{4}… /.test(line);
+// The edit tools (edit_lines/edit_file/create_file) emit a multi-line "edit card" as one
+// step event — a small stable line protocol written by _render_edit_card in
+// gonext_agent_chat.py and parsed/coloured by edit-card-render.mjs (task #29): coloured
+// verb + bold path, grey summary with green/red counts, a padded grey line-number gutter,
+// green/red tinted rows with brighter changed words (plain green/red text on 16 colours,
+// no colour under NO_COLOR).
 
 /**
  * STILL MODE — no animated status block at all (GONEXT_STILL=1).
@@ -972,7 +970,7 @@ function currentSkills() {
 }
 const skillCommands = () =>
   currentSkills()
-    .filter((s) => s.slash)
+    .filter((s) => s.slash && !s.hidden) // hidden = internal skill: still typeable, not offered (#118)
     .map((s) => ({ name: `/${s.name}`, usage: `/${s.name} [request]`, desc: `skill — ${firstSentence(s.description)}`, skill: true }));
 /** A skill's description is written for the MODEL and often runs a paragraph; /help shows one line. */
 function firstSentence(text, max = 100) {
@@ -7887,14 +7885,15 @@ async function refreshAfterPresetApply(value, codingDefault, result) {
       defaultCodingUrl = codingDefault.url;
     }
     // What the API now answers with is authoritative — read it back rather than assume.
-    const probe = await fetchAgentPayload([{ role: "user", content: "ping" }]).catch(() => null);
-    const p = probe?.payload ?? {};
+    // A mid-session refresh, NOT the startup probe: no sign-in offer here (that is probeWithRecovery's).
+    const refreshed = await fetchAgentPayload([{ role: "user", content: "ping" }]).catch(() => null);
+    const p = refreshed?.payload ?? {};
     seedDefaultCoder(p);
     // codingChoices lives on the envelope, never inside payload.
-    activeCoderWhere = whereOfActiveCoder(probe?.codingChoices, sessionCodingModel);
+    activeCoderWhere = whereOfActiveCoder(refreshed?.codingChoices, sessionCodingModel);
     if (value?.agentModel?.name || p.agentMissing === false) agentMissing = false;
     else if (p.agentMissing === true) agentMissing = true;
-    if (probe?.payload) noModelAtAll = nothingToAnswerWith(p);
+    if (refreshed?.payload) noModelAtAll = nothingToAnswerWith(p);
     await syncEmbedWarning({ repair: true });
     if (barPinned()) paintBar();
   } catch {
@@ -11820,7 +11819,10 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
   // them prints in a distinct grey (not dim, so it stands out from "Thought:" prose);
   // blank lines keep spacing; everything else commits dim to scrollback.
   let inCode = false;
-  let inEditCard = false; // inside a colored edit-card block (see isEditCardHeader)
+  let editCard = null; // the EditCardStream of the card being printed (see isEditCardHeader)
+  const writeCardRows = (rows) => {
+    for (const r of rows) process.stdout.write(r + "\n");
+  };
   // The worker wraps the raw model token stream (Thought prose + code) in ~~~ fences;
   // the concrete ACTION events (tool steps, edit cards) are emitted OUTSIDE them. We
   // suppress everything IN a fence — the rambling Thought and redundant raw code (the
@@ -12037,36 +12039,30 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
       // header is distinctive enough to never collide with generated Python.
       if (isEditCardHeader(line)) {
         onContent();
-        inEditCard = true;
+        if (editCard) writeCardRows(editCard.flush()); // back-to-back cards
+        editCard = new EditCardStream({
+          theme: CARD_THEME,
+          gutter: GUTTER,
+          width: () => Math.max(20, process.stdout.columns || 80),
+        });
         openBullet();
-        process.stdout.write(markLine(accent("⏺")) + bold(line.slice(1).replace(/^\s+/, "")) + "\n");
+        process.stdout.write(markLine(accent(CARD_THEME.glyph)) + editCard.header(line) + "\n");
         lastWasBlank = false;
         lastContentAt = Date.now();
         continue;
       }
-      if (inEditCard) {
-        if (isEditCardBody(line)) {
+      if (editCard) {
+        // Diff rows are buffered inside the card (so a '-' run can be paired with its '+'
+        // run for word highlights) and flushed at the card's end or this chunk's end.
+        if (editCard.accept(line)) {
           onContent();
-          const m = EDIT_DIFF_RE.exec(line);
-          if (m) {
-            // "    19 -  old text" → dim line number, red/cyan signed content.
-            const paintDiff = m[3] === "+" ? accent : red;
-            // Wrap to the terminal width: continuation rows hang under the text column
-            // (no line number, blank sign) instead of soft-wrapping back to column 0.
-            const room = Math.max(8, Math.max(20, process.stdout.columns || 80) - 1 - visibleLen(GUTTER) - m[1].length - m[2].length - 1 - 2);
-            const pieces = wrapDiffText(m[4], room);
-            process.stdout.write(`${GUTTER}${m[1]}${dim(m[2])} ${paintDiff(`${m[3]} ${pieces[0]}`)}\n`);
-            for (const p of pieces.slice(1)) {
-              process.stdout.write(`${GUTTER}${m[1]}${" ".repeat(m[2].length)} ${paintDiff(`  ${p}`)}\n`);
-            }
-          } else {
-            process.stdout.write(GUTTER + dim(line) + "\n"); // "└ summary" / "… (+N more)"
-          }
+          writeCardRows(editCard.drain());
           lastWasBlank = false;
           lastContentAt = Date.now();
           continue;
         }
-        inEditCard = false; // card ended — fall through to normal handling
+        writeCardRows(editCard.flush()); // card ended — fall through to normal handling
+        editCard = null;
       }
       {
         const t = line.trim();
@@ -12212,6 +12208,8 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
       }
       lastWasBlank = false;
     }
+    // A card's buffered diff rows must not wait for a line that may never come.
+    if (editCard) writeCardRows(editCard.flush());
     // Plain-reply answers often have NO internal newline at all (a short one-sentence
     // reply) and can take many seconds to generate — without this, nothing would print
     // until the whole thing finally lands, right back to the "wait then dump" problem

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.810",
+  "version": "1.0.812",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",
@@ -51,6 +51,9 @@
   },
   "files": [
     "accent.mjs",
+    "edit-card-render.mjs",
+    "diff-syntax.mjs",
+    "theme.mjs",
     "gu-cli.mjs",
     "gu-repl.mjs",
     "step-tokens.mjs",

package/skills.mjs

@@ -138,6 +138,12 @@ function scanDir(dir, scope) {
   return { skills, warnings };
 }
 
+/**
+ * Internal skills the agent loads itself through use_skill. They are NOT offered in the `/` menu,
+ * Tab-completion or /help (hidden), but typing /<name> still works (issue #118).
+ */
+export const HIDDEN_SKILLS = ["gu-session-memory-orchestration"];
+
 /**
  * Every skill that exists right now. `reserved` = names that are already commands (/help, /mcp…):
  * the built-in wins, and the skill is still usable by the agent, just not as a slash command —
@@ -161,7 +167,7 @@ export function discoverSkills({ cwd = process.cwd(), home = homedir(), reserved
   const taken = new Set(reserved.map((r) => r.replace(/^\//, "")));
   const skills = [...byName.values()]
     .sort((a, b) => a.name.localeCompare(b.name))
-    .map((s) => ({ ...s, slash: !taken.has(s.name), source: src }));
+    .map((s) => ({ ...s, slash: !taken.has(s.name), hidden: HIDDEN_SKILLS.includes(s.name), source: src }));
   return { skills, warnings: [...user.warnings, ...project.warnings], source: src };
 }
 

package/terminal-viewport.mjs

@@ -594,8 +594,8 @@ export function dragEventKind(btn, press) {
 // 105 is bright magenta, the sixteen-colour palette's purple, following the accent from cyan to
 // indigo when the brand moved (accent.mjs). Still a PALETTE colour, not the exact #a5b4fc: a
 // background inherits the user's theme this way, where a 256-colour or truecolor background would
-// fight every custom scheme and every light terminal — the same argument that kept syntax colour
-// out of the edit cards. The bright variant rather than 45, because black text on a dark magenta
+// fight every custom scheme and every light terminal — the same argument that keeps syntax colour
+// in the edit cards OFF by default (opt-in GU_DIFF_SYNTAX=1, task #30). The bright variant rather than 45, because black text on a dark magenta
 // is where this stops being legible.
 //
 // A BACKGROUND, because the cyan FOREGROUND is already spoken for: the ">> " prompt, where it

package/theme.mjs

@@ -0,0 +1,159 @@
+/**
+ * SEMANTIC TERMINAL COLOURS (task #29) — one place that decides HOW MUCH colour this terminal
+ * gets, and what each role (added row, deleted row, gutter, header verb…) looks like in it.
+ *
+ * Tiers: "truecolor" (24-bit), "256", "16", "none". Detection mirrors accent.mjs, plus:
+ *   NO_COLOR / GU_ACCENT=off / GU_THEME=mono / TERM=dumb   -> "none" (plain text)
+ *   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).
+ *
+ * Rules every caller relies on:
+ *  - background tiers fill a row by PADDING SPACES (measured with visibleLen), never ESC[K,
+ *    which conhost and Windows Terminal treat differently;
+ *  - every row ends with a FULL reset (ESC[0m) so a background never bleeds into the next row;
+ *  - the 16-colour tier uses grey (90) instead of dim (SGR 2), which old conhost ignores.
+ */
+
+const fgRgb = ([r, g, b]) => `\x1b[38;2;${r};${g};${b}m`;
+const bgRgb = ([r, g, b]) => `\x1b[48;2;${r};${g};${b}m`;
+const fg256 = (n) => `\x1b[38;5;${n}m`;
+const bg256 = (n) => `\x1b[48;5;${n}m`;
+
+/** [truecolor rgb, xterm-256 index] per role. */
+export const PALETTE = {
+  dark: {
+    addBg: [[22, 52, 30], 22],
+    addWord: [[38, 100, 52], 28],
+    delBg: [[66, 24, 30], 52],
+    delWord: [[128, 38, 50], 88],
+    addFg: [[110, 220, 130], 114],
+    delFg: [[245, 120, 120], 210],
+    update: [[229, 192, 123], 180],
+    // Syntax roles (task #30, GU_DIFF_SYNTAX=1): foregrounds bright enough on the dark tints.
+    keyword: [[198, 160, 246], 183],
+    string: [[230, 200, 140], 186],
+    comment: [[140, 150, 160], 246],
+    number: [[120, 200, 230], 117],
+  },
+  light: {
+    addBg: [[218, 250, 222], 194],
+    addWord: [[160, 232, 170], 157],
+    delBg: [[255, 226, 226], 224],
+    delWord: [[255, 180, 182], 217],
+    addFg: [[26, 127, 55], 28],
+    delFg: [[190, 30, 40], 124],
+    update: [[154, 103, 0], 136],
+    keyword: [[111, 66, 193], 91],
+    string: [[3, 47, 98], 24],
+    comment: [[106, 115, 125], 243],
+    number: [[0, 92, 197], 26],
+  },
+};
+
+/**
+ * Which colour tier this environment gets. Pure: pass env and (for Windows) the platform and
+ * the stream's colour depth, so every branch is testable on any OS.
+ */
+export function colorTier(env = process.env, { platform = process.platform, colorDepth } = {}) {
+  const pref = String(env.GU_ACCENT ?? "").trim().toLowerCase();
+  if (pref === "off" || pref === "none") return "none";
+  if (env.NO_COLOR != null && String(env.NO_COLOR) !== "") return "none";
+  if (String(env.GU_THEME ?? "").trim().toLowerCase() === "mono") return "none";
+  const term = String(env.TERM ?? "").toLowerCase();
+  if (term === "dumb") return "none";
+  const colorterm = String(env.COLORTERM ?? "").trim().toLowerCase();
+  if (colorterm === "truecolor" || colorterm === "24bit") return "truecolor";
+  if (env.WT_SESSION) return "truecolor";
+  if (/truecolor|direct/.test(term)) return "truecolor";
+  if (term.includes("256color")) return "256";
+  if (platform === "win32" && Number(colorDepth) > 0) {
+    if (colorDepth >= 24) return "truecolor";
+    if (colorDepth >= 8) return "256";
+  }
+  return "16";
+}
+
+/** The colour depth Node reports for stdout — only consulted on Windows. */
+export function stdoutColorDepth() {
+  try {
+    if (process.platform !== "win32") return undefined;
+    return process.stdout?.getColorDepth?.();
+  } catch {
+    return undefined;
+  }
+}
+
+/** Resolved once at module load — the environment cannot change mid-session. */
+export const TIER = colorTier(process.env, { colorDepth: stdoutColorDepth() });
+export const COLOR_ON = TIER !== "none";
+
+/**
+ * A plain SGR helper (`paint(31)("x")`) that honours NO_COLOR & co. Replaces the hard-coded
+ * `\x1b[31m…` helpers, which ignored NO_COLOR while the accent honoured it (task #29 bug B1).
+ */
+export function paint(code, on = COLOR_ON) {
+  return on ? (s) => `\x1b[${code}m${s}\x1b[0m` : (s) => String(s);
+}
+
+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 ? "*" : "⏺";
+  if (tier === "none") {
+    return {
+      tier, variant, glyph, fill: false, reset: "", lineNo: "", lineNoOff: "", grey: "",
+      fgOff: "", bold: "", boldOff: "", countAdd: "", countDel: "", syntax: null,
+      verb: { Update: "", Create: "", Delete: "", Write: "" },
+      add: { ...EMPTY_SIGN }, del: { ...EMPTY_SIGN },
+    };
+  }
+  const base = {
+    tier, variant, glyph, reset: "\x1b[0m", lineNo: "\x1b[90m", lineNoOff: "\x1b[39m",
+    grey: "\x1b[90m", fgOff: "\x1b[39m", bold: "\x1b[1m", boldOff: "\x1b[22m",
+  };
+  if (tier === "16") {
+    return {
+      ...base,
+      fill: false,
+      syntax: null, // rows are green/red TEXT here; token colours would erase that signal
+      countAdd: "\x1b[32m",
+      countDel: "\x1b[31m",
+      verb: { Update: "\x1b[33m", Create: "\x1b[32m", Delete: "\x1b[31m", Write: "\x1b[33m" },
+      // No background on 16 colours: the whole row is green/red text; changed words are
+      // reverse-video so they still stand out.
+      add: { row: "\x1b[32m", sign: "", signOff: "", wordOn: "\x1b[7m", wordOff: "\x1b[27m" },
+      del: { row: "\x1b[31m", sign: "", signOff: "", wordOn: "\x1b[7m", wordOff: "\x1b[27m" },
+    };
+  }
+  const P = PALETTE[variant === "light" ? "light" : "dark"];
+  const fg = tier === "truecolor" ? (c) => fgRgb(c[0]) : (c) => fg256(c[1]);
+  const bg = tier === "truecolor" ? (c) => bgRgb(c[0]) : (c) => bg256(c[1]);
+  return {
+    ...base,
+    fill: true,
+    // Opt-in only (GU_DIFF_SYNTAX=1): foreground per token role, layered over the row tint.
+    syntax: syntax
+      ? { keyword: fg(P.keyword), string: fg(P.string), comment: fg(P.comment), number: fg(P.number) }
+      : null,
+    countAdd: fg(P.addFg),
+    countDel: fg(P.delFg),
+    verb: { Update: fg(P.update), Create: fg(P.addFg), Delete: fg(P.delFg), Write: fg(P.update) },
+    add: { row: bg(P.addBg), sign: fg(P.addFg), signOff: "\x1b[39m", wordOn: bg(P.addWord), wordOff: bg(P.addBg) },
+    del: { row: bg(P.delBg), sign: fg(P.delFg), signOff: "\x1b[39m", wordOn: bg(P.delWord), wordOff: bg(P.delBg) },
+  };
+}
+
+/** The theme for this environment (GU_THEME, GU_ASCII, detected tier). */
+export function themeFromEnv(env = process.env, opts = {}) {
+  const tier = opts.tier ?? colorTier(env, opts);
+  const variant = String(env.GU_THEME ?? "").trim().toLowerCase() === "light" ? "light" : "dark";
+  const ascii = /^(1|true|yes)$/i.test(String(env.GU_ASCII ?? ""));
+  const syntax = /^(1|true|yes|on)$/i.test(String(env.GU_DIFF_SYNTAX ?? "").trim());
+  return makeTheme(tier, variant, { ascii, syntax });
+}
+
+export const CARD_THEME = themeFromEnv(process.env, { tier: TIER });