@visual-z/xeno 0.8.4 → 0.9.1

package/src/tui/ui/status.ts

@@ -1,403 +0,0 @@
-/**
- * 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";
-import { formatElapsed } from "./duration.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;
-  /**
-   * An explicit /goal, prepared by apps from the log (core/goal-view.ts). The
-   * block exists only while a goal is set, and for one message after it is met.
-   */
-  readonly goal?: GoalStatusView;
-  /** Without a goal: the latest check after this request's last edit, when it changed files. */
-  readonly checks?: { readonly status: "unchecked" | "pass" | "fail" | "stale" | "partial"; readonly command?: string; readonly exit?: number };
-  readonly workspace: string;
-  readonly workspaceShort: string;
-  readonly branch: string | null;
-  readonly mode?: { readonly yolo: boolean; readonly workflow: "build" | "plan" };
-  readonly provider?: { readonly name: string; readonly api: string; readonly host: string | null; readonly role: string | null; readonly ready: boolean };
-  readonly activity?: { readonly state: string; readonly label: string; readonly detail: string; readonly queued: number };
-  readonly git?: { readonly staged: number; readonly changed: number; readonly untracked: number; readonly conflicted: number; readonly ahead: number; readonly behind: number } | null;
-  readonly context?: ContextStatus;
-  /** `speed`: output tokens per second over this turn's model requests (runtime/usage.ts generationSpeed). */
-  readonly usage?: { readonly input: number; readonly output: number; readonly cacheRate: number; readonly cost: string | null; readonly speed?: number };
-  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 interface GoalStatusView {
-  readonly phase: "drafting" | "working" | "needs_you" | "met" | "stopped";
-  readonly objective: string;
-  readonly elapsedMs: number;
-  readonly checks: readonly { readonly id: string; readonly kind: "command" | "human" | "fresh_check"; readonly status: string; readonly guard?: true; readonly exit?: number }[];
-  /** S.1: one glyph per rung (ran, tests the change, independent, human), prepared by apps. */
-  readonly ladder?: { readonly glyphs: string; readonly summary: string };
-  /** Model requests since the goal was set (from the log) and output tokens this process saw. */
-  readonly requests: number;
-  readonly tokens?: number;
-}
-
-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 names the measured budget: `seg ~12%` or `model ~12%`. */
-export function contextLabel(model: StatusModel): Label | undefined {
-  const share = model.context && shareSeg(model.context);
-  return share ? { segs: [{ text: model.context?.trigger === null ? "model " : "seg ", role: "muted" }, share], priority: 3 } : undefined;
-}
-
-export function modeLabels(model: StatusModel): Label[] {
-  if (!model.mode) return [];
-  return [
-    { segs: [{ text: model.mode.yolo ? "YOLO" : "Approval", role: model.mode.yolo ? "warning" : "muted", bold: model.mode.yolo }], priority: 0 },
-    { segs: [{ text: model.mode.workflow === "plan" ? "Plan" : "Build", role: "accent" }], priority: 0 },
-  ];
-}
-
-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[] {
-  if (model.provider) {
-    const provider = model.provider;
-    return splitLine(width, [
-      { segs: [{ text: "xeno", role: "text", bold: true }], priority: 0 },
-      { segs: [{ text: `${provider.ready ? "" : "! "}${provider.name}`, role: provider.ready ? "text" : "warning" }], priority: 0, min: 6 },
-      { segs: [{ text: provider.api, role: "muted" }], priority: 2, min: 8 },
-      ...(provider.host ? [{ segs: [{ text: provider.host, role: "muted" as const }], priority: 3, min: 8 }] : []),
-      ...(provider.role ? [{ segs: [{ text: `agent ${provider.role}`, role: "accent" as const }], priority: 1, min: 8 }] : []),
-    ], model.title ? [{ segs: [{ text: firstLine(model.title), role: "muted" }], priority: 4, min: 12 }] : []);
-  }
-  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;
-  /** Rows shown after the items, kept with the head (the goal's ladder and spend). */
-  readonly tail?: readonly Line[];
-  /** A list shown even without items: a goal being drafted has no checks yet. */
-  readonly keep?: 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 || block.keep);
-  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 + (block.tail?.length ?? 0);
-    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" }]);
-    }
-    out.push(...entry.block.tail ?? []);
-  });
-  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] : []),
-    ...(model.git ? [[{ text: `${model.git.staged} staged · ${model.git.changed} changed · ${model.git.untracked} new`, role: "muted" }] as Line,
-      ...(model.git.conflicted ? [[{ text: `${model.git.conflicted} conflicts`, role: "warning" }] as Line] : []),
-      ...(model.git.ahead || model.git.behind ? [[{ text: `↑${model.git.ahead} ↓${model.git.behind}`, role: "muted" }] as Line] : [])] : model.git === null ? [[{ text: "Git unavailable", role: "muted" }] as Line] : []),
-  ] });
-  const goal = model.goal;
-  if (goal) blocks.push(goalBlock(goal, w, row));
-  else if (model.checks) blocks.push({ list: false, items: [], head: [checksLine(model.checks, w)] });
-  const context = model.context;
-  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);
-    // Two budgets, each named: the segment cut (what the bar shows) and the model window. Both shares
-    // ride on the heading, both denominators on one row below the bar.
-    const modelShare = context.window && context.trigger !== null ? `${est}${Math.round(context.used / context.window * 100)}%` : undefined;
-    const segment = context.trigger !== null ? `seg ${est}${compact(context.used)} / ${est}${compact(context.trigger)}` : `${est}${compact(context.used)} · no cut`;
-    blocks.push({ list: false, items: [], head: [
-      row([{ text: "Context", role: "text", bold: true }], [
-        ...(shareText ? [{ text: context.trigger === null ? "model " : "seg ", role: "muted" as const }, shareText] : []),
-        ...(modelShare ? [{ text: ` · model ${modelShare}`, role: "muted" as const }] : [])]),
-      ...(share === undefined ? [] : [[{ text: "━".repeat(filled), role: tone }, { text: "─".repeat(Math.max(0, w - filled)), role: "line" }] as Line]),
-      row([{ text: segment, role: "muted" }], [{ text: context.window ? `model ${compact(context.window)}` : "window unknown", role: "muted" }]),
-    ] });
-  }
-  const usage = model.usage, tools = model.tools;
-  const toolCount = tools.done + tools.failed + tools.running;
-  if (usage || toolCount) {
-    const figures = usage ? [`↑${compact(usage.input)} ↓${compact(usage.output)}`, `cache ${Math.round(usage.cacheRate * 100)}%`,
-      ...(usage.speed !== undefined ? [speedText(usage.speed)] : [])].join(" · ") : "";
-    // Heading with the cost; one row of figures below it. Together they need about 49 columns, more than the 34-42 the sidebar has.
-    blocks.push({ list: false, items: [], head: [
-      row([{ text: "Usage", role: "text", bold: true }], usage?.cost ? [{ text: usage.cost, role: "text" }] : []),
-      ...(figures ? [[{ text: figures, role: "muted" }] as Line] : []),
-      ...(tools.failed || tools.running ? [[
-        { 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: "Agent 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;
-}
-
-/** `42 tok/s`; under 10 one decimal, so a slow upstream does not read as zero. */
-export function speedText(speed: number): string {
-  return `${speed < 10 ? speed.toFixed(1) : Math.round(speed)} tok/s`;
-}
-
-const PHASE: Record<GoalStatusView["phase"], { label: string; role: Seg["role"] }> = {
-  drafting: { label: "drafting", role: "accent" }, working: { label: "working", role: "accent" },
-  needs_you: { label: "needs you", role: "warning" }, met: { label: "met", role: "success" }, stopped: { label: "stopped", role: "warning" },
-};
-
-/**
- * `Goal · needs you   4m 12s`, the objective, one row per accepted check with
- * what it needs, the evidence ladder and what the goal has spent. A met goal
- * is one summary row. The sidebar may cut the checks; a cut ends in "+N more".
- */
-function goalBlock(goal: GoalStatusView, w: number, row: (left: readonly Seg[], right?: readonly Seg[]) => Line): Block {
-  const phase = PHASE[goal.phase];
-  const passed = goal.checks.filter(check => check.status === "pass" || check.status === "accepted").length;
-  const elapsed = goal.phase === "drafting" ? [] : [{ text: formatElapsed(goal.elapsedMs), role: "muted" as const }];
-  const title = [{ text: "Goal", role: "text" as const, bold: true }, { text: ` · ${phase.label}`, role: phase.role }];
-  if (goal.phase === "met") return { list: false, items: [], head: [row(title, [{ text: `${passed}/${goal.checks.length} · `, role: "muted" }, ...elapsed])] };
-  const items = goal.checks.map(check => {
-    const done = check.status === "pass" || check.status === "accepted";
-    const glyph: Seg = done ? { text: "✓ ", role: "success" } : check.status === "fail" ? { text: "✗ ", role: "error" } : { text: "○ ", role: "muted" };
-    const need = check.kind === "human" && !done ? `/accept ${check.id}` : check.status === "fail" && check.exit !== undefined ? `exit ${check.exit}`
-      : check.status === "stale" ? "rerun" : check.guard ? "guard" : "";
-    return row([glyph, { text: check.id, role: "text" }], need ? [{ text: need, role: check.kind === "human" && !done ? "warning" : "muted" }] : []);
-  });
-  const spent = [`${goal.requests} ${goal.requests === 1 ? "request" : "requests"}`, ...(goal.tokens ? [`${compact(goal.tokens)} tokens this run`] : [])].join(" · ");
-  return { list: true, keep: true, head: [row(title, elapsed), ...wrap(firstLine(goal.objective), w, 2).map(text => [{ text, role: "text" }] as Line)],
-    items, ...(goal.phase === "drafting" ? {} : { tail: [...(goal.ladder ? [[{ text: goal.ladder.glyphs, role: "text" }] as Line] : []), [{ text: spent, role: "muted" }] as Line] }) };
-}
-
-/** Without a goal: whether a check has passed since this request's last edit. */
-function checksLine(checks: NonNullable<StatusModel["checks"]>, w: number): Line {
-  if (checks.status === "unchecked" || !checks.command) return [{ text: "Checks", role: "text", bold: true }, { text: " · not run since last edit", role: "warning" }];
-  // partial: some of a declared contract holds; the rest may only be waiting for the user, so it is not a failure mark.
-  const mark: Seg[] = checks.status === "pass" ? [{ text: " ✓", role: "success" }] : checks.status === "partial" ? []
-    : checks.status === "fail" ? [{ text: " ✗", role: "error" }, ...(checks.exit === undefined ? [] : [{ text: ` exit ${checks.exit}`, role: "muted" as const }])]
-    : [{ text: " stale", role: "warning" }];
-  const room = Math.max(1, w - segsWidth(mark) - "Checks · ".length);
-  return [{ text: "Checks", role: "text", bold: true }, { text: ` · ${clipText(checks.command, room)}`, role: "muted" }, ...mark];
-}
-
-/** Without a sidebar the goal rides on the input box's bottom edge: `goal 2/3 · needs you · 4m 12s`. */
-export function goalLabel(model: StatusModel): Label | undefined {
-  const goal = model.goal;
-  if (!goal) return undefined;
-  const passed = goal.checks.filter(check => check.status === "pass" || check.status === "accepted").length;
-  const parts = [`goal ${goal.phase === "drafting" ? "" : `${passed}/${goal.checks.length} · `}${PHASE[goal.phase].label}`,
-    ...(goal.phase === "drafting" ? [] : [formatElapsed(goal.elapsedMs)])];
-  return { segs: [{ text: parts.join(" · "), role: goal.phase === "needs_you" ? "warning" : "muted" }], priority: 2, min: 8 };
-}
-
-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;
-}
-
-/**
- * The input box's top-edge label while no turn runs: the outcome in its own
- * colour, then how long the last turn took (Codex "Worked for 2m 5s", Claude
- * Code "Cooked for 1m 6s"). A plain grey "Turn finished" read the same as
- * "nothing happened" (fix-finished-turn-status).
- */
-export function idleActivityLabel(activity: NonNullable<StatusModel["activity"]>, turnMs?: number): Label {
-  const tone = activity.state === "done" ? { glyph: "✓", role: "success" as const }
-    : activity.state === "error" ? { glyph: "✗", role: "error" as const }
-    : activity.state === "blocked" ? { glyph: activity.label === "Stopped" ? "■" : "", role: "warning" as const }
-    : { glyph: "", role: "muted" as const };
-  const text = activity.label === "Stopped" && activity.detail ? `Stopped · ${activity.detail}` : activity.label;
-  return { segs: [...(tone.glyph ? [{ text: tone.glyph, role: tone.role }, { text: " ", role: "muted" as const }] : []), { text, role: tone.role },
-    ...(turnMs !== undefined ? [{ text: ` · ${formatElapsed(turnMs)}`, role: "muted" as const }] : [])], priority: 1, min: 4, shrink: tone.glyph ? 2 : 0 };
-}

package/src/tui/ui/styled.ts

@@ -1,85 +0,0 @@
-/**
- * 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/tool-card.ts

@@ -1,150 +0,0 @@
-/**
- * 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 + "…";
-}