@tiens.nguyen/gu-cli 1.0.811 → 1.0.813

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
@@ -4764,6 +4769,42 @@ def _collapse_inner_openers(text):
     return text[:body_from] + cleaned + "\n</code>"
 
 
+# DeepSeek DSML tool-call markup (issue #119). Some DeepSeek-family models (seen via
+# token-plan.maas.qwencloudapi.com) answer with their NATIVE tool-call text instead of our code
+# block: prose, then a DSML "calls" tag, a DSML invoke tag with name="code", then plain Python,
+# then closers that are often wrong (a DSML "parameter" close) or missing. The bars in the tags
+# are FULLWIDTH, so the patterns tolerate any short run of non-bracket characters around DSML.
+_DSML_INVOKE_CODE = re.compile(
+    r"<[^<>\n]{0,8}DSML[^<>\n]{0,8}invoke\s+name\s*=\s*[\x22\x27]code[\x22\x27]\s*>[ \t]*\r?\n?"
+)
+_DSML_ANY = re.compile(r"<[^<>\n]{0,8}DSML")
+_DSML_CLOSER = re.compile(r"\n?[ \t]*</[^<>\n]{0,8}DSML")
+
+
+def _dsml_to_code_block(text):
+    """Rewrite a DSML invoke name="code" body into a normal code block, or return the text
+    unchanged. Fires only when there is NO code tag already and the body COMPILES (the same
+    conservative contract as the other readings)."""
+    if not text or "DSML" not in text or re.search(r"<\s*/?\s*code\b", text, re.I):
+        return text
+    m = _DSML_INVOKE_CODE.search(text)
+    if not m:
+        return text
+    rest = text[m.end():]
+    c = _DSML_CLOSER.search(rest)
+    body = (rest[:c.start()] if c else rest).strip("\n")
+    if not body.strip():
+        return text
+    try:
+        compile(body, "<gu-code>", "exec")
+    except Exception:  # noqa: BLE001
+        return text
+    head = text[:m.start()]
+    first = _DSML_ANY.search(head)
+    prose = (head[:first.start()] if first else head).rstrip()
+    return (prose + "\n" if prose else "") + "<code>\n" + body + "\n</code>"
+
+
 def _code_block_readings(text):
     """Every plausible reading of where the code block is, CHEAPEST FIRST.
 
@@ -4824,6 +4865,10 @@ def _canonicalise_code_reply(text):
     # reproduced, inside the fix, the very shape of the bug being fixed: a strict cheap check
     # guarding a tolerant repair. If a pre-check cannot be as permissive as what it guards, it
     # does not belong in front of it.
+    _dsml = _dsml_to_code_block(text)
+    if _dsml != text:
+        _log("DSML tool-call markup converted to a code block (#119)")
+        return _dsml
     if not text or not _CODE_ANY_TAGGISH.search(text):
         return text
     fallback = None
@@ -6853,9 +6898,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 +6912,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 +6932,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:
@@ -11810,7 +11865,8 @@ def run_agent_chat(cfg):
                         if _still_bad:
                             self._parse_fail_streak += 1
                             _log("tool-call code still unparseable after repair "
-                                 f"(streak {self._parse_fail_streak}/3)")
+                                 f"(streak {self._parse_fail_streak}/3) model={getattr(self, 'model_id', '?')} "
+                                 f"reply[:300]={(msg.content or '')[:300]!r}")
                             if self._parse_fail_streak >= 3:
                                 _log("parse-fail streak hit limit → ending the turn honestly "
                                      "instead of looping on an unparseable tool call")
@@ -12789,7 +12845,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

@@ -61,6 +61,7 @@ import {
   thoughtFull,
   thoughtBlockRows,
   ragSegmentLabel,
+  ragBarNote,
   searchSegmentLabel,
   runningDetailRows,
   formatThinkTime,
@@ -175,6 +176,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 +220,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 +403,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 +440,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).
@@ -2278,9 +2277,13 @@ const ragSegmentText = () => {
   // RAG FAILED MID-TURN and searches were answered by the grep fallback: a WARNING (yellow),
   // always visible — the turn still got results, but not semantic ones.
   const liveFallback = b.ragState === "fallback" && !b.stale;
-  if (!REPL_VERBOSE && !liveDown && !liveFallback) return lexSeg;
+  // Task #34: a LIVE grep fallback (embedder down, or RAG failed mid-turn) is no longer on this
+  // row. In red with a "✗" it read as a serious fault while search kept working. It is now a soft
+  // yellow note on the bottom bar's mode row (ragBarNote → footerRows' modeNote).
+  if (liveDown || liveFallback) return lexSeg;
+  if (!REPL_VERBOSE) return lexSeg;
   if (b.stale) return dim(" · ") + dim(`${label}·`) + lexSeg;
-  return dim(" · ") + (liveDown ? red(label) : liveFallback ? yellow(label) : dim(label)) + lexSeg;
+  return dim(" · ") + dim(label) + lexSeg;
 };
 /**
  * IS ANYTHING NEWER? (task #181) — cached, never probed from a repaint.
@@ -2731,6 +2734,10 @@ const footerRows = () =>
     identity: identityLineText(),
     token: tokenLineText(),
     mode: modeLineText(),
+    // Task #34: "rag: embedder down → grep fallback" as a soft yellow note beside the mode, not an
+    // alarming red segment on the token row. yellow goes through paint(), so NO_COLOR turns it off.
+    modeNote: ragBarNote(lastPromptBreakdown),
+    notePaint: yellow,
     // How to paste here (issue #67): the platform's text key, plus gu's image key when the coder
     // can take an image.
     modeHint: pasteHint({ images: coderTakesImages() }),
@@ -3542,6 +3549,7 @@ function printThoughtBlock(raw, before, { gap = false } = {}) {
       collapsed: true,
       lines: THOUGHT_COLLAPSED_LINES,
     });
+    const rowsBeforeMerge = screenRows().length;
     const newEnd = transcript.replaceRange(prev.from, prev.to, grown.map((r) => GUTTER + dim(r)));
     if (newEnd !== null) {
       prev.prose = merged;
@@ -3550,7 +3558,7 @@ function printThoughtBlock(raw, before, { gap = false } = {}) {
       // move under the pointer, so the cached hover row must be dropped — same reason
       // toggleThoughtBlock does it after a resize of the block.
       hoverCtl.reset();
-      paintLiveTail();
+      repaintTailOrHoldView(rowsBeforeMerge); // #113/#35: a finished thought never pulls a reader down
       return true;
     }
     // Scrolled out of the buffer — fall through and print a new block rather than lose it.
@@ -3857,6 +3865,21 @@ function toggleNewestThought() {
   return toggleThoughtBlock(block);
 }
 
+/**
+ * #113 / #35 — A BLOCK AT THE TAIL CHANGED SIZE (a thought merged, a step group grew). At the
+ * live tail that is a paintLiveTail. Scrolled back, it is NOT: paintLiveTail sets scrollOffset
+ * to 0, which is exactly the "it finished thinking and threw me back to the bottom" report. The
+ * change happened below (or at the edge of) what the reader is looking at, so keep the same
+ * lines on screen — the offset moves by the rows added — and let the jump notice count up.
+ */
+function repaintTailOrHoldView(rowsBefore) {
+  if (barPinned() && scrolledBack()) {
+    scrollOffset = Math.max(1, scrollOffset + (screenRows().length - rowsBefore));
+    renderScrollback(); // same slice as before; ends in paintBar (the "N lines below" count)
+    return;
+  }
+  paintLiveTail();
+}
 /** Back to the live tail: repaint it from the transcript and hand the screen back. */
 function jumpToBottom() {
   if (!barPinned() || !scrollOffset) return; // already live — nothing to come back from
@@ -7887,14 +7910,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 +11844,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
@@ -11874,13 +11901,16 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
     if (stepGroupStillOpen()) {
       stepGroup.items.push(text);
       const painted = paintThoughtRows(stepGroup, hoverCtl.hovered === stepGroup);
+      const rowsBeforeStep = screenRows().length;
       const newEnd = transcript.replaceRange(stepGroup.from, stepGroup.to, painted);
       if (newEnd !== null) {
         const delta = newEnd - stepGroup.to;
         stepGroup.to = newEnd;
         if (delta === 0) {
           // Collapsed: one row before, one row after — rewrite that row and nothing else.
-          ui(thoughtBlockRepaintSeq(stepGroup));
+          // Scrolled back (#113/#35): those rows are live-tail coordinates, NOT the history the
+          // reader is looking at — painting them would draw over it. The transcript has it.
+          if (!scrolledBack()) ui(thoughtBlockRepaintSeq(stepGroup));
           paintBar();
         } else {
           // Open (the user clicked it mid-turn): it grew, and what is under it moved down.
@@ -11891,7 +11921,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
             }
           }
           hoverCtl.reset();
-          paintLiveTail();
+          repaintTailOrHoldView(rowsBeforeStep); // #113/#35: never pull a reader down
         }
         return;
       }
@@ -12037,36 +12067,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 +12236,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.811",
+  "version": "1.0.813",
   "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",
@@ -40,6 +40,7 @@
     "test:cache-e2e": "GONEXT_OLLAMA1_LIVE=1 node --test --test-timeout=1800000 tests/prefix-cache-e2e.test.mjs",
     "test:tokens": "python3 -m unittest discover tests -p \"test_cached_tokens.py\" -v && node --test tests/prefix-cache.test.mjs tests/agent-turn-shape.test.mjs",
     "test:selection": "node --test tests/selection-scrollback.test.mjs tests/selection-while-thinking.test.mjs tests/terminal-selection.test.mjs tests/terminal-copy.test.mjs tests/terminal-viewport.test.mjs tests/hover-repaint.test.mjs",
+    "test:autoscroll": "node --test tests/no-autoscroll-hide-total.test.mjs tests/thought-spacing.test.mjs tests/terminal-viewport.test.mjs tests/selection-scrollback.test.mjs",
     "test:steps": "python3 scripts/py-tap.py tests/test_read_caps.py tests/test_trim_payback.py tests/test_explore.py tests/test_and_chains.py tests/test_edit_file_primary.py tests/test_bare_code_rescue.py tests/test_batching_rule.py tests/test_no_pdf_routing.py",
     "check:image": "node scripts/image-paste-check.mjs",
     "check:image-clipboard": "node scripts/image-paste-check.mjs --clipboard",
@@ -51,6 +52,9 @@
   },
   "files": [
     "accent.mjs",
+    "edit-card-render.mjs",
+    "diff-syntax.mjs",
+    "theme.mjs",
     "gu-cli.mjs",
     "gu-repl.mjs",
     "step-tokens.mjs",

package/terminal-layout.mjs

@@ -146,8 +146,9 @@ export function ragSegmentLabel(b) {
   const rag = Number.isFinite(b.rag) ? b.rag : 0;
   if (rag > 0) return null; // …the caller renders the number + percent instead
   switch (b.ragState) {
+    // Task #34: no "✗" — search still works through grep, so this is a notice, not an error.
     case "unreachable":
-      return "rag ✗ embedder down → grep fallback";
+      return "rag: embedder down → grep fallback";
     case "no-index":
       return "rag — not indexed";
     case "unavailable":
@@ -167,7 +168,7 @@ export function ragSegmentLabel(b) {
     // RAG FAILED MID-TURN (indexing or query embedding) and the search was answered by the
     // keyword fallback instead. A warning, not an error: the turn still got results.
     case "fallback":
-      return "rag ⚠ unavailable → grep fallback";
+      return "rag: unavailable → grep fallback";
     // Nothing has been measured yet (the state before any turn has run). "0" is a claim we
     // cannot support; a dash says "no figure", which is the truth.
     case "unknown":
@@ -182,6 +183,34 @@ export function ragSegmentLabel(b) {
   }
 }
 
+/**
+ * The RAG notice for the BOTTOM BAR's mode row (task #34), or "" when there is none.
+ *
+ * Only THIS session's live verdict that search fell back to grep: "unreachable" (the embedder is
+ * down) or "fallback" (RAG failed mid-turn). It used to sit in red with a "✗" in the middle of the
+ * token row and read as a serious fault, while every search was still answered by grep. It is
+ * now a soft note beside "accept edits on". A stale verdict reloaded from a saved session is
+ * not a live fault, so it gets no notice.
+ */
+export function ragBarNote(b) {
+  if (!b || typeof b !== "object" || b.stale) return "";
+  if (b.ragState !== "unreachable" && b.ragState !== "fallback") return "";
+  return ragSegmentLabel(b) || "";
+}
+
+/** Cut plain text to `room` visible columns, ending with "…" when it was cut. */
+function fitPlain(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 + "…";
+}
+
 // The six origin buckets. They are scaled to sum to the server's prompt_tokens for ONE
 // request, so their sum IS the size of the newest context — the number to compare against
 // the model's window. Deliberately excludes ragFresh/ragCarried (shares OF rag, not extra)
@@ -544,11 +573,25 @@ export function buildFooterRows({
   // Right-aligned on the mode row (issue #67), dim. DROPPED WHOLE when it does not fit: every
   // footer row must stay one physical row (#109/#132/#138), and half a key name is worse than none.
   modeHint = "",
+  // Task #34: a soft notice (PLAIN text) after the mode text, painted with notePaint. It takes
+  // priority over the paste hint and is cut with "…" on a narrow window, never wrapped.
+  modeNote = "",
+  notePaint = dim,
   notice = "",
   missing = "",
 }) {
   const w = Math.max(20, width || 80);
-  const modeLeft = gutter + mode;
+  let modeLeft = gutter + mode;
+  if (modeNote) {
+    const NOTE_GAP = "  ";
+    const hintRoom = modeHint ? HINT_MIN_GAP + visibleLen(modeHint) : 0;
+    let room = w - 1 - visibleLen(modeLeft) - NOTE_GAP.length;
+    // Keep the paste hint only when the whole notice still fits beside it.
+    if (modeHint && visibleLen(modeNote) <= room - hintRoom) room -= hintRoom;
+    else modeHint = "";
+    // Too little room to say anything readable: leave the notice out.
+    if (room >= 8) modeLeft += NOTE_GAP + notePaint(fitPlain(modeNote, room));
+  }
   const hintGap = modeHint ? w - 1 - visibleLen(modeLeft) - visibleLen(modeHint) : -1;
   const modeRow =
     hintGap >= HINT_MIN_GAP

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 });