@tiens.nguyen/gu-cli 1.0.784 → 1.0.786

package/mcp-config.mjs

@@ -18,13 +18,27 @@
  * tool is read-only (readOnlyHint) is NOT a rule: the MCP spec says clients must treat those hints
  * as untrusted, and a hostile server would simply claim it.
  *
+ * CLAUDE CODE'S SERVERS (#325). A folder that chose "Claude's skills" (/switch-skill) takes YOUR
+ * servers from Claude Code's own file instead of ~/.gonext/mcp.json:
+ *   ~/.claude.json   projects["<this folder>"].mcpServers   (Claude's "local" scope — this folder only)
+ *   ~/.claude.json   mcpServers                             (Claude's "user" scope — every folder)
+ * The project's .mcp.json is the same file either way. Yours still win over the project's. gu's own
+ * bookkeeping — disabled, the allow/deny rules, which project servers you approved — stays in
+ * ~/.gonext/mcp.json whichever source is chosen: Claude Code's file has no place for it, and gu
+ * reads Claude's setup without Claude ever having to read gu's.
+ *
+ * ~/.claude.json IS CLAUDE CODE'S WHOLE STATE FILE, not a config file of ours. It is only written
+ * when you add or remove a server yourself, and then only its mcpServers entry changes: re-read,
+ * change one key, write back atomically with the file's own permissions.
+ *
  * ONE WRITER SHAPE. Both `gu mcp` and `/mcp` go through updateUserConfig, which re-reads the file,
  * changes one thing and writes it back atomically — keys it does not know are kept. Rebuilding the
  * object from what one side knows is how a settings screen once deleted the other side's entries.
  */
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
+import { resolveSkillSource } from "./skill-source.mjs";
 
 export const SERVER_NAME_RE = /^[A-Za-z0-9_-]{1,64}$/;
 
@@ -34,6 +48,13 @@ export function userConfigPath(home = homedir()) {
 export function projectConfigPath(cwd) {
   return join(cwd, ".mcp.json");
 }
+/** Claude Code's state file — where its user- and local-scope MCP servers are (#325). */
+export function claudeConfigPath(home = homedir()) {
+  return join(home, ".claude.json");
+}
+/** The file YOUR servers are in, for the source in use. */
+export const userServersPath = (home = homedir(), source = "gu") =>
+  source === "claude" ? claudeConfigPath(home) : userConfigPath(home);
 
 function readJson(file) {
   let text;
@@ -67,6 +88,39 @@ export function readUserConfig(home = homedir()) {
 
 const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
 
+/** Claude Code's servers for this folder → { local, user, error? }. A missing file is no servers. */
+export function readClaudeServers({ cwd, home = homedir() } = {}) {
+  const { data, error } = readJson(claudeConfigPath(home));
+  const proj = cwd && isObj(data?.projects) ? data.projects[resolve(cwd)] : null;
+  return {
+    error,
+    local: isObj(proj?.mcpServers) ? proj.mcpServers : {},
+    user: isObj(data?.mcpServers) ? data.mcpServers : {},
+  };
+}
+
+/**
+ * Change ~/.claude.json: re-read, edit in place, write back atomically, permissions kept. Refused
+ * when the file is not valid JSON — it is Claude Code's, and not ours to "repair".
+ */
+export function updateClaudeConfig(mutate, home = homedir()) {
+  const file = claudeConfigPath(home);
+  const { data, error } = readJson(file);
+  if (error) throw new Error(`${file} is ${error} — fix it first (it is Claude Code's own file)`);
+  const raw = data ?? {};
+  mutate(raw);
+  let mode = 0o600;
+  try {
+    mode = statSync(file).mode & 0o777;
+  } catch {
+    /* a new file: private, as Claude Code makes it */
+  }
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(tmp, JSON.stringify(raw, null, 2) + "\n", { encoding: "utf8", mode });
+  renameSync(tmp, file);
+  return raw;
+}
+
 /** Write ~/.gonext/mcp.json atomically: a crash mid-write leaves the old file, never half of one. */
 function writeUserRaw(raw, home) {
   const file = userConfigPath(home);
@@ -103,12 +157,17 @@ export function normalizeServer(entry) {
 
 /**
  * Every server this folder knows of, with its state.
- * → { servers: [{ name, scope, type, command, args, env, disabled, approved, runnable, error? }], warnings }
+ * `source` = whose servers ("gu" | "claude"); left out, it is the folder's own choice.
+ * scope: "user" (yours, every folder), "local" (Claude's: yours, this folder only), "project".
+ * → { servers: [{ name, scope, type, command, args, env, disabled, approved, runnable, error? }], warnings, source }
  */
-export function listServers({ cwd = process.cwd(), home = homedir() } = {}) {
+export function listServers({ cwd = process.cwd(), home = homedir(), source } = {}) {
+  const src = resolveSkillSource({ source, cwd, home });
   const user = readUserConfig(home);
   const warnings = [];
-  if (user.error) warnings.push(`${userConfigPath(home)} is ${user.error} — its servers are skipped`);
+  if (user.error) {
+    warnings.push(`${userConfigPath(home)} is ${user.error} — ${src === "claude" ? "its rules and approvals are skipped" : "its servers are skipped"}`);
+  }
   const servers = [];
   const seen = new Set();
   const add = (name, entry, scope, approved) => {
@@ -129,7 +188,14 @@ export function listServers({ cwd = process.cwd(), home = homedir() } = {}) {
       runnable: !n.error && !disabled && approved,
     });
   };
-  for (const [name, entry] of Object.entries(user.mcpServers)) add(name, entry, "user", true);
+  if (src === "claude") {
+    const claude = readClaudeServers({ cwd, home });
+    if (claude.error) warnings.push(`${claudeConfigPath(home)} is ${claude.error} — its servers are skipped`);
+    for (const [name, entry] of Object.entries(claude.local)) add(name, entry, "local", true);
+    for (const [name, entry] of Object.entries(claude.user)) add(name, entry, "user", true);
+  } else {
+    for (const [name, entry] of Object.entries(user.mcpServers)) add(name, entry, "user", true);
+  }
   if (cwd) {
     const proj = readJson(projectConfigPath(cwd));
     if (proj.error) warnings.push(`${projectConfigPath(cwd)} is ${proj.error} — its servers are skipped`);
@@ -138,12 +204,12 @@ export function listServers({ cwd = process.cwd(), home = homedir() } = {}) {
       add(name, entry, "project", approvedHere.includes(name));
     }
   }
-  return { servers, warnings };
+  return { servers, warnings, source: src };
 }
 
 /** What the worker hands the agent for one turn: the servers it may start, and the rules. */
-export function mcpForTurn({ cwd, home = homedir() } = {}) {
-  const { servers } = listServers({ cwd, home });
+export function mcpForTurn({ cwd, home = homedir(), source } = {}) {
+  const { servers } = listServers({ cwd, home, source });
   const user = readUserConfig(home);
   return {
     servers: servers
@@ -177,7 +243,7 @@ export function decide({ allow = [], deny = [] }, server, tool) {
 
 /* ---------------------------------------------------------------- changes -------------- */
 
-export function addServer({ name, command, args = [], env = {}, scope = "user", cwd, home = homedir() }) {
+export function addServer({ name, command, args = [], env = {}, scope = "user", cwd, home = homedir(), source }) {
   if (!SERVER_NAME_RE.test(name ?? "")) throw new Error(`"${name}" is not a valid name — use letters, digits, _ or -`);
   if (!String(command ?? "").trim()) throw new Error("no command given");
   const entry = { type: "stdio", command: String(command), args: args.map(String), env };
@@ -196,6 +262,15 @@ export function addServer({ name, command, args = [], env = {}, scope = "user",
     approveProjectServer({ name, cwd, home });
     return { file };
   }
+  if (resolveSkillSource({ source, cwd, home }) === "claude") {
+    // Claude Code's user scope. Its entry, its file; gu's file only forgets a stale "disabled".
+    updateClaudeConfig((raw) => {
+      raw.mcpServers = isObj(raw.mcpServers) ? raw.mcpServers : {};
+      raw.mcpServers[name] = entry;
+    }, home);
+    if (readUserConfig(home).disabled.includes(name)) setDisabled({ name, disabled: false, home });
+    return { file: claudeConfigPath(home) };
+  }
   updateUserConfig((raw) => {
     raw.mcpServers = isObj(raw.mcpServers) ? raw.mcpServers : {};
     raw.mcpServers[name] = entry;
@@ -205,10 +280,23 @@ export function addServer({ name, command, args = [], env = {}, scope = "user",
 }
 
 /** Remove from YOUR file. A project's server cannot be removed from here — only not approved. */
-export function removeServer({ name, home = homedir() }) {
+export function removeServer({ name, home = homedir(), cwd, source }) {
   let found = false;
+  const claude = resolveSkillSource({ source, cwd, home }) === "claude";
+  if (claude) {
+    // From Claude Code's file: this folder's own entry and the every-folder one.
+    const has = readClaudeServers({ cwd, home });
+    if (name in has.local || name in has.user) {
+      updateClaudeConfig((raw) => {
+        if (isObj(raw.mcpServers) && name in raw.mcpServers) delete raw.mcpServers[name];
+        const proj = cwd && isObj(raw.projects) ? raw.projects[resolve(cwd)] : null;
+        if (isObj(proj?.mcpServers) && name in proj.mcpServers) delete proj.mcpServers[name];
+      }, home);
+      found = true;
+    }
+  }
   updateUserConfig((raw) => {
-    if (isObj(raw.mcpServers) && name in raw.mcpServers) {
+    if (!claude && isObj(raw.mcpServers) && name in raw.mcpServers) {
       delete raw.mcpServers[name];
       found = true;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.784",
+  "version": "1.0.786",
   "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",
@@ -41,7 +41,7 @@
     "check:image": "node scripts/image-paste-check.mjs",
     "check:image-clipboard": "node scripts/image-paste-check.mjs --clipboard",
     "test:presets": "node --test tests/open-presets.test.mjs tests/preset-safety.test.mjs tests/preset-more.test.mjs tests/preset-apply.test.mjs tests/preset-full.test.mjs tests/presets-transfer.test.mjs tests/preset-editor.test.mjs tests/load-preset-paste.test.mjs",
-    "test:skills": "python3 scripts/py-tap.py tests/test_skills_mcp_turn.py tests/test_hooks_turn.py tests/test_mcp_client.py && node --test tests/skills.test.mjs tests/mcp-config.test.mjs tests/hooks-config.test.mjs tests/slash-menu.test.mjs tests/conversation-archive.test.mjs",
+    "test:skills": "python3 scripts/py-tap.py tests/test_skills_mcp_turn.py tests/test_hooks_turn.py tests/test_claude_hooks.py tests/test_mcp_client.py && node --test tests/skills.test.mjs tests/mcp-config.test.mjs tests/hooks-config.test.mjs tests/switch-skill.test.mjs tests/slash-menu.test.mjs tests/conversation-archive.test.mjs",
     "capture:turn": "GONEXT_OLLAMA1_LIVE=1 node scripts/capture-turn-fixture.mjs",
     "test:bearer": "node --test tests/bearer-routing.test.mjs tests/bearer-verify.test.mjs",
     "test:bearer-e2e": "bash scripts/bearer-e2e.sh"
@@ -109,6 +109,8 @@
     "powershell-alias.mjs",
     "install-path.mjs",
     "skills.mjs",
+    "skill-source.mjs",
+    "step-group.mjs",
     "mcp-config.mjs",
     "mcp-command.mjs",
     "hooks-config.mjs",

package/skill-source.mjs

@@ -0,0 +1,60 @@
+/**
+ * WHOSE SKILLS THIS FOLDER USES — gu's or Claude Code's (task #325, /switch-skill).
+ *
+ *   "gu"      ~/.gonext  and  <project>/.gonext     (the default; a folder that never chose)
+ *   "claude"  ~/.claude  and  <project>/.claude     Claude Code's own files, read where they are
+ *
+ * One choice covers skills, MCP servers and hooks, because they depend on each other: a skill names
+ * an MCP server's tools, and the hooks feed the same database that server reads. Switching one of
+ * the three alone would leave them talking about different things.
+ *
+ * ONE-WAY. gu reads Claude Code's setup; Claude Code is never expected to read gu's. So nothing of
+ * gu's own is written into Claude's files: which project servers and hooks you approved, and the
+ * allow rules, stay in ~/.gonext whichever source is chosen.
+ *
+ * PER FOLDER, IN THE FOLDER'S SESSION FILE. The terminal writes it; the worker — a different
+ * process, which builds each turn's skills, servers and hooks — reads the same file. Every reader
+ * in this package resolves the source through readSkillSource, so the banner and the turn cannot
+ * disagree about which setup is in use.
+ */
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const SKILL_SOURCES = ["gu", "claude"];
+export const DEFAULT_SKILL_SOURCE = "gu";
+/** The session file's key. */
+export const SKILL_SOURCE_KEY = "skillSource";
+
+export const normalizeSkillSource = (v) => (v === "claude" ? "claude" : DEFAULT_SKILL_SOURCE);
+
+/** The folder each source keeps its files in — under the home directory and under the project. */
+export const sourceDirName = (source) => (normalizeSkillSource(source) === "claude" ? ".claude" : ".gonext");
+
+/** What a picker and a status line call it. */
+export const sourceLabel = (source) => (normalizeSkillSource(source) === "claude" ? "Claude's skills" : "gu's skills");
+
+/** The terminal's per-folder session file — the same name gu-repl.mjs uses. */
+export function sessionFileFor(cwd, home = homedir()) {
+  const hash = createHash("sha256").update(String(cwd)).digest("hex").slice(0, 32);
+  return join(home, ".gonext", "sessions", `${hash}.json`);
+}
+
+/**
+ * This folder's choice. No folder, no session file, a file that cannot be read, any other value:
+ * gu's — the behaviour before there was a choice, and never an error.
+ */
+export function readSkillSource(cwd, home = homedir()) {
+  if (!cwd) return DEFAULT_SKILL_SOURCE;
+  try {
+    const raw = JSON.parse(readFileSync(sessionFileFor(cwd, home), "utf8"));
+    return normalizeSkillSource(raw?.[SKILL_SOURCE_KEY]);
+  } catch {
+    return DEFAULT_SKILL_SOURCE;
+  }
+}
+
+/** `source` when a caller names one, else the folder's own. */
+export const resolveSkillSource = ({ source, cwd, home = homedir() } = {}) =>
+  source ? normalizeSkillSource(source) : readSkillSource(cwd, home);

package/skills.mjs

@@ -4,6 +4,10 @@
  *   ~/.gonext/skills/<name>/SKILL.md        yours, every folder
  *   <project>/.gonext/skills/<name>/SKILL.md this project only
  *
+ * …or Claude Code's own, when the folder chose them with /switch-skill (#325, skill-source.mjs):
+ *   ~/.claude/skills/<name>/SKILL.md  and  <project>/.claude/skills/<name>/SKILL.md
+ * The same file in the same layout — only the folder differs, so nothing is converted.
+ *
  * A SKILL.md is YAML frontmatter (name, description) and a body of instructions. Only the name and
  * description go into every prompt; the body is read when the agent calls use_skill(name) or the
  * user types /<name> — never pasted into every turn. Same split as Claude Code, and for the same
@@ -24,16 +28,17 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { resolveSkillSource, sourceDirName } from "./skill-source.mjs";
 
 export const SKILL_FILE = "SKILL.md";
 /** Claude Code's rule: lowercase letters, digits and hyphens, at most 64. It is also a slash command. */
 export const SKILL_NAME_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
 
-export function userSkillsDir(home = homedir()) {
-  return join(home, ".gonext", "skills");
+export function userSkillsDir(home = homedir(), source = "gu") {
+  return join(home, sourceDirName(source), "skills");
 }
-export function projectSkillsDir(cwd) {
-  return join(cwd, ".gonext", "skills");
+export function projectSkillsDir(cwd, source = "gu") {
+  return join(cwd, sourceDirName(source), "skills");
 }
 
 /** Strip one pair of matching quotes. */
@@ -138,13 +143,17 @@ function scanDir(dir, scope) {
  * the built-in wins, and the skill is still usable by the agent, just not as a slash command —
  * that is `slash: false`.
  *
- * → { skills: [{ name, description, path, dir, scope, slash }], warnings: string[] }
+ * `source` = whose skills ("gu" | "claude"); left out, it is the folder's own choice (/switch-skill).
+ * Only that source's skills are listed — the two are never mixed.
+ *
+ * → { skills: [{ name, description, path, dir, scope, slash, source }], warnings: string[], source }
  */
-export function discoverSkills({ cwd = process.cwd(), home = homedir(), reserved = [] } = {}) {
-  const user = scanDir(userSkillsDir(home), "user");
+export function discoverSkills({ cwd = process.cwd(), home = homedir(), reserved = [], source } = {}) {
+  const src = resolveSkillSource({ source, cwd, home });
+  const user = scanDir(userSkillsDir(home, src), "user");
   const project =
-    cwd && projectSkillsDir(cwd) !== userSkillsDir(home)
-      ? scanDir(projectSkillsDir(cwd), "project")
+    cwd && projectSkillsDir(cwd, src) !== userSkillsDir(home, src)
+      ? scanDir(projectSkillsDir(cwd, src), "project")
       : { skills: [], warnings: [] };
   const byName = new Map();
   for (const s of user.skills) byName.set(s.name, s);
@@ -152,17 +161,20 @@ 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) }));
-  return { skills, warnings: [...user.warnings, ...project.warnings] };
+    .map((s) => ({ ...s, slash: !taken.has(s.name), source: src }));
+  return { skills, warnings: [...user.warnings, ...project.warnings], source: src };
 }
 
 /** What the worker hands the agent for one turn: enough to list them and to read one. */
 export function skillsForTurn(opts) {
-  return discoverSkills(opts).skills.map(({ name, description, path, dir }) => ({
+  // `source` goes along only for Claude's: the agent then reads the skill as one written for
+  // Claude Code's tools (gu_skills.py). gu's own keep the shape they always had.
+  return discoverSkills(opts).skills.map(({ name, description, path, dir, source }) => ({
     name,
     description,
     path,
     dir,
+    ...(source === "claude" ? { source } : {}),
   }));
 }
 

package/step-group.mjs

@@ -0,0 +1,140 @@
+/**
+ * A TURN'S LOOK-UPS AS ONE LINE (task #326) — pure helpers; gu-repl.mjs does the drawing.
+ *
+ * Asked for after reading a Claude Code session beside a gu one. gu printed one "●" line per tool
+ * call — "Searching code → …", "Reading lines → …", again and again — so a turn that read six
+ * files and searched five times was thirty rows of scaffolding above a ten-row answer. Claude Code
+ * says the same thing in one line ("Searched for 2 patterns, read 6 files") and keeps the detail a
+ * click away. That is what a GROUP is: consecutive look-ups share one row, counted by kind, and a
+ * click opens it into the lines gu used to print.
+ *
+ * WHAT IS GROUPED: a neutral step of the shape "Label → detail" — the agent telling us what it
+ * looked at. NOT grouped, because each is something the user must be able to see at a glance:
+ * a failure (✗), a command's result (✓), an edit card, an approval, the answer.
+ *
+ * NOTHING HERE KNOWS A TOOL'S NAME. The kind is whatever stands before the arrow, so a tool added
+ * tomorrow is counted with no change here — the same rule the tool list itself follows (#37).
+ *
+ * SCAFFOLD LINES are the turn's machinery talking about itself ("Starting 1 MCP server(s)…",
+ * "Composing answer…", the retrieval tally the group line now carries): live status, not history.
+ * Still printed under --verbose.
+ */
+
+const ARROW = " → ";
+
+const SCAFFOLD = [/^Starting \d+ MCP server\(s\)…$/, /^Composing answer…$/, /^Found code by → /];
+
+/** The turn's own machinery, not something it did for the user. */
+export function isScaffoldStep(text) {
+  const t = String(text ?? "").trim();
+  return SCAFFOLD.some((re) => re.test(t));
+}
+
+/** "Searching code → seenNames (3 hits)" → "Searching code"; "" when the line has no such shape. */
+export function stepLabel(text) {
+  const t = String(text ?? "").trim();
+  const at = t.indexOf(ARROW);
+  if (at <= 0 || at > 40) return ""; // a sentence that merely contains an arrow is not a step
+  const label = t.slice(0, at).trim();
+  // A label is a few words ("Indexing project for RAG" is the longest the agent writes) — more
+  // than four is prose that happens to hold an arrow.
+  if (label.split(/\s+/).length > 4) return "";
+  return /^[A-Za-z][A-Za-z0-9 _.\-/]*$/.test(label) ? label : "";
+}
+
+/** Does this step join a group? `kind` is bulletKind()'s: only neutral ("info") steps do. */
+export function isGroupableStep(text, kind) {
+  return kind === "info" && !isScaffoldStep(text) && stepLabel(text) !== "";
+}
+
+// "Searching code" reads as work in progress; a finished group is said in the past. Only the first
+// word changes, and only when it is one of these — anything else is shown as the agent wrote it.
+const PAST = {
+  searching: "searched", reading: "read", listing: "listed", locating: "located", exploring: "explored",
+  calculating: "calculated", downloading: "downloaded", fetching: "fetched", checking: "checked",
+  calling: "called", indexing: "indexed", sending: "sent", deploying: "deployed",
+};
+
+function pastLabel(label) {
+  const [first, ...rest] = label.split(" ");
+  const past = PAST[first.toLowerCase()];
+  return past ? [past, ...rest].join(" ") : label;
+}
+
+/** "searched code 3× · read lines 2× · listed files" — kinds in the order they first happened. */
+export function stepGroupSummary(items) {
+  const counts = new Map();
+  for (const it of items ?? []) {
+    const label = stepLabel(it) || String(it ?? "").trim();
+    counts.set(label, (counts.get(label) ?? 0) + 1);
+  }
+  return [...counts].map(([label, n]) => pastLabel(label) + (n > 1 ? ` ${n}×` : "")).join(" · ");
+}
+
+function wrapWords(text, width) {
+  const rows = [];
+  let cur = "";
+  for (const word of String(text).trim().split(/\s+/)) {
+    const next = cur ? cur + " " + word : word;
+    if (next.length <= width) cur = next;
+    else {
+      if (cur) rows.push(cur);
+      // a word longer than the row (a path) is cut into row-sized pieces, never dropped
+      let w = word;
+      while (w.length > width) {
+        rows.push(w.slice(0, width));
+        w = w.slice(width);
+      }
+      cur = w;
+    }
+  }
+  if (cur) rows.push(cur);
+  return rows;
+}
+
+const clip = (text, width) => (text.length <= width ? text : text.slice(0, Math.max(1, width - 1)) + "…");
+
+const EXPAND_HINT = "  (click to expand)";
+const COLLAPSE_HINT = "(click to collapse)";
+
+/**
+ * The rows of one group: plain text, no colour, no gutter — the caller owns both.
+ * → [{ text, head }]; `head` marks a row that starts an entry (it gets the "●").
+ *
+ * COLLAPSED IS ALWAYS EXACTLY ONE ROW, whatever the width. The group is updated in place as the
+ * turn goes on, and a row that is always one row can be rewritten without moving anything below
+ * it — the lesson of every repaint bug in this terminal (#109, #321, #324): rows must not wrap,
+ * and what is on screen must stay what gu thinks is on screen.
+ *   one look-up  → the look-up itself (cut with "…" if it is too long; a click shows it whole)
+ *   several      → the counted summary, with the hint when there is room for it
+ */
+export function stepGroupRows(items, { width = 76, collapsed = true } = {}) {
+  const list = (items ?? []).map((x) => String(x ?? "").trim()).filter(Boolean);
+  const w = Math.max(20, width);
+  if (!list.length) return [];
+  if (collapsed) {
+    if (list.length === 1) return [{ text: clip(list[0], w), head: true }];
+    const summary = stepGroupSummary(list);
+    const withHint = summary + EXPAND_HINT;
+    return [{ text: withHint.length <= w ? withHint : clip(summary, w), head: true }];
+  }
+  const rows = [];
+  for (const item of list) wrapWords(item, w).forEach((text, i) => rows.push({ text, head: i === 0 }));
+  // Only a group that HAS a shorter form offers to go back to it.
+  if (list.length > 1 || rows.length > 1) rows.push({ text: COLLAPSE_HINT, head: false });
+  return rows;
+}
+
+/**
+ * Paths under the project folder, shown relative to it: "/Users/x/proj/src/a.ts:1-9" → "src/a.ts:1-9".
+ * Display only. The folder itself becomes "." so "Listing files → /Users/x/proj" still says where.
+ */
+export function relativizePaths(text, cwd) {
+  const root = String(cwd ?? "").replace(/[\\/]+$/, "");
+  const src = String(text ?? "");
+  if (!root || root.length < 2 || !src.includes(root)) return src;
+  const esc = root.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return src
+    .replace(new RegExp(esc + "[\\\\/]", "g"), "")
+    .replace(new RegExp(esc + "(?![\\w.-])", "g"), ".");
+}

package/terminal-layout.mjs

@@ -1038,6 +1038,10 @@ export function thoughtProse(buf) {
     // A leading pipe or quote survives some streams ("| Thought: …").
     .replace(/^\s*[|>\-]+\s*/, "")
     .replace(/^\s*Thought:\s*/i, "")
+    // …and the same label in the MIDDLE, glued to the sentence before it ("…the app does.Thought:
+    // I have all the file contents") — a model that reasons and then restates under the label
+    // (seen live, #326). It is a label, not a word of the thought: a space takes its place.
+    .replace(/(?<=\S)\s*\bThought:\s*/g, " ")
     .replace(/```[a-z]*\n?/gi, " ")
     .replace(/\s+/g, " ")
     .trim();
@@ -1735,7 +1739,12 @@ export function answerBlock({
   doneAt = Date.now(),
   inputLabel = "",
 } = {}) {
-  const rendered = render(worked ? `recap: ${answer}` : answer);
+  // NO "recap:" LABEL (#326). It was added when the answer arrived under a long list of step
+  // lines and needed saying what it was; the look-ups are one row now, so the answer is simply
+  // the bright text under them — and a label on it read as if a recap FOLLOWED the answer.
+  // `worked` is still accepted: callers pass it, and it is what a real recap line would gate on.
+  void worked;
+  const rendered = render(answer);
   const clock = formatClockTime(doneAt);
   // The stamp is DROPPED, not defaulted, when the time is unusable — "done Invalid Date" beside
   // a correct duration is worse than no stamp at all. The same for the input figure (#53): the
@@ -2619,6 +2628,11 @@ export function formatThinkTime(ms) {
 const _PICTOGRAPH =
   /[\p{Extended_Pictographic}\p{Emoji_Modifier}\p{Regional_Indicator}️‍]+[ \t]?/gu;
 
+// A KEYCAP ("1️⃣") is a digit + a variation selector + U+20E3, and only the selector is a
+// pictograph: stripping left "1⃣ What it is" — a digit wearing a combining box, which terminals
+// draw badly or over the next letter (seen live, #326). The model meant a numbered point: "1.".
+const _KEYCAP = /([0-9#*])\uFE0F?\u20E3/g;
+
 /**
  * The answer as PLAIN TEXT: decorative emoji removed (task #178).
  *
@@ -2643,7 +2657,7 @@ export function plainAnswer(text) {
         : // …and within prose, odd indices are inline code spans.
           part
             .split(/(`[^`\n]*`)/g)
-            .map((seg, j) => (j % 2 ? seg : seg.replace(_PICTOGRAPH, "")))
+            .map((seg, j) => (j % 2 ? seg : seg.replace(_KEYCAP, "$1.").replace(_PICTOGRAPH, "")))
             .join("")
     )
     .join("")