@visual-z/xeno 0.2.1 → 0.4.0

package/src/tui/ui/status.ts

@@ -0,0 +1,279 @@
+/**
+ * Session status as rows of styled segments (docs/tasks/refactor-tui-dock-layout.md). Pure.
+ *
+ * The app gathers the numbers (log projection, handoff preview, usage
+ * totals); these functions only decide what fits where. Which fields a tier
+ * shows is layout.ts's decision; this module formats them for the sidebar,
+ * the top bar and the input box edge.
+ *
+ * Field order follows what users ask for most (research 2026-10-06: context
+ * share, model and effort, location, cost, files, tasks, background work),
+ * then xeno's own: the handoff the next segment would start from. Every block
+ * appears only when it has something to say; complaints about status that is
+ * "a paragraph" were as common as requests for more of it.
+ */
+import { clipSegs, clipText, segsWidth, splitLine, type Label, type Seg } from "./edge.ts";
+import { displayWidth } from "../width.ts";
+
+export interface ContextStatus {
+  readonly used: number;
+  readonly window?: number;
+  /** Where the next segment cut happens, in the same units; null when the policy never cuts. */
+  readonly trigger: number | null;
+  readonly estimated: boolean;
+  readonly segment: number;
+}
+
+export interface FileStatus { readonly path: string; readonly edited: boolean; readonly added: number; readonly removed: number }
+
+export interface StatusModel {
+  readonly version: string;
+  /** `/name`, else the first prompt; null for a session with neither. */
+  readonly title: string | null;
+  readonly goal?: { readonly text: string; readonly status: string; readonly execution: string; readonly observations: number; readonly retries: number };
+  readonly workspace: string;
+  readonly workspaceShort: string;
+  readonly branch: string | null;
+  readonly context?: ContextStatus;
+  readonly usage?: { readonly input: number; readonly output: number; readonly cacheRate: number; readonly cost: string | null };
+  readonly tools: { readonly running: number; readonly done: number; readonly failed: number };
+  readonly handoff?: { readonly verified: readonly string[]; readonly inFlight: readonly string[]; readonly unverified: readonly string[] };
+  readonly tasks?: readonly { readonly what: string; readonly status: "active" | "blocked" }[];
+  readonly files?: readonly FileStatus[];
+  readonly background?: readonly string[];
+  readonly resources?: { readonly contextFiles: readonly string[]; readonly skills: number; readonly extensions: number };
+  readonly extension?: string;
+}
+
+export type Line = readonly Seg[];
+
+/** 1234 → "1.2k", 1234567 → "1.2m". The same compact form everywhere a token count appears. */
+export function compact(value: number): string {
+  return value >= 1_000_000 ? `${(value / 1_000_000).toFixed(1)}m` : value >= 1000 ? `${(value / 1000).toFixed(1)}k` : String(Math.round(value));
+}
+
+/**
+ * Share of the budget before the next segment cut. The cut, not the model
+ * window, is when this segment's context is replaced by a handoff, so it is
+ * the number that says how much room is left (D1/D8).
+ */
+export function contextShare(context: ContextStatus): number | undefined {
+  const limit = context.trigger ?? context.window;
+  return limit ? Math.max(0, Math.min(1, context.used / limit)) : undefined;
+}
+
+/** Above this share the context figure turns to the warning colour. Assumed, matching the old gauge. */
+const CONTEXT_WARNING = 0.8;
+
+function shareSeg(context: ContextStatus): Seg | undefined {
+  const share = contextShare(context);
+  if (share === undefined) return undefined;
+  return { text: `${context.estimated ? "~" : ""}${Math.round(share * 100)}%`, role: share >= CONTEXT_WARNING ? "warning" : "text" };
+}
+
+/** The input box's bottom-right label where there is no sidebar: `ctx ~12%`. */
+export function contextLabel(model: StatusModel): Label | undefined {
+  const share = model.context && shareSeg(model.context);
+  return share ? { segs: [{ text: "ctx ", role: "muted" }, share], priority: 1 } : undefined;
+}
+
+export function terminalTitle(model: StatusModel): string {
+  return ["xeno", model.branch, model.title ? clipText(firstLine(model.title), 48) : null].filter(Boolean).join(" · ");
+}
+
+function firstLine(text: string): string { return text.split("\n").find(line => line.trim())?.trim() ?? ""; }
+
+// ------------------------------------------------------------------- top bar
+
+/**
+ * `xeno  title ………… ~/P/w/xeno-tui   ⎇ branch   ✓3 …1   ⧗ 1   $0.42`
+ * Labels read in display order; priority decides what drops first when the
+ * row is narrow: location goes before counts, as OpenCode #570 asked.
+ */
+export function topbarRow(model: StatusModel, width: number): Seg[] {
+  const left: Label[] = [
+    { segs: [{ text: "xeno", role: "text", bold: true }], priority: 0 },
+    // Never dropped, but gives up width after cost and background counts, before the handoff counts go.
+    { segs: [{ text: model.title ? firstLine(model.title) : "New session", role: model.title ? "text" : "muted" }], priority: 0, min: 12, shrinkPriority: 1.5 },
+  ];
+  const right: Label[] = [{ segs: [{ text: model.workspaceShort, role: "muted" }], priority: 6 }];
+  if (model.branch) right.push({ segs: [{ text: "⎇ ", role: "muted" }, { text: model.branch, role: "muted" }], priority: 5, min: 8, shrink: 1 });
+  const counts = handoffCounts(model);
+  if (counts.length) right.push({ segs: counts, priority: 1 });
+  if (model.background?.length) right.push({ segs: [{ text: "⧗ ", role: "accent" }, { text: String(model.background.length), role: "text" }], priority: 2 });
+  if (model.extension) right.push({ segs: [{ text: model.extension, role: "muted" }], priority: 4, min: 10 });
+  if (model.usage?.cost) right.push({ segs: [{ text: model.usage.cost, role: "muted" }], priority: 3 });
+  return splitLine(width, left, right);
+}
+
+function handoffCounts(model: StatusModel): Seg[] {
+  const h = model.handoff;
+  if (!h) return [];
+  const out: Seg[] = [];
+  const add = (glyph: string, role: Seg["role"], count: number) => { if (count) out.push(...(out.length ? [{ text: " ", role: "muted" as const }] : []), { text: glyph, role }, { text: String(count), role: "text" }); };
+  add("✓", "success", h.verified.length);
+  add("…", "accent", h.inFlight.length);
+  add("?", "warning", h.unverified.length);
+  return out;
+}
+
+// ------------------------------------------------------------------- sidebar
+
+interface Block {
+  /** Rows that are always shown together (a header and its fixed facts). */
+  readonly head: readonly Line[];
+  /** Rows that may be cut, with a "+N more" row. */
+  readonly items: readonly Line[];
+  /** A list block with no items is not shown at all. */
+  readonly list: boolean;
+}
+
+/**
+ * The sidebar, `height` rows of at most `width` cells. Blocks are placed in
+ * priority order; a list gets at least two rows (or all of its items), then
+ * leftover rows go to the lists in the same order. A cut list ends in
+ * "+N more" so nothing disappears silently.
+ */
+export function sidebarLines(model: StatusModel, width: number, height: number): Line[] {
+  const w = Math.max(1, Math.floor(width)), h = Math.max(0, Math.floor(height));
+  const blocks = sidebarBlocks(model, w).filter(block => !block.list || block.items.length > 0);
+  const plan: { block: Block; rows: number }[] = [];
+  let used = 0;
+  for (const block of blocks) {
+    const minimum = block.list ? Math.min(block.items.length, 2) : 0;
+    const need = (plan.length ? 1 : 0) + block.head.length + minimum;
+    if (used + need > h) continue;
+    used += need;
+    plan.push({ block, rows: minimum });
+  }
+  for (const entry of plan) {
+    if (!entry.block.list) continue;
+    const extra = Math.min(entry.block.items.length - entry.rows, h - used);
+    if (extra > 0) { entry.rows += extra; used += extra; }
+  }
+  const out: Line[] = [];
+  plan.forEach((entry, index) => {
+    if (index) out.push([]);
+    out.push(...entry.block.head);
+    const items = entry.block.items;
+    if (entry.rows >= items.length) out.push(...items);
+    else if (entry.rows > 0) {
+      out.push(...items.slice(0, entry.rows - 1));
+      out.push([{ text: `+${items.length - entry.rows + 1} more`, role: "muted" }]);
+    }
+  });
+  return out.slice(0, h).map(line => clipSegs(line, w));
+}
+
+function sidebarBlocks(model: StatusModel, w: number): Block[] {
+  const blocks: Block[] = [];
+  const row = (left: readonly Seg[], right: readonly Seg[] = []): Line => right.length ? splitLine(w, [{ segs: left, priority: 0 }], [{ segs: right, priority: 1 }], 1) : left;
+  const title = model.title ? wrap(firstLine(model.title), w, 2) : ["New session"];
+  blocks.push({ list: false, items: [], head: [
+    row([{ text: "xeno", role: "text", bold: true }], [{ text: model.version, role: "muted" }]),
+    [],
+    ...title.map(text => [{ text, role: model.title ? "text" : "muted", bold: Boolean(model.title) }] as Line),
+    [{ text: clipText(model.workspace, w), role: "muted" }],
+    ...(model.branch ? [[{ text: "⎇ ", role: "muted" }, { text: model.branch, role: "muted" }] as Line] : []),
+  ] });
+  const context = model.context;
+  if (model.goal) blocks.push({ list: false, items: [], head: [
+    [{ text: "Goal", role: "text", bold: true }, { text: ` · ${model.goal.status}`, role: model.goal.status === "verified" ? "success" : "warning" }],
+    ...wrap(firstLine(model.goal.text), w, 2).map(text => [{ text, role: "text" }] as Line),
+    [{ text: model.goal.execution, role: "muted" }],
+    [{ text: `${model.goal.observations} observations · ${model.goal.retries} retries`, role: "muted" }],
+    [{ text: "/control · goal, evidence, context", role: "muted" }],
+  ] });
+  if (context) {
+    const share = contextShare(context), est = context.estimated ? "~" : "";
+    const filled = share === undefined ? 0 : Math.max(share > 0 ? 1 : 0, Math.round(share * w));
+    const tone = share !== undefined && share >= CONTEXT_WARNING ? "warning" : "accent";
+    const shareText = shareSeg(context);
+    blocks.push({ list: false, items: [], head: [
+      row([{ text: "Context", role: "text", bold: true }], shareText ? [shareText] : []),
+      ...(share === undefined ? [] : [[{ text: "━".repeat(filled), role: tone }, { text: "─".repeat(Math.max(0, w - filled)), role: "line" }] as Line]),
+      [{ text: `${est}${compact(context.used)}${context.window ? ` / ${compact(context.window)}` : ""}`, role: "text" }, { text: ` · node ${context.segment}`, role: "muted" }],
+      ...(context.trigger !== null ? [[{ text: `cut at ${est}${compact(context.trigger)}`, role: "muted" }] as Line] : []),
+    ] });
+  }
+  const usage = model.usage, tools = model.tools;
+  const toolCount = tools.done + tools.failed + tools.running;
+  if (usage || toolCount) {
+    blocks.push({ list: false, items: [], head: [
+      row([{ text: "Usage", role: "text", bold: true }], usage?.cost ? [{ text: usage.cost, role: "text" }] : []),
+      ...(usage ? [[{ text: `↑${compact(usage.input)} ↓${compact(usage.output)}`, role: "text" }, { text: `  cache ${Math.round(usage.cacheRate * 100)}%`, role: "muted" }] as Line] : []),
+      ...(toolCount ? [[
+        { text: `${tools.done} done`, role: "muted" },
+        ...(tools.failed ? [{ text: " · ", role: "muted" as const }, { text: `${tools.failed} failed`, role: "error" as const }] : []),
+        ...(tools.running ? [{ text: " · ", role: "muted" as const }, { text: `${tools.running} running`, role: "accent" as const }] : []),
+      ] as Line] : []),
+    ] });
+  }
+  const handoff = model.handoff;
+  if (handoff) {
+    const items: Line[] = [
+      ...handoff.verified.map(what => [{ text: "✓ ", role: "success" }, { text: what, role: "text" }] as Line),
+      ...handoff.inFlight.map(what => [{ text: "… ", role: "accent" }, { text: what, role: "text" }] as Line),
+      ...handoff.unverified.map(what => [{ text: "? ", role: "warning" }, { text: what, role: "text" }] as Line),
+    ];
+    blocks.push({ list: true, items, head: [row([{ text: "Handoff", role: "text", bold: true }], [{ text: "if cut now", role: "muted" }])] });
+  }
+  const tasks = model.tasks ?? [];
+  blocks.push({ list: true, head: [row([{ text: "Tasks", role: "text", bold: true }], [{ text: `${tasks.length} open`, role: "muted" }])],
+    items: tasks.map(task => [{ text: task.status === "blocked" ? "! " : "◐ ", role: task.status === "blocked" ? "warning" : "accent" }, { text: task.what, role: "text" }] as Line) });
+  const files = model.files ?? [];
+  blocks.push({ list: true, head: [row([{ text: "Files", role: "text", bold: true }], [{ text: String(files.length), role: "muted" }])],
+    items: files.map(file => fileLine(file, w)) });
+  const background = model.background ?? [];
+  blocks.push({ list: true, head: [row([{ text: "Background", role: "text", bold: true }], [{ text: String(background.length), role: "muted" }])],
+    items: background.map(what => [{ text: "⧗ ", role: "accent" }, { text: what, role: "text" }] as Line) });
+  const resources = model.resources;
+  if (resources && (resources.contextFiles.length || resources.skills || resources.extensions)) {
+    const parts = [
+      ...(resources.contextFiles.length ? [resources.contextFiles.length > 1 ? `${resources.contextFiles[0]} ×${resources.contextFiles.length}` : resources.contextFiles[0]!] : []),
+      ...(resources.skills ? [`${resources.skills} skill${resources.skills === 1 ? "" : "s"}`] : []),
+      ...(resources.extensions ? [`${resources.extensions} extension${resources.extensions === 1 ? "" : "s"}`] : []),
+    ];
+    blocks.push({ list: false, items: [], head: [[{ text: "Loaded", role: "text", bold: true }], [{ text: parts.join(" · "), role: "muted" }]] });
+  }
+  if (model.extension) blocks.push({ list: false, items: [], head: wrap(model.extension, w, 3).map(text => [{ text, role: "muted" }] as Line) });
+  return blocks;
+}
+
+function fileLine(file: FileStatus, w: number): Line {
+  const name = file.path.split("/").pop() || file.path;
+  const counts: Seg[] = file.edited && (file.added || file.removed)
+    ? [{ text: `+${file.added}`, role: "success" }, { text: " ", role: "muted" }, { text: `−${file.removed}`, role: "error" }] : [];
+  const glyph: Seg = { text: file.edited ? "✎ " : "· ", role: file.edited ? "text" : "muted" };
+  if (!counts.length) return [glyph, { text: name, role: file.edited ? "text" : "muted" }];
+  const room = Math.max(1, w - 2 - segsWidth(counts) - 1);
+  const shown = clipText(name, room);
+  return [glyph, { text: shown, role: "text" }, { text: " ".repeat(Math.max(1, w - 2 - displayWidth(shown) - segsWidth(counts))), role: "muted" }, ...counts];
+}
+
+/** The leading characters of `text` that fit in `width` cells. */
+function cells(text: string, width: number): string {
+  let out = "", used = 0;
+  for (const ch of text) { const w = displayWidth(ch); if (used + w > width) break; out += ch; used += w; }
+  return out;
+}
+
+/** Word-aware wrap (CJK breaks per character); at most `lines` rows, the last one cut with "…". */
+export function wrap(text: string, width: number, lines: number): string[] {
+  const w = Math.max(1, width);
+  const tokens = text.match(/\s+|[⺀-鿿豈-﫿＀-￯]|[^\s⺀-鿿豈-﫿＀-￯]+/g) ?? [];
+  const out: string[] = [];
+  let current = "";
+  for (const token of tokens) {
+    if (/^\s+$/.test(token)) { if (current && displayWidth(current) < w) current += " "; continue; }
+    if (displayWidth(current + token) <= w) { current += token; continue; }
+    if (current.trim()) out.push(current.trimEnd());
+    current = displayWidth(token) > w ? clipText(token, w) : token;
+  }
+  if (current.trim()) out.push(current.trimEnd());
+  if (out.length <= lines) return out;
+  const kept = out.slice(0, lines);
+  const last = kept[lines - 1]!;
+  kept[lines - 1] = `${displayWidth(last) + 1 <= w ? last : cells(last, w - 1).trimEnd()}…`;
+  return kept;
+}

package/src/tui/ui/styled.ts

@@ -0,0 +1,85 @@
+/**
+ * Small helpers that build OpenTUI StyledText from parts, plus the bridge
+ * from ANSI lines (extension renderers, coloured shell output) to chunks.
+ */
+import { RGBA, StyledText, TextAttributes, type TextChunk } from "@opentui/core";
+import { ansiSpans, type SpanColor } from "../ansi-spans.ts";
+import { rgba } from "./colors.ts";
+
+export interface Part {
+  readonly text: string;
+  /** An OpenTUI colour, or #rrggbb from a custom theme. */
+  readonly fg?: RGBA | string;
+  readonly bg?: RGBA | string;
+  readonly bold?: boolean;
+  readonly dim?: boolean;
+  readonly italic?: boolean;
+  readonly underline?: boolean;
+  /** Swap foreground and background (SGR 7): emphasis without painting a colour of our own. */
+  readonly inverse?: boolean;
+}
+
+/**
+ * OpenTUI draws uncoloured text in opaque white. Text with no colour of its
+ * own is the terminal's foreground instead (SGR 39), which is what keeps it
+ * legible on a light terminal (refactor-tui-terminal-colors).
+ */
+const TERMINAL_TEXT: RGBA = RGBA.defaultForeground();
+
+function chunk(text: string, fg?: RGBA, bg?: RGBA, attributes = 0, link?: string): TextChunk {
+  return { __isChunk: true, text, ...(fg ? { fg } : {}), ...(bg ? { bg } : {}), ...(attributes ? { attributes } : {}), ...(link ? { link: { url: link } } : {}) };
+}
+
+export function parts(...items: (Part | string | false | undefined)[]): StyledText {
+  const chunks: TextChunk[] = [];
+  for (const item of items) {
+    if (!item) continue;
+    if (typeof item === "string") { chunks.push(chunk(item, TERMINAL_TEXT)); continue; }
+    let attributes = 0;
+    if (item.bold) attributes |= TextAttributes.BOLD;
+    if (item.dim) attributes |= TextAttributes.DIM;
+    if (item.italic) attributes |= TextAttributes.ITALIC;
+    if (item.underline) attributes |= TextAttributes.UNDERLINE;
+    if (item.inverse) attributes |= TextAttributes.INVERSE;
+    chunks.push(chunk(item.text, color(item.fg) ?? TERMINAL_TEXT, color(item.bg), attributes));
+  }
+  return new StyledText(chunks);
+}
+
+function color(value: RGBA | string | undefined): RGBA | undefined {
+  return value === undefined ? undefined : typeof value === "string" ? rgba(value) : value;
+}
+
+/**
+ * Indexed colours from shell output, diffs and highlighters stay indexed, so
+ * the terminal draws them from its own palette (refactor-tui-terminal-colors);
+ * converting them to xterm's default RGB would repaint them in someone else's.
+ */
+const indexedCache = new Map<number, RGBA>();
+function spanColor(value: SpanColor | undefined): RGBA | undefined {
+  if (!value) return undefined;
+  if (value.kind === "rgb") return RGBA.fromInts(value.r, value.g, value.b, 255);
+  let ink = indexedCache.get(value.index);
+  if (!ink) { ink = RGBA.fromIndex(value.index); indexedCache.set(value.index, ink); }
+  return ink;
+}
+
+/** ANSI lines → one StyledText with newlines between rows. */
+export function ansiText(lines: readonly string[]): StyledText {
+  const chunks: TextChunk[] = [];
+  lines.forEach((line, row) => {
+    if (row > 0) chunks.push(chunk("\n"));
+    for (const span of ansiSpans(line)) {
+      const s = span.style;
+      let attributes = 0;
+      if (s.bold) attributes |= TextAttributes.BOLD;
+      if (s.dim) attributes |= TextAttributes.DIM;
+      if (s.italic) attributes |= TextAttributes.ITALIC;
+      if (s.underline) attributes |= TextAttributes.UNDERLINE;
+      if (s.reverse) attributes |= TextAttributes.INVERSE;
+      if (s.strikethrough) attributes |= TextAttributes.STRIKETHROUGH;
+      chunks.push(chunk(span.text, spanColor(s.fg) ?? TERMINAL_TEXT, spanColor(s.bg), attributes, s.link));
+    }
+  });
+  return new StyledText(chunks);
+}

package/src/tui/ui/testing.ts

@@ -0,0 +1,5 @@
+/**
+ * The headless renderer, re-exported so tests reach OpenTUI through the one
+ * directory allowed to import it (scripts/check-boundaries.ts, D20).
+ */
+export { createTestRenderer, type TestRendererSetup } from "@opentui/core/testing";

package/src/tui/ui/tool-card.ts

@@ -0,0 +1,150 @@
+/**
+ * Tool call → card summary, evidence and expanded detail. Pure.
+ *
+ * The card's one-line summary comes from the call's input (what was asked);
+ * its evidence comes from the logged result (what happened): an exit code,
+ * a diff's +/- counts, a line count. A model's narration is never evidence
+ * (D11), so nothing here reads assistant text.
+ */
+import { diffLines, renderDiff, wrapPlain } from "../diff.ts";
+import { ANSI, IDENTITY, PLAIN_ATTRS, paint, type Style } from "../style.ts";
+import { displayWidth } from "../width.ts";
+import type { ToolStatus } from "./items.ts";
+
+export interface ToolCall { readonly name: string; readonly input: unknown; readonly result: { readonly text: string; readonly ok: boolean; readonly data?: unknown } | null }
+export interface ToolCard { readonly summary: string; readonly status: ToolStatus; readonly evidence?: string }
+
+function record(value: unknown): Record<string, unknown> { return value !== null && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {}; }
+function str(value: unknown): string { return typeof value === "string" ? value : value === undefined || value === null ? "" : JSON.stringify(value); }
+
+export function exitCode(text: string): number | null {
+  const match = /^exit (-?\d+)/.exec(text);
+  return match ? Number(match[1]) : null;
+}
+
+function edits(input: Record<string, unknown>): { old: string; new: string }[] {
+  const list = Array.isArray(input["edits"]) ? input["edits"].map(record) : [input];
+  return list.map(edit => ({ old: str(edit["old_string"] ?? edit["old"]), new: str(edit["new_string"] ?? edit["new"]) }));
+}
+
+export function diffCounts(input: unknown): { added: number; removed: number } {
+  let added = 0, removed = 0;
+  for (const edit of edits(record(input))) for (const op of diffLines(edit.old, edit.new)) { if (op.kind === "add") added++; else if (op.kind === "del") removed++; }
+  return { added, removed };
+}
+
+/** One line: the argument a reader needs to recognise the call. */
+export function toolSummary(name: string, input: unknown): string {
+  const args = record(input);
+  switch (name) {
+    case "bash": return str(args["command"]).split("\n")[0] ?? "";
+    case "read": {
+      const offset = typeof args["offset"] === "number" ? args["offset"] : undefined;
+      const limit = typeof args["limit"] === "number" ? args["limit"] : undefined;
+      return `${str(args["path"])}${offset !== undefined ? `:${offset}${limit !== undefined ? `+${limit}` : ""}` : ""}`;
+    }
+    case "write": case "edit": return str(args["path"]);
+    case "grep": case "find": case "glob": return [str(args["pattern"]), str(args["path"])].filter(Boolean).join(" in ");
+    case "history": return [str(args["section"]) || (args["recent"] ? "recent activity" : "session history"), typeof args["node"] === "number" ? `node ${args["node"]}` : ""].filter(Boolean).join(" · ");
+    default: {
+      const first = Object.entries(args).find(([, value]) => typeof value === "string" && value.length > 0);
+      return first ? `${first[0]}=${str(first[1]).split("\n")[0]}` : "";
+    }
+  }
+}
+
+export function toolCard(call: ToolCall): ToolCard {
+  const summary = toolSummary(call.name, call.input);
+  if (!call.result) return { summary, status: "pending", ...(call.name === "edit" ? { evidence: plusMinus(call.input) } : {}) };
+  const { text, ok } = call.result;
+  const status: ToolStatus = ok ? "ok" : "error";
+  switch (call.name) {
+    case "bash": {
+      const code = exitCode(text);
+      return { summary, status, ...(code !== null ? { evidence: `exit ${code}` } : ok ? {} : { evidence: "failed" }) };
+    }
+    case "edit": return { summary, status, evidence: ok ? plusMinus(call.input) : "failed" };
+    case "write": {
+      const lines = str(record(call.input)["content"]).split("\n").length;
+      return { summary, status, evidence: ok ? `${lines} lines` : "failed" };
+    }
+    case "read": {
+      const data = record(call.result.data), start = data["start"], end = data["end"];
+      const lines = typeof start === "number" && typeof end === "number" && end >= start ? end - start + 1 : text ? text.split("\n").length : 0;
+      return { summary, status, evidence: ok ? `${lines} lines` : "failed" };
+    }
+    case "history": {
+      const data = record(jsonValue(text));
+      return { summary, status, ...(ok && typeof data["matches"] === "number" ? { evidence: `${data["matches"]} matches` } : ok ? {} : { evidence: "failed" }) };
+    }
+    default: return { summary, status, ...(ok ? {} : { evidence: "failed" }) };
+  }
+}
+
+function plusMinus(input: unknown): string {
+  const { added, removed } = diffCounts(input);
+  return `+${added} −${removed}`;
+}
+
+/** Expanded body: input that matters, then the result. Width-bounded ANSI lines. */
+export function toolDetail(call: ToolCall, width: number, style: Style = ANSI): string[] {
+  const w = Math.max(1, width);
+  // Semantic colour, never SGR faint: faint made already-muted arguments unreadable.
+  const dim = (text: string) => style.token?.("muted", text) ?? text;
+  const red = (text: string) => style === IDENTITY ? text : paint(text, { ...PLAIN_ATTRS, error: true }, style);
+  const clip = (line: string) => truncate(line, w);
+  const args = record(call.input);
+  const out: string[] = [];
+  switch (call.name) {
+    case "bash": out.push(...str(args["command"]).split("\n").map(line => clip(`$ ${line}`))); break;
+    case "edit": for (const edit of edits(args)) out.push(...renderDiff(edit.old, edit.new, w, style)); break;
+    case "write": out.push(...str(args["content"]).split("\n").flatMap(line => wrapPlain(line, w)).map(dim)); break;
+    case "read": break;
+    default: {
+      const json = JSON.stringify(call.input, null, 2) ?? "";
+      out.push(...json.split("\n").flatMap(line => wrapPlain(line, w)).map(dim));
+    }
+  }
+  if (call.result) {
+    const body = call.name === "bash" ? call.result.text.replace(/^exit -?\d+[^\n]*\n?/, "") : call.result.text;
+    const parsed = jsonValue(body);
+    const readable = parsed !== undefined ? JSON.stringify(parsed, null, 2) : body;
+    const lines = readable ? readable.replace(/\s+$/, "").split("\n").flatMap(line => wrapPlain(line, w)) : [];
+    if (lines.length && out.length) out.push("");
+    const paintLine = call.result.ok ? (line: string) => clip(line) : (line: string) => red(clip(line));
+    out.push(...lines.map(paintLine));
+  } else out.push(dim("running…"));
+  return out;
+}
+
+function jsonValue(text: string): unknown {
+  if (!/^[\s]*[\[{]/.test(text)) return undefined;
+  try { return JSON.parse(text) as unknown; } catch { return undefined; }
+}
+
+/** Brief logged output stays visible even when details are folded. */
+export function toolPreview(call: ToolCall): string[] {
+  if (!call.result) return [];
+  let raw = call.result.text.replace(/^exit -?\d+[^\n]*\n?/, "").trim();
+  // The read result's provenance remains in expanded details. Its preview
+  // shows the selected source lines instead of an opaque version fingerprint.
+  if (call.name === "read") raw = raw.replace(/^\[Read selection:[^\n]*\nsha256:[^\n]*\n/, "");
+  const parsed = jsonValue(raw), data = record(parsed);
+  if (Array.isArray(data["items"])) {
+    const items = data["items"] as unknown[];
+    return items.slice(0, 2).map(value => { const item = record(value); return str(item["text"] ?? item["what"] ?? item["path"] ?? item["kind"] ?? value).replace(/\s+/g, " "); });
+  }
+  if (parsed !== undefined) return Object.entries(data).filter(([key]) => key !== "source").slice(0, 2).map(([key, value]) => `${key}  ${typeof value === "object" && value !== null ? Array.isArray(value) ? `${value.length} items` : Object.keys(value).join(", ") : str(value)}`);
+  return raw.split("\n").filter(Boolean).slice(0, 2);
+}
+
+function truncate(line: string, width: number): string {
+  if (displayWidth(line) <= width) return line;
+  let out = "", used = 0;
+  for (const ch of line) {
+    const w = displayWidth(ch);
+    if (used + w > width - 1) break;
+    out += ch; used += w;
+  }
+  return out + "…";
+}