rovecode 0.4.0-beta.3 → 0.4.0

package/src/tui/sextant-attach.ts

@@ -0,0 +1,68 @@
+/** Port #44: the attach context the app hands a Renderer that implements `attach` (the sextant surface)
+ *  — extracted from app.ts for the ADR-002 line cap. The panels read the runtime through these closures
+ *  ONLY: the active store (swapped by /sessions, /resume and a root /rewind — read live, never captured),
+ *  the task manager, the current mode's model, the catalog's context window and the /cost math over the
+ *  active transcript (tui/cost.ts sessionUsage — priced per message at its origin model). */
+
+import type { SessionStore } from "../core/session.ts";
+import type { TaskManager } from "../core/tasks.ts";
+import type { ModelCatalog } from "../providers/catalog.ts";
+import type { SextantAttach } from "../sextant/types.ts";
+import type { LiveRuntime } from "../sextant/context-source.ts";
+import { sessionUsage } from "./cost.ts";
+
+/** slash names the sextant surface handles itself before onSubmit (keys.ts runLocal — the future
+ *  src/sextant/local-commands.ts); reserved against custom commands like the built-ins, so a
+ *  `.rovecode/commands/theme.md` warns and loses instead of silently never being reachable. */
+export const SEXTANT_LOCAL_NAMES: readonly string[] = ["theme", "open", "diff", "focus", "agents", "notices", "context"];
+
+export interface AttachSources {
+  cwd: string;
+  sessionsDir: string;
+  /** the ACTIVE store, read live */
+  store(): SessionStore;
+  tasks: TaskManager;
+  /** the current mode's model */
+  model(): { provider: string; model: string };
+  catalog: ModelCatalog;
+  /** the LIVE runtime, for /context. A function rather than a value: /sessions and /resume swap what is
+   *  underneath, and a captured runtime would report on the session the human left. Returning null is
+   *  allowed and means the panel says its total is a floor. */
+  runtime?: () => LiveRuntime | null;
+  /** `--pet <name>` */
+  petName?: string;
+}
+
+export function buildSextantAttach(a: AttachSources): SextantAttach {
+  return {
+    cwd: a.cwd,
+    sessionsDir: a.sessionsDir,
+    store: () => ({ id: a.store().id }),
+    tasks: a.tasks,
+    model: a.model,
+    contextWindow: () => { const m = a.model(); return a.catalog.lookup(m.provider, m.model)?.contextWindow; },
+    usage: () => sessionUsage(a.store().messages(), a.catalog, a.model()),
+    // /context counts the real transcript against the real catalog, and asks the live runtime for the
+    // system prompt and the tool schemas — the two rows a transcript cannot know and a fresh window is
+    // mostly made of. The tier travels with the pricing, or a long xAI turn is billed at half rate.
+    contextInputs: () => ({
+      messages: a.store().messages(),
+      lookup: (r) => {
+        const info = a.catalog.lookup(r.provider, r.model);
+        if (!info) return undefined;
+        return {
+          ...(info.contextWindow !== undefined ? { contextWindow: info.contextWindow } : {}),
+          ...(info.pricing ? { pricing: info.pricing } : {}),
+          ...(info.tier ? { tier: info.tier } : {}),
+        };
+      },
+      runtime: a.runtime?.() ?? null,
+    }),
+    // /market installs an MCP server into a file this session already read; without this the only way to
+    // reach it was to quit and start again, which is a poor answer to "I just installed it"
+    reloadMcp: async () => { const rt = a.runtime?.(); return (await rt?.reloadMcp?.()) ?? { added: [], removed: [], failed: [], skipped: [] }; },
+    // the images staged for the next message (tui/attach.ts /attach, /paste) — read live, the store owns them
+    staged: () => a.store().stagedAttachments.map((p) => p.name ?? "image"),
+    ...(a.petName !== undefined ? { petName: a.petName } : {}),
+  };
+}

package/src/tui/sextant-io.ts

@@ -0,0 +1,184 @@
+/** Sextant terminal I/O + surface choice (port #44). The ONE module on the sextant path that touches
+ *  vendor: ProcessIO drives process.stdin/stdout (raw mode, utf8, resize, and pi-tui's Windows
+ *  ENABLE_VIRTUAL_TERMINAL_INPUT helper — without it libuv's console reader drops modifier state and
+ *  Shift+Tab arrives as a plain \t instead of CSI Z; the helper is loaded AFTER setRawMode(true), which
+ *  resets the console mode, exactly as vendor/pi-tui/src/terminal.ts:186-190 does). MemoryIO is the
+ *  in-memory double tests and the smoke drive. chooseSurface() is the pure `rovecode` default rule:
+ *  sextant only on a TTY of at least 100×30 that renders truecolor or 256 colors (the #40 quantizer
+ *  paints the latter); `--classic` beats everything; ROVECODE_TUI=classic|sextant overrides the heuristics
+ *  (a non-TTY still never gets sextant, nor does a TTY under the 40×12 Screen floor). */
+
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { getNativeModuleCandidates } from "../../vendor/pi-tui/src/native-module-path.ts";
+import { MIN_COLS, MIN_ROWS } from "../sextant/screen.ts";
+import { SextantRenderer } from "../sextant/sextant-renderer.ts";
+import { SEXTANT_MIN_COLS, SEXTANT_MIN_ROWS, type TerminalIO } from "../sextant/types.ts";
+import type { Renderer } from "./renderer.ts";
+
+const cjsRequire = createRequire(import.meta.url);
+/** the vendored pi-tui source dir — getNativeModuleCandidates resolves `native/…` beside it */
+const VENDOR_TUI_URL = new URL("../../vendor/pi-tui/src/terminal.ts", import.meta.url).href;
+
+export type Env = Readonly<Record<string, string | undefined>>;
+
+/** where pi-tui's prebuilt console-mode helper may live (vendor tree, or beside a compiled binary) */
+export function vtInputCandidates(arch: string = process.arch, execPath: string = process.execPath): string[] {
+  return getNativeModuleCandidates(join("native", "win32", "prebuilds", `win32-${arch}`, "win32-console-mode.node"), { moduleUrl: VENDOR_TUI_URL, execPath });
+}
+
+/** pi-tui terminal.ts enableWindowsVTInput: flip ENABLE_VIRTUAL_TERMINAL_INPUT on the stdin console;
+ *  false when the helper is unavailable (Shift+Tab is then indistinguishable from Tab) */
+export function enableWindowsVTInput(arch: string = process.arch): boolean {
+  if (arch !== "x64" && arch !== "arm64") return false;
+  for (const p of vtInputCandidates(arch)) {
+    try {
+      const helper = cjsRequire(p) as { enableVirtualTerminalInput?: () => boolean };
+      return helper.enableVirtualTerminalInput?.() ?? false;
+    } catch { /* try the next packaging location */ }
+  }
+  return false;
+}
+
+/** the slice of process.stdin the surface uses (tests inject a fake) */
+export interface RawStdin {
+  isRaw?: boolean;
+  setRawMode?(mode: boolean): unknown;
+  setEncoding(enc: BufferEncoding): unknown;
+  resume(): unknown;
+  pause(): unknown;
+  on(event: "data", cb: (chunk: string | Buffer) => void): unknown;
+  off(event: "data", cb: (chunk: string | Buffer) => void): unknown;
+}
+/** the slice of process.stdout the surface uses */
+export interface RawStdout {
+  write(s: string): unknown;
+  isTTY?: boolean;
+  columns?: number;
+  rows?: number;
+  on(event: "resize", cb: () => void): unknown;
+  off(event: "resize", cb: () => void): unknown;
+}
+export interface ProcessIOOptions {
+  /** default process.platform; the VT helper runs on win32 only */
+  platform?: string;
+  /** the VT-input helper (default enableWindowsVTInput) */
+  vtInput?: () => boolean;
+}
+
+export class ProcessIO implements TerminalIO {
+  private wasRaw = false;
+  constructor(
+    private readonly stdin: RawStdin = process.stdin,
+    private readonly stdout: RawStdout = process.stdout,
+    readonly env: Env = process.env,
+    private readonly opts: ProcessIOOptions = {},
+  ) {}
+  write(s: string): void { this.stdout.write(s); }
+  onInput(cb: (chunk: string) => void): () => void {
+    const h = (d: string | Buffer): void => cb(typeof d === "string" ? d : d.toString("utf8"));
+    this.stdin.on("data", h);
+    return () => { this.stdin.off("data", h); };
+  }
+  onResize(cb: (cols: number, rows: number) => void): () => void {
+    const h = (): void => { const { cols, rows } = this.size(); cb(cols, rows); };
+    this.stdout.on("resize", h);
+    return () => { this.stdout.off("resize", h); };
+  }
+  size(): { cols: number; rows: number } { return { cols: this.stdout.columns || 80, rows: this.stdout.rows || 24 }; }
+  /** raw mode + utf8 + flowing, then the Windows VT-input helper (must follow setRawMode, which resets the console flags) */
+  enterRaw(): void {
+    this.wasRaw = this.stdin.isRaw ?? false;
+    this.stdin.setRawMode?.(true);
+    this.stdin.setEncoding("utf8");
+    this.stdin.resume();
+    if ((this.opts.platform ?? process.platform) === "win32") (this.opts.vtInput ?? enableWindowsVTInput)();
+  }
+  /** restore the previous raw state and pause stdin so buffered bytes never reach the parent shell */
+  leaveRaw(): void {
+    this.stdin.setRawMode?.(this.wasRaw);
+    this.stdin.pause();
+  }
+}
+
+/** in-memory TerminalIO: records writes, replays fed input, emulates resizes (tests + `smoke-tui --sextant`) */
+export class MemoryIO implements TerminalIO {
+  readonly writes: string[] = [];
+  raw = false;
+  private readonly inputs = new Set<(chunk: string) => void>();
+  private readonly resizes = new Set<(cols: number, rows: number) => void>();
+  constructor(public cols = 160, public rows = 44, readonly env: Env = {}) {}
+  write(s: string): void { this.writes.push(s); }
+  onInput(cb: (chunk: string) => void): () => void { this.inputs.add(cb); return () => { this.inputs.delete(cb); }; }
+  onResize(cb: (cols: number, rows: number) => void): () => void { this.resizes.add(cb); return () => { this.resizes.delete(cb); }; }
+  size(): { cols: number; rows: number } { return { cols: this.cols, rows: this.rows }; }
+  enterRaw(): void { this.raw = true; }
+  leaveRaw(): void { this.raw = false; }
+  /** deliver raw terminal bytes (keys, mouse, paste) */
+  feed(chunk: string): void { for (const cb of [...this.inputs]) cb(chunk); }
+  resize(cols: number, rows: number): void { this.cols = cols; this.rows = rows; for (const cb of [...this.resizes]) cb(cols, rows); }
+  /** everything written so far */
+  output(): string { return this.writes.join(""); }
+  /** live input + resize subscriptions (0 after stop) */
+  get listeners(): number { return this.inputs.size + this.resizes.size; }
+}
+
+// ------------------------------------------------------------------ surface choice
+
+const TC_PROGRAMS = new Set(["vscode", "iTerm.app", "WezTerm", "ghostty"]);
+
+/** the terminal renders 24-bit color: COLORTERM truecolor/24bit, Windows Terminal (WT_SESSION), a
+ *  known TERM_PROGRAM (vscode, iTerm.app, WezTerm, ghostty) or a kitty/`-direct` TERM */
+export function truecolor(env: Env): boolean {
+  const ct = (env.COLORTERM ?? "").toLowerCase();
+  if (ct === "truecolor" || ct === "24bit") return true;
+  if (env.WT_SESSION) return true;
+  if (TC_PROGRAMS.has(env.TERM_PROGRAM ?? "")) return true;
+  return /kitty|direct/.test(env.TERM ?? "");
+}
+
+export type ColorDepth = "truecolor" | "256" | "none";
+
+/** what the terminal renders: truecolor per the heuristics above; else 256 colors when TERM says so
+ *  (xterm-256color, screen-/tmux-256color) and COLORTERM is silent — the surface then paints through the
+ *  #40 quantizer (SGR 38;5); else nothing sextant can use */
+export function colorDepth(env: Env): ColorDepth {
+  if (truecolor(env)) return "truecolor";
+  if (!(env.COLORTERM ?? "").trim() && /256color/.test(env.TERM ?? "")) return "256";
+  return "none";
+}
+
+export interface StdoutInfo { isTTY?: boolean; columns?: number; rows?: number }
+
+/** the heuristic: a TTY of at least SEXTANT_MIN_COLS×SEXTANT_MIN_ROWS with truecolor or 256 colors */
+export function sextantOk(env: Env, stdout: StdoutInfo): boolean {
+  return !!stdout.isTTY && (stdout.columns ?? 0) >= SEXTANT_MIN_COLS && (stdout.rows ?? 0) >= SEXTANT_MIN_ROWS && colorDepth(env) !== "none";
+}
+
+/** the Screen floor (screen.ts MIN_COLS×MIN_ROWS): below it the cell buffer is larger than the terminal
+ *  (39-cell rows into a 30-column window), so even a forced sextant yields; an unknown size counts as
+ *  the 80×24 ProcessIO.size() falls back to */
+export function fitsFloor(stdout: StdoutInfo): boolean {
+  return (stdout.columns ?? 80) >= MIN_COLS && (stdout.rows ?? 24) >= MIN_ROWS;
+}
+
+export type Surface = "sextant" | "classic";
+
+/** `--classic` wins; ROVECODE_TUI=classic forces classic, ROVECODE_TUI=sextant forces sextant on any TTY at or
+ *  above the 40×12 floor (the 100×30 and color heuristics skipped); otherwise sextantOk(). A non-TTY
+ *  stdout never gets sextant. */
+export function chooseSurface(cli: { classic: boolean }, env: Env, stdout: StdoutInfo): Surface {
+  if (cli.classic) return "classic";
+  const force = (env.ROVECODE_TUI ?? "").trim().toLowerCase();
+  if (force === "classic") return "classic";
+  if (force === "sextant") return stdout.isTTY && fitsFloor(stdout) ? "sextant" : "classic";
+  return sextantOk(env, stdout) ? "sextant" : "classic";
+}
+
+/** main.ts: the renderer to hand runTui — a SextantRenderer over the process terminal (truecolor SGR, or
+ *  the 256-color quantizer when that is all the terminal declares), or undefined (runTui then builds the
+ *  classic PiTuiRenderer exactly as before) */
+export function pickRenderer(cli: { classic: boolean; pet?: string }, env: Env = process.env, stdout: RawStdout = process.stdout): Renderer | undefined {
+  if (chooseSurface(cli, env, stdout) !== "sextant") return undefined;
+  return new SextantRenderer({ io: new ProcessIO(process.stdin, stdout, env), truecolor: colorDepth(env) === "truecolor", ...(cli.pet !== undefined ? { pet: cli.pet } : {}), ...(env.ROVECODE_THEME ? { theme: env.ROVECODE_THEME } : {}) });
+}

package/src/tui/sextant-smoke.ts

@@ -0,0 +1,110 @@
+/** `rovecode smoke-tui --sextant` (port #44): the sextant surface end-to-end through the real pipeline —
+ *  agentLoop → SextantRenderer → Screen → an in-memory TerminalIO at 160×44 (no @xterm/headless, so it
+ *  also runs from an installed tree or the compiled binary). Gated session: a scripted write, then an
+ *  anchored edit of that file, each raise the approval card and are allowed once the card is on
+ *  screen; a text turn closes the run; ⌃c quits and the terminal must be restored (leave sequence in
+ *  the output tail, frame interval cleared). Prints the edit's card frame and the final frame; the CLI
+ *  wrapper exits 0 iff every stage rendered. */
+
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileTag, lineHash } from "../coding/hashline.ts";
+import { mockStream, textTurn, toolTurn } from "../providers/stream.ts";
+import { SextantRenderer } from "../sextant/sextant-renderer.ts";
+import { runTui } from "./app.ts";
+import { MemoryIO } from "./sextant-io.ts";
+
+export interface SextantSmokeResult {
+  ok: boolean;
+  reasons: string[];
+  /** the frame with the edit's approval card on screen */
+  cardFrame: string;
+  /** the final frame */
+  frame: string;
+  /** the last 400 bytes written to the terminal (the leave sequence lives here) */
+  tail: string;
+}
+
+const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms));
+/** the two approval cards, in order: the write's, then the edit's */
+const CARDS: readonly RegExp[] = [/needs your permission\s+write\b/, /needs your permission\s+edit\b/];
+/** what quitting must leave in the output: main screen, cursor shown, SGR mouse off, bracketed paste off */
+const LEAVE: readonly string[] = ["\x1b[?1049l", "\x1b[?25h", "\x1b[?1006l", "\x1b[?2004l"];
+
+/** drive the surface headlessly and report; never exits the process (runSextantSmoke does) */
+export async function sextantSmoke(opts: { cols?: number; rows?: number; deadlineMs?: number } = {}): Promise<SextantSmokeResult> {
+  const cwd = mkdtempSync(join(tmpdir(), "rovecode-sextant-smoke-"));
+  const io = new MemoryIO(opts.cols ?? 160, opts.rows ?? 44, { COLORTERM: "truecolor" });
+  const renderer = new SextantRenderer({ io, cwd, pet: "rovecode" });
+  const probe = join(cwd, "smoke.txt");
+  const written = "smoke-ok\n";
+  const stream = mockStream({
+    turns: [
+      toolTurn([{ id: "t1", tool: "write", args: { path: probe, content: written } }]),
+      toolTurn([{ id: "t2", tool: "edit", args: { path: probe, edits: [{ tag: fileTag(written), anchorLine: 1, anchorHash: lineHash("smoke-ok"), newLines: ["smoke-edited"] }] } }]),
+      textTurn("Smoke OK — the sextant surface rendered a write, an anchored edit and this summary."),
+    ],
+  });
+  const reasons: string[] = [];
+  // The whole assertion below is "two approval cards appear", so the permission level is pinned here rather
+  // than inherited from the machine: a ~/.rovecode/settings.json with "permission":"auto" allowed the write
+  // and the edit without a card and the smoke FAILED with "approval cards seen 0/2". `yolo: false` cannot
+  // pin it — app.ts treats false as "no flag" and lets the settings file win; `permission` is the flag rung.
+  const app = runTui({ renderer, stream, cwd, permission: "ask", exitOnClose: false, model: "scripted" });
+  io.feed("hello rovecode\r");
+  const deadline = Date.now() + (opts.deadlineMs ?? 15_000);
+  const cardFrames: string[] = [];
+  let frame = "", done = false;
+  while (Date.now() < deadline) {
+    renderer.tick();
+    frame = renderer.frameText();
+    if (cardFrames.length === CARDS.length && frame.includes("Smoke OK") && !frame.includes("needs your permission")) { done = true; break; }
+    const want = CARDS[cardFrames.length];
+    if (want !== undefined && want.test(frame) && frame.includes("allow")) { cardFrames.push(frame); io.feed("\r"); } // Enter = allow once
+    await sleep(25);
+  }
+  // the boot reveal paints panels in 90 ms steps after bootAt (frame.ts REVEAL_STEP_MS); a fast host
+  // finishes the scripted run before the right column and the pet have appeared — give the reveal its time
+  const PANELS = ["─ files ─", "─ code ─", "─ messages ─", "─ plan ─", "─ usage ─", "─ rovecode ─"];
+  const shown = (p: string): boolean => frame.includes(p) || (p === "─ code ─" && frame.includes("─ diff ─"));
+  const revealBy = Date.now() + 2_000;
+  while (done && Date.now() < revealBy && !PANELS.every(shown)) { await sleep(25); renderer.tick(); frame = renderer.frameText(); }
+  if (!done) reasons.push(`final frame not reached (approval cards seen ${cardFrames.length}/${CARDS.length})`);
+  if (!/~ edit\s+smoke\.txt/.test(frame)) reasons.push("no `~ edit smoke.txt` tool row in the messages panel");
+  if (!/\+ write\s+smoke\.txt/.test(frame)) reasons.push("no `+ write smoke.txt` tool row in the messages panel");
+  for (const p of PANELS) if (!shown(p)) reasons.push(`panel ${p.trim()} missing at ${io.cols}×${io.rows}`);
+  const wasActive = renderer.active;
+  io.feed("\x03");
+  await app;
+  const tail = io.output().slice(-400);
+  for (const seq of LEAVE) if (!tail.includes(seq)) reasons.push(`the output tail lacks ${JSON.stringify(seq)} — terminal not restored`);
+  if (!wasActive) reasons.push("the frame interval was not running before quit");
+  if (renderer.active) reasons.push("the frame interval survived quit");
+  // the repo watcher's git children must be GONE before the scratch repo goes (sextant-renderer drain);
+  // on Windows a live `git status` holds its cwd and rmSync answers EBUSY — the tui-sextant "flake".
+  // The retry is the belt to that brace: handle release on Windows lags the process exit itself.
+  await renderer.drain().catch(() => {});
+  for (let attempt = 0; ; attempt++) {
+    try { rmSync(cwd, { recursive: true, force: true }); break; }
+    catch (e) {
+      const code = (e as NodeJS.ErrnoException).code;
+      if ((code !== "EBUSY" && code !== "EPERM" && code !== "ENOTEMPTY") || attempt >= 20) throw e;
+      await sleep(25);
+    }
+  }
+  return { ok: reasons.length === 0, reasons, cardFrame: cardFrames[1] ?? cardFrames[0] ?? "(no approval card rendered)", frame, tail };
+}
+
+export async function runSextantSmoke(): Promise<void> {
+  const r = await sextantSmoke();
+  console.log("── sextant: approval card for the anchored edit (160x44) ──────────────────────");
+  console.log(r.cardFrame);
+  console.log("── sextant: final frame (160x44) ────────────────────────────────────────────────");
+  console.log(r.frame);
+  console.log("─────────────────────────────────────────────────────────────────────────────────");
+  console.log(r.ok
+    ? "smoke-tui --sextant: PASS (files · code · messages · plan · usage · rovecode + two approval cards through the full pipeline; terminal restored on quit)"
+    : `smoke-tui --sextant: FAIL — ${r.reasons.join("; ")}`);
+  process.exit(r.ok ? 0 : 1);
+}

package/src/tui/smoke.ts

@@ -0,0 +1,72 @@
+/** `rovecode smoke-tui`: end-to-end render check through the real pipeline —
+ *  agentLoop → Renderer → pi-tui → ANSI → @xterm/headless terminal emulator.
+ *  Gated session: a scripted write, then an anchored edit of that file, each raise the
+ *  approval overlay with its diff card (port #24) and are approved once the card is on
+ *  screen; a markdown turn closes the run. Prints the edit's diff-card screen and the
+ *  final 80x24 screen; exits 0 iff every stage rendered. */
+
+import { VirtualTerminal } from "../../vendor/pi-tui/test/virtual-terminal.ts";
+import { PiTuiRenderer } from "./pi-renderer.ts";
+import { runTui } from "./app.ts";
+import { mockStream, textTurn, toolTurn } from "../providers/stream.ts";
+import { fileTag, lineHash } from "../coding/hashline.ts";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+export async function runTuiSmoke(): Promise<void> {
+  const cwd = mkdtempSync(join(tmpdir(), "rovecode-tui-smoke-"));
+  const term = new VirtualTerminal(80, 24);
+  const renderer = new PiTuiRenderer({ terminal: term, cwd });
+  const probe = join(cwd, "smoke.txt");
+  const written = "smoke-ok\n";
+  const stream = mockStream({
+    turns: [
+      toolTurn([{ id: "t1", tool: "write", args: { path: probe, content: written } }]),
+      // port #24: anchored edit of the file just written → the approval card shows -old/+new
+      toolTurn([{ id: "t2", tool: "edit", args: { path: probe, edits: [
+        { tag: fileTag(written), anchorLine: 1, anchorHash: lineHash("smoke-ok"), newLines: ["smoke-edited"] },
+      ] } }]),
+      textTurn("# Smoke OK\n\nrendered **markdown**, a tool card, and the status line."),
+    ],
+  });
+
+  // pinned, not inherited: this smoke asserts approval cards, and a ~/.rovecode/settings.json with
+  // "permission":"auto" would allow everything silently (`yolo: false` is "no flag" to app.ts, not "ask")
+  const app = runTui({ renderer, stream, cwd, permission: "ask", exitOnClose: false, model: "scripted" });
+
+  // type a prompt into the (focused) editor and submit
+  term.sendInput("hello rovecode");
+  term.sendInput("\r");
+
+  // each approval overlay must show its diff card before Enter (= allow once) approves it:
+  // the write is an all-adds create diff, the edit a modify diff with the removed line
+  const cards = ["+smoke-ok", "-smoke-ok"];
+  const cardScreens: string[][] = [];
+  const deadline = Date.now() + 10_000;
+  let screen: string[] = [];
+  let ok = false;
+  while (Date.now() < deadline) {
+    screen = await term.flushAndGetViewport();
+    const text = screen.join("\n");
+    if (text.includes("Smoke OK") && text.includes("write") && cardScreens.length === cards.length) { ok = true; break; }
+    const want = cards[cardScreens.length];
+    if (want !== undefined && text.includes("allow once") && text.includes(want)) {
+      cardScreens.push(screen);
+      term.sendInput("\r");
+    }
+    await new Promise((r) => setTimeout(r, 50));
+  }
+
+  term.sendInput("\x03"); // Ctrl+C → clean exit path
+  await app;
+  rmSync(cwd, { recursive: true, force: true });
+
+  console.log("── approval overlay with diff card (edit) ──────────────────────────────");
+  for (const line of cardScreens[1] ?? ["(diff card never rendered)"]) console.log(line.trimEnd());
+  console.log("── emulated 80x24 screen ──────────────────────────────────────────────");
+  for (const line of screen) console.log(line.trimEnd());
+  console.log("───────────────────────────────────────────────────────────────────────");
+  console.log(ok ? "smoke-tui: PASS (markdown + tool card + diff card rendered through full pipeline)" : `smoke-tui: FAIL (diff cards seen: ${cardScreens.length}/${cards.length})`);
+  process.exit(ok ? 0 : 1);
+}

package/src/tui/theme.ts

@@ -0,0 +1,59 @@
+/** Rovecode TUI theme: raw ANSI styling (no chalk dep) + theme objects for vendored pi-tui
+ *  components (EditorTheme / MarkdownTheme / SelectListTheme shapes from vendor). */
+
+import type { EditorTheme, MarkdownTheme, SelectListTheme } from "../../vendor/pi-tui/src/index.ts";
+
+const esc = (open: string, close: string) => (s: string) => `\x1b[${open}m${s}\x1b[${close}m`;
+
+export const st = {
+  bold: esc("1", "22"),
+  dim: esc("2", "22"),
+  italic: esc("3", "23"),
+  underline: esc("4", "24"),
+  inverse: esc("7", "27"),
+  strike: esc("9", "29"),
+  fg: (n: number) => esc(`38;5;${n}`, "39"),
+  bg: (n: number) => esc(`48;5;${n}`, "49"),
+};
+
+// palette (256-color): calm blues/teals for chrome, amber for warnings
+export const pal = {
+  accent: st.fg(75),     // sky blue — headings, borders
+  accentDim: st.fg(67),
+  ok: st.fg(114),        // green
+  warn: st.fg(215),      // amber
+  err: st.fg(203),       // red
+  muted: st.dim,
+  code: st.fg(180),
+  link: st.fg(75),
+};
+
+export const rovecodeSelectListTheme: SelectListTheme = {
+  selectedPrefix: (t) => pal.accent(t),
+  selectedText: (t) => st.bold(t),
+  description: (t) => st.dim(t),
+  scrollInfo: (t) => st.dim(t),
+  noMatch: (t) => st.dim(t),
+};
+
+export const rovecodeEditorTheme: EditorTheme = {
+  borderColor: (t) => pal.accentDim(t),
+  selectList: rovecodeSelectListTheme,
+};
+
+export const rovecodeMarkdownTheme: MarkdownTheme = {
+  heading: (t) => st.bold(pal.accent(t)),
+  link: (t) => pal.link(st.underline(t)),
+  linkUrl: (t) => st.dim(t),
+  code: (t) => pal.code(t),
+  codeBlock: (t) => pal.code(t),
+  codeBlockBorder: (t) => st.dim(t),
+  quote: (t) => st.italic(st.dim(t)),
+  quoteBorder: (t) => st.dim(t),
+  hr: (t) => st.dim(t),
+  listBullet: (t) => pal.accent(t),
+  bold: (t) => st.bold(t),
+  italic: (t) => st.italic(t),
+  strikethrough: (t) => st.strike(t),
+  underline: (t) => st.underline(t),
+};

package/src/tui/todo-label.ts

@@ -0,0 +1,7 @@
+/** Tiny status-bar helper split from info-cmd.ts so app.ts can import it statically
+ *  without pulling in the full info-cmd module at startup. */
+import { loadTodos, todoStatusLabel } from "../tools/todo.ts";
+
+export function todoLabel(sessionDir: string): string | undefined {
+  return todoStatusLabel(loadTodos(sessionDir).items) || undefined;
+}