rovecode 0.3.2 → 0.4.0-beta.2

package/src/tui/sextant-smoke.ts

@@ -1,110 +0,0 @@
-/** `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/shell-cmd.ts

@@ -1,158 +0,0 @@
-/** `!cmd` shell mode: a prompt line that starts with `!` runs in the workspace shell through the ONE bash tool
- *  dispatch — ToolRegistry.dispatch with the session's permission rules and the very approval chain a model-issued
- *  `bash` call gets (permission rules → execpolicy → the approval hook → the human's card, cli/runtime.ts buildCfg)
- *  behind the configured executor rung. Never a direct spawn, never a second policy path: the composer's `!` is a
- *  convenience over the same door, not a way around it. The caller passes ITS human approver, so the surface's own
- *  behaviour — the diff preview, the "all edits" door — applies here too rather than being reimplemented.
- *
- *  No model turn starts. The command and its output are appended to the session as a user message the model reads
- *  on its NEXT turn (shellRecord), so `!bun test` followed by "fix it" gives the model the failure without a tool
- *  round-trip. Both surfaces share this module: a renderer with `onEvent` (sextant) builds its rows from the
- *  dispatch events; one without (the classic pi-tui) gets the tool card pair plus a bounded output block.
- *
- *  Pattern source (Apache-2.0, PATTERN ONLY, no code copied): gemini-cli packages/cli/src/ui/hooks/
- *  useGeminiStream.ts (shell mode short-circuits the prompt before any model call) and atCommandProcessor.ts (a
- *  client-initiated tool call whose result is folded into the user turn).
- *
- *  Rules: `!` alone, `! x` (a space after the bang) and `!!x` are plain text for the model — the ONE classifier is
- *  sextant/overlays.ts parseInput; a busy run refuses the line (the record would fork the run's chain); staged
- *  /attach images never ride on a shell record; and a call refused BEFORE execution (a rule, execpolicy, a hook, a
- *  denied card) leaves no record at all — the model learns only what actually ran. */
-
-import { randomUUID } from "node:crypto";
-import type { Runtime } from "../cli/runtime.ts";
-import type { SessionStore } from "../core/session.ts";
-import type { ApprovalFn, Message, PermissionLevel, RunEvent, ToolCallPart, ToolContext, ToolOutput } from "../core/types.ts";
-import { parseInput } from "../sextant/overlays.ts";
-import type { Renderer } from "./renderer.ts";
-
-/** the classic block shows this many output lines; the session record keeps the tool's full (≤10k) text */
-export const OUTPUT_BLOCK_LINES = 40;
-const OPEN = "<user_shell_command>", CLOSE = "</user_shell_command>", OUT_OPEN = "<user_shell_output", OUT_CLOSE = "</user_shell_output>";
-
-/** The command of a `!cmd` line, or null when the line is plain text (sextant/overlays.ts parseInput). */
-export function shellLine(text: string): string | null {
-  const p = parseInput(text);
-  return p.kind === "shell" && p.cmd ? p.cmd : null;
-}
-
-export interface ShellCtx {
-  renderer: Renderer;
-  rt: Pick<Runtime, "registry" | "hooks" | "buildCfg" | "cwd">;
-  /** the ACTIVE store, read live */
-  store(): SessionStore;
-  /** the session's permission level, exactly as a model turn would run under */
-  level(): PermissionLevel;
-  /** the surface's own human approver (undefined under `auto`, where nothing is asked) */
-  approve(): ApprovalFn | undefined;
-  /** the app's busy flag (a live run, or another `!cmd`) */
-  busy(): boolean;
-  /** flip the app's busy flag (+ status) around the command */
-  setBusy(b: boolean): void;
-  /** the app's interrupt target — Esc / ⌃c / quit abort it; bound for the command's lifetime, then cleared */
-  bindAbort(ac: AbortController | null): void;
-}
-
-const head = (cmd: string): string => { const one = cmd.replace(/\s+/g, " ").trim(); return one.length > 40 ? one.slice(0, 39) + "…" : one; };
-
-type FailedEvent = Extract<RunEvent, { type: "tool_call_failed" }>;
-export const REFUSED_DETAIL = "refused by a permission rule, exec policy or an approval hook (no approval prompt)";
-
-/** the event BOTH surfaces get for a call refused before execution. `asked` = the human saw the card and denied —
- *  the raw event stands, its "user denied" is true; otherwise the chain settled it alone (a forbidden argv, a hook
- *  deny) and dispatch's generic "user denied" would misreport a policy stop as the person's choice. */
-function refusal(ev: FailedEvent, asked: boolean): FailedEvent {
-  return !asked && ev.detail === "user denied" ? { ...ev, detail: REFUSED_DETAIL } : ev;
-}
-
-/** Run one `!cmd` line. Echoes the typed line, dispatches the bash tool with the session's rules and approval
- *  chain, records what ran, settles the surface — and never starts a model turn. */
-export async function runShellLine(ctx: ShellCtx, line: string): Promise<void> {
-  const cmd = shellLine(line);
-  if (cmd === null) return;
-  const { renderer } = ctx;
-  if (ctx.busy()) { renderer.addSystemNote("finish or interrupt the run first (Esc) — `!cmd` runs only while the agent is idle", "warn"); return; }
-  renderer.addUser(line.trim());
-  const ac = new AbortController();
-  ctx.setBusy(true);
-  ctx.bindAbort(ac);
-  renderer.setBusy(true, `running ${head(cmd)}…`);
-  const call: ToolCallPart = { kind: "tool_call", id: `shell-${randomUUID().slice(0, 8)}`, tool: "bash", args: { command: cmd } };
-  let asked = false, executed = false;
-  // the SAME chain a model-issued bash call gets: buildCfg wraps the surface's approver in the rules, execpolicy
-  // and the hooks. The wrapper only records that the human was reached, so the refusal text can tell the truth.
-  const human = ctx.approve();
-  const cfg = ctx.rt.buildCfg(ctx.level(), human === undefined ? undefined : async (req) => { asked = true; return human(req); });
-  const toolCtx: ToolContext = { sessionId: ctx.store().id, cwd: ctx.rt.cwd, signal: ac.signal, permissions: { effect: "allow" } };
-  // onEvent FIRST — a renderer that has it owns the rows and ignores the card calls below; the classic surface
-  // paints its `→ bash` / `← ok|FAIL` pair from them. Both are built from the ONE corrected event.
-  const emit = (raw: RunEvent): void => {
-    const ev = raw.type === "tool_call_failed" ? refusal(raw, asked) : raw;
-    renderer.onEvent?.(ev);
-    if (ev.type === "tool_execution_start") renderer.toolStart(ev.callId, ev.tool, JSON.stringify(ev.args).slice(0, 120));
-    else if (ev.type === "tool_execution_update") renderer.toolUpdate(ev.callId, ev.note);
-    else if (ev.type === "tool_execution_end") { executed = true; renderer.toolEnd(ev.callId, ev.ok, ev.output.slice(0, 160).replace(/\n/g, " ⏎ "), ev.durationMs); }
-    else if (ev.type === "tool_call_failed") renderer.toolEnd(ev.callId, false, `${ev.reason}: ${ev.detail}`.slice(0, 160), 0);
-  };
-  let out: ToolOutput = { ok: false, output: "" };
-  try {
-    // no loop guard: the person's own repeats are not a model loop and must not count toward its streak
-    out = await ctx.rt.registry.dispatch(call, toolCtx, ctx.rt.hooks, cfg.permissionRules, cfg.approval, emit, undefined);
-    if (executed) {
-      const store = ctx.store();
-      const staged = store.stagedAttachments; // /attach images ride on the next TYPED message, never on a shell record
-      store.stageAttachments([]);
-      store.append(shellRecord(cmd, out, store.messages().at(-1)?.id ?? null));
-      store.stageAttachments(staged);
-      if (!renderer.onEvent) renderer.addSystemNote(outputBlock(out.output), out.ok ? "info" : "warn");
-    } else {
-      const why = ac.signal.aborted ? "was interrupted before it ran" : asked ? "was denied at the approval card" : "was refused before any approval prompt (a permission rule, exec policy or a hook)";
-      renderer.addSystemNote(`\`${head(cmd)}\` ${why} — nothing ran, nothing recorded`, "warn");
-    }
-  } finally {
-    ctx.bindAbort(null);
-    renderer.setBusy(false, executed && out.ok ? "done" : "error");
-    ctx.setBusy(false);
-  }
-}
-
-/** The session record the model reads next turn: a role:"user" message —
- *  `<user_shell_command>\n$ <cmd>\n</user_shell_command>\n<user_shell_output exit="N">\n<output>\n</user_shell_output>`
- *  — exit = the bash tool's `exit=N` header (`?` when the output carries none), output = the rest. */
-export function shellRecord(cmd: string, out: ToolOutput, parentId: string | null): Message {
-  const m = /^exit=(-?\d+)\r?\n?/.exec(out.output);
-  const exit = m ? m[1]! : "?";
-  const body = (m ? out.output.slice(m[0].length) : out.output).replace(/\r?\n$/, "");
-  const text = [OPEN, `$ ${cmd}`, CLOSE, `${OUT_OPEN} exit="${exit}">`, ...(body ? [body] : []), OUT_CLOSE].join("\n");
-  return { id: randomUUID(), role: "user", parts: [{ kind: "text", text }], parentId, createdAt: Date.now() };
-}
-
-const RECORD_RE = /^<user_shell_command>\n\$ ([\s\S]*?)\n<\/user_shell_command>\n<user_shell_output exit="(-?\d+|\?)">\n(?:([\s\S]*?)\n)?<\/user_shell_output>$/;
-
-/** the inverse of shellRecord for transcript replay; null for any other user text */
-export function parseShellRecord(text: string): { cmd: string; exit: string; output: string } | null {
-  const m = RECORD_RE.exec(text);
-  return m ? { cmd: m[1]!, exit: m[2]!, output: m[3] ?? "" } : null;
-}
-
-/** the classic surface's output block: the tool's text (its `exit=N` header first), at most OUTPUT_BLOCK_LINES lines */
-export function outputBlock(output: string): string {
-  const lines = output.replace(/\r\n/g, "\n").replace(/\n$/, "").split("\n");
-  const shown = lines.slice(0, OUTPUT_BLOCK_LINES);
-  const more = lines.length - shown.length;
-  return shown.join("\n") + (more > 0 ? `\n… ${more} more line${more === 1 ? "" : "s"} (the session record keeps the full output)` : "");
-}
-
-let replaySeq = 0;
-/** Transcript replay of a stored shell record: the typed `!cmd` line, then the bash tool card pair the live run
- *  showed. false = not a record. */
-export function replayShellRecord(renderer: Renderer, text: string): boolean {
-  const r = parseShellRecord(text);
-  if (!r) return false;
-  const id = `shell-replay-${++replaySeq}`;
-  renderer.addUser(`!${r.cmd}`);
-  renderer.toolStart(id, "bash", JSON.stringify({ command: r.cmd }).slice(0, 120));
-  // the record's exact text as the preview: an empty output is `exit=N` alone, never a dangling line break
-  renderer.toolEnd(id, r.exit === "0", [`exit=${r.exit}`, ...(r.output ? [r.output] : [])].join("\n").slice(0, 160).replace(/\n/g, " ⏎ "), 0);
-  return true;
-}

package/src/tui/smoke.ts

@@ -1,72 +0,0 @@
-/** `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/staged-terminal.ts

@@ -1,50 +0,0 @@
-/** Classic TUI's first frame is measured AND serialized offscreen. No raw mode, terminal writes or
- *  input subscription until reveal(). Re-preparing replaces the buffer (resize/status), never appends
- *  an obsolete screen. Imported only by the optional classic renderer. */
-import type { Terminal } from "../../vendor/pi-tui/src/terminal.ts";
-
-export class StagedTerminal implements Terminal {
-  private pending: (() => void)[] = [];
-  private visible = false;
-  private discarded = false;
-  constructor(private readonly inner: Terminal) {}
-  get columns(): number { return this.inner.columns; }
-  get rows(): number { return this.inner.rows; }
-  get kittyProtocolActive(): boolean { return this.inner.kittyProtocolActive; }
-  prepare(render: () => void): void { this.pending = []; render(); }
-  reveal(start: () => void, handoff?: () => void): void {
-    if (this.discarded || this.visible) return;
-    const frame = this.pending; this.pending = [];
-    const esc = String.fromCharCode(27);
-    this.inner.write(`${esc}[?2026h`);
-    try {
-      handoff?.();
-      this.visible = true;
-      start(); // protocol setup/input first, followed immediately by the already-computed complete frame
-      for (const write of frame) write();
-    } finally { this.inner.write(`${esc}[?2026l`); }
-  }
-  private emit(write: () => void): void {
-    if (this.discarded) return;
-    if (this.visible) write(); else this.pending.push(write);
-  }
-  start(input: (data: string) => void, resize: () => void): void {
-    if (this.visible) this.inner.start(input, resize);
-  }
-  stop(): void {
-    this.discarded = true; this.pending = [];
-    if (this.visible) this.inner.stop();
-  }
-  drainInput(maxMs?: number, idleMs?: number): Promise<void> {
-    return this.visible ? this.inner.drainInput(maxMs, idleMs) : Promise.resolve();
-  }
-  write(data: string): void { this.emit(() => this.inner.write(data)); }
-  moveBy(lines: number): void { this.emit(() => this.inner.moveBy(lines)); }
-  hideCursor(): void { this.emit(() => this.inner.hideCursor()); }
-  showCursor(): void { this.emit(() => this.inner.showCursor()); }
-  clearLine(): void { this.emit(() => this.inner.clearLine()); }
-  clearFromCursor(): void { this.emit(() => this.inner.clearFromCursor()); }
-  clearScreen(): void { this.emit(() => this.inner.clearScreen()); }
-  setTitle(title: string): void { this.emit(() => this.inner.setTitle(title)); }
-  setProgress(active: boolean): void { this.emit(() => this.inner.setProgress(active)); }
-}

package/src/tui/startup.ts

@@ -1,12 +0,0 @@
-/** Wait for required startup work without trapping Ctrl+C behind a slow probe. The readiness promise
- *  stays observed after cancellation, so a late rejection cannot become an unhandled rejection. */
-export function waitForStartup(ready: Promise<void>, signal?: AbortSignal): Promise<void> {
-  if (!signal) return ready;
-  return new Promise((resolve, reject) => {
-    const abort = () => { reject(signal.reason ?? new Error("startup cancelled")); };
-    signal.addEventListener("abort", abort, { once: true });
-    const cleanup = () => signal.removeEventListener("abort", abort);
-    if (signal.aborted) { cleanup(); abort(); }
-    ready.then(() => { cleanup(); resolve(); }, (error) => { cleanup(); reject(error); });
-  });
-}

package/src/tui/theme.ts

@@ -1,59 +0,0 @@
-/** 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

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

package/src/tui/trust-card.ts

@@ -1,107 +0,0 @@
-/** `/trust` in the TUI — the approval card for the project trust gate (core/trust.ts, 08f355a), which until now could
- *  only be answered by QUITTING the TUI and running `rovecode trust`. A security gate whose only yes is "leave the thing
- *  you are doing" is a gate people switch off, so this is the same decision without the exit.
- *
- *  NOT the aion port of the same file name. aion's src/tui/trust-card.ts asks about a FOLDER (decideTrust, trust.json,
- *  "trust this folder / just this session / never", and a PreBootHooks so runTui can ask before createRuntime); rovecode's
- *  gate is per-FILE and keyed by sha256 in the user home, so there is no folder answer to give and no boot ordering to
- *  bend — the decision here is "these bytes of THIS file", one file at a time. Everything the person reads before
- *  answering comes from core/project-trust.ts (projectTrustRows → trustShowLines), the same lines `rovecode trust show`
- *  prints: the terminal and the TUI must not describe the same file differently.
- *
- *  Two rules the card is built around, both of them Berkay's:
- *   - approving is a DECISION, not a keystroke: the first item of the picker — the one Enter lands on — is "keep them
- *     untrusted". There is no default yes, and Esc is the same refusal.
- *   - no bulk yes without showing what "all" is: the carries lines are printed BEFORE the picker every time, and
- *     "approve all N files" only appears when N > 1 (with one file it would be a second spelling of the same item).
- *  Approving does not retro-load anything — hooks.ts is imported at boot, sandbox.json picks the executor at boot — so
- *  the card closes with the CLI's own sentence: restart to apply. */
-
-import { relative } from "node:path";
-import { projectTrustRows, trustRows, trustShowLines, untrustedRows, untrustRows, type TrustRow } from "../core/project-trust.ts";
-import { trustFile } from "../core/trust.ts";
-import { rovecodeHome } from "../providers/auth.ts";
-import type { PickItem, Renderer } from "./renderer.ts";
-
-export const TRUST_CARD_USAGE = "/trust — review this repo's gated files and approve them · /trust show — review only · /trust untrust — withdraw";
-
-/** the palette entry (the mcp-cmd.ts idiom, so app.ts's table gains ONE line) */
-export const TRUST_SUBCOMMANDS = ["show", "untrust"] as const;
-export const TRUST_COMMAND = { name: "trust", choices: TRUST_SUBCOMMANDS, choicesThen: "submit" as const, description: "Review what this repo's config would run and approve it: /trust · /trust show · /trust untrust", group: "modes & safety" };
-
-/** picker value of the refusal (first item) and of the bulk approval — neither can collide with a file path */
-export const KEEP_UNTRUSTED = "\u0000keep-untrusted";
-export const TRUST_ALL = "\u0000trust-all";
-
-export const RESTART_NOTE = "restart rovecode to apply — an edit to any of these files asks again";
-
-export interface TrustCardCtx {
-  renderer: Renderer;
-  cwd: string;
-  /** the trust store's home; default rovecodeHome() (tests point it at a scratch dir) */
-  home?: string;
-}
-
-/** the picker for the untrusted rows: refusal FIRST, then one item per file, then the bulk item when there are several */
-export function trustPickItems(untrusted: readonly TrustRow[], cwd: string): PickItem[] {
-  const items: PickItem[] = [{ value: KEEP_UNTRUSTED, label: "keep them untrusted", description: "nothing from these files is used; you will be asked again next launch" }];
-  for (const r of untrusted) items.push({ value: r.file, label: `approve ${rel(r.file, cwd)}`, description: r.carries.join(" · ") });
-  if (untrusted.length > 1) items.push({ value: TRUST_ALL, label: `approve all ${untrusted.length} files`, description: untrusted.map((r) => rel(r.file, cwd)).join(", ") });
-  return items;
-}
-
-const rel = (file: string, cwd: string): string => { const r = relative(cwd, file); return r === "" || r.startsWith("..") ? file : r; };
-
-export function trustCardTitle(cwd: string, untrusted: readonly TrustRow[]): string {
-  const what = untrusted.length === 1 ? "1 file" : `${untrusted.length} files`;
-  return `${cwd}: ${what} would make rovecode run something and ${untrusted.length === 1 ? "is" : "are"} not trusted on this machine — the lines above say what each one carries. Enter on the first item changes nothing (Esc the same).`;
-}
-
-/** `/trust [show|untrust]` — the review lines, then (bare verb only) the approval card */
-export async function cmdTrustCard(ctx: TrustCardCtx, arg = ""): Promise<void> {
-  const { renderer } = ctx;
-  const home = ctx.home ?? rovecodeHome();
-  const verb = arg.trim().split(/\s+/).filter(Boolean)[0] ?? "";
-  if (verb !== "" && verb !== "show" && verb !== "untrust") { renderer.addSystemNote(`unknown /trust verb "${verb}" — ${TRUST_CARD_USAGE}`, "warn"); return; }
-  const rows = projectTrustRows(ctx.cwd, home);
-  if (verb === "untrust") { for (const l of untrustRows(home, rows)) renderer.addSystemNote(l); return; }
-  show(ctx, rows);
-  if (verb === "show" || rows.length === 0) return;
-  if (untrustedRows(rows).length === 0) { renderer.addSystemNote("every gated file here is already trusted — nothing to approve"); return; }
-  await ask(ctx, home);
-}
-
-/** the `trust show` lines, verbatim from project-trust.ts; an untrusted file's header is a warn so it is not read as prose */
-function show(ctx: TrustCardCtx, rows: readonly TrustRow[]): void {
-  for (const line of trustShowLines([...rows])) ctx.renderer.addSystemNote(line, line.startsWith("· UNTRUSTED") ? "warn" : "info");
-}
-
-/** one card per remaining untrusted file: approve one → re-list what is left → ask again, until the person refuses
- *  (Enter on the first item / Esc) or nothing is left. `trustFile` records the file's CURRENT bytes. */
-async function ask(ctx: TrustCardCtx, home: string): Promise<void> {
-  const { renderer } = ctx;
-  let approved = 0;
-  for (;;) {
-    const untrusted = untrustedRows(projectTrustRows(ctx.cwd, home));
-    if (untrusted.length === 0) break;
-    const picked = await renderer.pickOne(trustPickItems(untrusted, ctx.cwd), trustCardTitle(ctx.cwd, untrusted));
-    if (picked === null || picked === KEEP_UNTRUSTED) {
-      renderer.addSystemNote(`${untrusted.length} file${untrusted.length === 1 ? "" : "s"} left untrusted — ${untrusted.map((r) => rel(r.file, ctx.cwd)).join(", ")} contribute nothing this session`, "warn");
-      break;
-    }
-    if (picked === TRUST_ALL) {
-      for (const l of trustRows(home, untrusted)) renderer.addSystemNote(l);
-      approved += untrusted.length;
-      break;
-    }
-    const row = untrusted.find((r) => r.file === picked);
-    if (row === undefined) break; // a file that vanished between the card and the answer: nothing to record
-    const t = trustFile(home, row.file);
-    if (!t.ok) { renderer.addSystemNote(t.reason, "warn"); break; }
-    renderer.addSystemNote(`trusted ${row.file}  (${t.digest.slice(0, 12)}…)`);
-    approved++;
-    if (untrusted.length === 1) break; // that was the last one; the loop's re-list would only confirm it
-    show(ctx, untrustedRows(projectTrustRows(ctx.cwd, home)));
-  }
-  if (approved > 0) ctx.renderer.addSystemNote(RESTART_NOTE);
-}