rovecode 0.3.3 → 0.4.0-beta.2

package/src/tui/session-cmd.ts

@@ -1,148 +0,0 @@
-/** TUI session navigation (port #2 session tree), extracted from app.ts for the ADR-002
- *  cap: /sessions + /resume pick or resolve a session to switch to, /rewind (alias /tree)
- *  jumps to an earlier turn for edit-and-resubmit, /new branches back to the session
- *  start. The CALLER owns the swappable store and the rebind routine (switchSession), so
- *  store reads and switches run through the injected ctx — same shape as checkpoints-cmd.
- *  Also home to the pure session helpers the app calls around a switch: transcript replay,
- *  usage recount, and the `--resume <prefix>` boot resolution (wiring pass, ADR-002 cap). */
-
-import { partsText } from "../core/loop.ts";
-import { listSessions, type SessionStore } from "../core/session.ts";
-import { ambiguityMessage, matchSessions } from "../core/session-ops.ts";
-import { userTurnLine } from "./attach.ts";
-import { replayLabel } from "./modes-cmd.ts";
-import { replayMarkerLine } from "./replay-marker.ts";
-import { replayShellRecord } from "./shell-cmd.ts";
-import type { Renderer } from "./renderer.ts";
-import { randomUUID } from "node:crypto";
-
-/** Re-render the whole transcript from the active session path (boot replay, /resume, /rewind,
- *  /new, checkpoint restores). Tool calls replay as start+end card pairs; mode switches render
- *  as a human line (port #20 LOW-3), never the raw <mode_notice> XML the entry carries; user
- *  turns carry their image chips (port #34), so an image-only turn is not a blank line; persisted
- *  compaction events replay as the live run's note (port #25 LOW-4, replay-marker.ts). */
-export function replayTranscript(renderer: Renderer, store: SessionStore): void {
-  renderer.clearTranscript();
-  for (const m of store.path()) {
-    if (!("role" in m)) { const line = replayMarkerLine(m); if (line !== null) renderer.addSystemNote(line); continue; } // event entry (appendEvent): marker or nothing
-    const text = partsText(m.parts);
-    // a `!cmd` record is a user message in the store, but it replays as the typed line plus its bash card pair
-    // (tui/shell-cmd.ts) rather than as the raw <user_shell_command> block the model reads
-    if (m.role === "user" && replayShellRecord(renderer, text)) continue;
-    if (m.role === "user") { const line = userTurnLine(text, m.parts); if (line) renderer.addUser(line); }
-    else if (m.role === "assistant") {
-      if (text) { const v = renderer.beginAssistant(); v.append(text); v.done(); }
-      for (const p of m.parts) {
-        if (p.kind === "tool_call") renderer.toolStart(p.id, p.tool, JSON.stringify(p.args).slice(0, 120));
-      }
-    } else if (m.role === "tool") {
-      for (const p of m.parts) {
-        if (p.kind === "tool_result") renderer.toolEnd(p.callId, p.ok, p.output.slice(0, 160).replace(/\n/g, " ⏎ "), 0);
-      }
-    } else if (m.role === "system" && text) renderer.addSystemNote(replayLabel(m, text));
-  }
-}
-
-/** Token usage summed over the active path — the status line's counters. */
-export function usageOf(store: SessionStore): { tokensIn: number; tokensOut: number } {
-  let tokensIn = 0, tokensOut = 0;
-  for (const m of store.messages()) { tokensIn += m.usage?.input ?? 0; tokensOut += m.usage?.output ?? 0; }
-  return { tokensIn, tokensOut };
-}
-
-/** The in-TUI /resume rule (matchSessions, core/session-ops.ts — the same one `--resume`, `trace`, `export` and the
- *  `sessions` verbs use): a unique match resolves, an AMBIGUOUS prefix must not silently pick one — start fresh (id
- *  undefined) and say so in `warn`. The CLI's `--resume <id>` no longer comes through here: cli/resume.ts refuses an
- *  unknown or ambiguous id before the TUI boots (2026-09-07). */
-export function resolveBootSession(sessionsDir: string, id: string | undefined): { id: string | undefined; warn?: string } {
-  if (id === undefined) return { id };
-  const pre = matchSessions(listSessions(sessionsDir, { includeHollow: true }), id);
-  if (pre.length === 1) return { id: pre[0]!.id };
-  if (pre.length > 1) return { id: undefined, warn: `"${id}" matches ${pre.length} sessions — started fresh; use /resume to pick one` };
-  return { id };
-}
-
-export interface SessionCmdCtx {
-  renderer: Renderer;
-  /** the run's cwd — `/sessions delete` removes the session's checkpoints shadow dir under it (session-manage.ts) */
-  cwd: string;
-  /** <cwd>/.rovecode/sessions — where listSessions looks */
-  sessionsDir: string;
-  busy(): boolean;
-  /** the ACTIVE session store, read live: /sessions and a root /rewind swap it */
-  store(): SessionStore;
-  /** rebind the app to session id (store, memory, mode) and replay it; announce defaults on */
-  switchSession(id: string, announce?: boolean): void;
-  /** re-render the whole transcript from the active session path */
-  replayHistory(): void;
-  /** recount token usage from the active store */
-  refreshUsage(): void;
-  pushStatus(): void;
-}
-
-/** /rewind (alias /tree) — pick an earlier turn in the overlay; Enter branches the session
- *  to before that turn and prefills the editor with its FULL text for edit-and-resubmit. */
-export async function cmdRewind(ctx: SessionCmdCtx): Promise<void> {
-  if (ctx.busy()) { ctx.renderer.addSystemNote("finish or interrupt the run first (Esc)", "warn"); return; }
-  const points = ctx.store().turnPoints();
-  if (points.length === 0) { ctx.renderer.addSystemNote("nothing to rewind — no turns yet"); return; }
-  const items = [...points].reverse().map((p) => ({
-    value: p.entryId,
-    label: `#${p.index} ${p.text}`,
-    description: p.branches > 0 ? `◆ ${p.branches} other branch${p.branches > 1 ? "es" : ""}` : undefined,
-  }));
-  const picked = await ctx.renderer.pickOne(items, "rewind to a turn (Enter = edit & resubmit, Esc = cancel)");
-  if (!picked) { ctx.replayHistory(); return; } // cancel: clear the overlay title note
-  const point = points.find((p) => p.entryId === picked);
-  if (!point) return;
-  if (point.parentId === null) {
-    // pi resets the leaf to an empty conversation (sessions.md:116); root reset would need
-    // core support — v1 approximates it with a fresh session, old one untouched
-    ctx.switchSession(randomUUID(), false);
-    ctx.renderer.addSystemNote("rewound to the start — fresh session, previous one kept");
-  } else {
-    if (!ctx.store().branch(point.parentId)) { ctx.renderer.addSystemNote("rewind failed: turn not found", "error"); return; }
-    ctx.replayHistory();
-    ctx.renderer.addSystemNote(`rewound to before turn #${point.index} — edit and resubmit (branch kept)`);
-  }
-  ctx.renderer.prefillEditor(point.fullText); // FULL text, never the ≤80-char overlay label
-  ctx.pushStatus();
-}
-
-/** /sessions — pick a previous session in the overlay; /resume <id> resolves an exact id
- *  or a UNIQUE prefix directly (an ambiguous prefix must not silently pick one). */
-export async function cmdSessions(ctx: SessionCmdCtx, directId?: string): Promise<void> {
-  if (ctx.busy()) { ctx.renderer.addSystemNote("finish or interrupt the run first (Esc)", "warn"); return; }
-  const all = listSessions(ctx.sessionsDir); // the picker: sessions that hold something (hollow dirs stay out of the list)
-  if (directId) {
-    // the ONE matching rule (core/session-ops.ts): exact id wins outright; a prefix must match exactly ONE session
-    // — resolving an ambiguous prefix silently to the first hit resumed the wrong session
-    const matches = matchSessions(listSessions(ctx.sessionsDir, { includeHollow: true }), directId);
-    if (matches.length === 1) ctx.switchSession(matches[0]!.id);
-    else if (matches.length > 1) ctx.renderer.addSystemNote(ambiguityMessage(directId, matches), "warn");
-    else ctx.renderer.addSystemNote(`no session matching "${directId}"`, "warn");
-    return;
-  }
-  const items = all.slice(0, 20).map((s) => ({
-    value: s.id,
-    label: s.title ?? (s.preview || "(empty session)"), // a title stands in for the first prompt, as `rovecode sessions list` does (cli/sessions-cmd.ts) — otherwise /sessions rename is invisible where you resume
-    description: `${new Date(s.updatedAt).toLocaleString()} · ${s.entryCount} entries · ${s.id.slice(0, 8)}${s.id === ctx.store().id ? " · current" : ""}`,
-  }));
-  if (items.length === 0) { ctx.renderer.addSystemNote("no sessions found"); return; }
-  const picked = await ctx.renderer.pickOne(items, "resume a session (Esc = cancel)");
-  if (picked && picked !== ctx.store().id) ctx.switchSession(picked);
-  else if (!picked) ctx.replayHistory(); // cancel: clear the overlay title note
-}
-
-/** /new — branch the leaf back to the session's first entry; the old turns stay in the
- *  tree. Synchronous on purpose: no overlay, nothing to await. */
-export function cmdNew(ctx: SessionCmdCtx): void {
-  // busy gate (same as /rewind //sessions): moving the leaf mid-run would make the
-  // run's next append chain off a moved leaf while its parentId points elsewhere
-  if (ctx.busy()) { ctx.renderer.addSystemNote("finish or interrupt the run first (Esc)", "warn"); return; }
-  const store = ctx.store();
-  if (store.branch(store.messages()[0]?.id ?? "")) {
-    ctx.replayHistory(); ctx.refreshUsage(); ctx.pushStatus();
-    ctx.renderer.addSystemNote("branched to session start");
-  } else ctx.renderer.addSystemNote("nothing to branch — no turns yet");
-}

package/src/tui/session-manage.ts

@@ -1,95 +0,0 @@
-/** TUI `/sessions <verb>` (aion port #84): rename · delete · fork · search over core/session-ops.ts — the same ops as
- *  the headless `rovecode sessions …` (cli/sessions-cmd.ts, 5ceb21e), through the SessionCmdCtx seam app.ts already hands
- *  the session navigator (session-cmd.ts), so the classic and sextant surfaces share it via app.ts handleSlash. Rules:
- *   - every verb sits behind the /rewind busy gate (moving or removing session state mid-run is refused);
- *   - `rename <title…>` titles the CURRENT session through the LIVE store instance (`ctx.store().patchMeta`) — a second
- *     SessionStore on the same dir would be clobbered by this instance's next persistLeaf (/new, /rewind);
- *   - `delete <id|prefix>` resolves first, shows ONE askApproval card (deny → nothing removed); deleting the ACTIVE
- *     session switches the app to a fresh session first (the root-rewind pattern of session-cmd.ts cmdRewind) so no
- *     live store points at a removed dir; then session-ops.deleteSession removes the dir AND its checkpoints shadow
- *     repo — a half-delete leaves the space used with nothing pointing at it, so the test pins the shadow dir too;
- *   - `fork [<id|prefix>]` (default: the current session) forks and switches to the fork (announced, transcript replayed);
- *   - `search <terms…>` opens pickOne over the hits (label = preview, description = title · id8 · time); Enter switches
- *     to the hit's session, Esc replays the current transcript (the /sessions picker's cancel rule).
- *  Bare `/sessions` stays the picker (cmdSessions). `--plain` has none of this (README honesty). Pattern sources: see
- *  core/session-ops.ts (opencode MIT session.ts fork / remove / setTitle; codex Apache-2.0 DeleteConfirmation, pattern only). */
-
-import { randomUUID } from "node:crypto";
-import { deleteSession, forkSession, oneLineTitle, resolveSession, searchSessions } from "../core/session-ops.ts";
-import { cmdSessions, type SessionCmdCtx } from "./session-cmd.ts";
-
-const BUSY = "finish or interrupt the run first (Esc)";
-const USAGE = "/sessions rename <title…> | delete <id|prefix> | fork [<id|prefix>] | search <terms…>";
-
-/** app.ts `case "sessions"`: `arg` is the collapsed remainder after `/sessions` */
-export async function cmdSessionsVerb(ctx: SessionCmdCtx, arg: string): Promise<void> {
-  const [verb, ...rest] = arg.split(/\s+/).filter(Boolean);
-  if (verb === undefined) return cmdSessions(ctx); // bare /sessions: the picker, unchanged (it carries its own busy gate)
-  if (ctx.busy()) { ctx.renderer.addSystemNote(BUSY, "warn"); return; }
-  switch (verb) {
-    case "rename": return rename(ctx, rest.join(" "));
-    case "delete": return remove(ctx, rest[0]);
-    case "fork": return fork(ctx, rest[0]);
-    case "search": return search(ctx, rest.join(" "));
-    default: ctx.renderer.addSystemNote(`unknown /sessions verb "${verb}" — ${USAGE}`, "warn");
-  }
-}
-
-function rename(ctx: SessionCmdCtx, raw: string): void {
-  const title = oneLineTitle(raw);
-  if (title === undefined) { ctx.renderer.addSystemNote("usage: /sessions rename <title…>", "warn"); return; }
-  const store = ctx.store(); // the LIVE instance — its later persistLeaf carries the title forward
-  store.patchMeta({ title });
-  ctx.renderer.addSystemNote(`session ${store.id.slice(0, 8)} titled "${title}"`);
-}
-
-async function remove(ctx: SessionCmdCtx, ref: string | undefined): Promise<void> {
-  if (ref === undefined) { ctx.renderer.addSystemNote("usage: /sessions delete <id|prefix>", "warn"); return; }
-  const found = resolveSession(ctx.sessionsDir, ref);
-  if (!found.ok) { ctx.renderer.addSystemNote(found.error, "warn"); return; }
-  const s = found.summary;
-  const active = found.id === ctx.store().id;
-  const label = s.title ?? (s.preview || "(empty session)");
-  const answer = await ctx.renderer.askApproval(
-    "sessions delete",
-    `${s.id.slice(0, 8)} · ${label} · ${s.entryCount} entries${active ? " · the current session" : ""}`,
-    "removes the session directory (entries, meta, attachments, todos) and its checkpoints shadow repo — not undoable",
-  );
-  if (answer === "deny") { ctx.renderer.addSystemNote("delete cancelled — nothing removed", "warn"); return; }
-  if (active) {
-    // the root-rewind pattern (session-cmd.ts cmdRewind): the app moves to a fresh session BEFORE the old dir goes
-    ctx.switchSession(randomUUID(), false);
-    ctx.renderer.addSystemNote("deleting the active session — switched to a fresh one first");
-  }
-  const { removed } = deleteSession(ctx.cwd, ctx.sessionsDir, found.id);
-  ctx.renderer.addSystemNote(`deleted session ${found.id.slice(0, 8)} (${removed.length} path${removed.length === 1 ? "" : "s"} removed)`);
-}
-
-function fork(ctx: SessionCmdCtx, ref: string | undefined): void {
-  const found = resolveSession(ctx.sessionsDir, ref ?? ctx.store().id);
-  if (!found.ok) { ctx.renderer.addSystemNote(found.error, "warn"); return; }
-  let r: { id: string; from: string; title: string };
-  try { r = forkSession(ctx.sessionsDir, found.summary); }
-  catch (e) { ctx.renderer.addSystemNote(e instanceof Error ? e.message : String(e), "warn"); return; } // over FORK_MAX_ATTACHMENT_BYTES
-  ctx.switchSession(r.id); // rebinds store / memory / mode / checkpoints, replays the copied transcript, announces
-  ctx.renderer.addSystemNote(`forked ${r.from.slice(0, 8)} → ${r.id.slice(0, 8)} "${r.title}"`);
-}
-
-async function search(ctx: SessionCmdCtx, raw: string): Promise<void> {
-  const query = raw.trim();
-  if (query === "") { ctx.renderer.addSystemNote("usage: /sessions search <terms…>", "warn"); return; }
-  const rows = searchSessions(ctx.sessionsDir, query, 10);
-  if (rows.length === 0) { ctx.renderer.addSystemNote(`no matches for "${query}"`); return; }
-  const current = ctx.store().id;
-  const items = rows.map((r, i) => ({
-    value: String(i), // several hits may share a session: the index is the unique pick value
-    label: r.preview || r.title || "(empty session)",
-    description: `${r.title !== undefined ? `${r.title} · ` : ""}${r.sessionId.slice(0, 8)}${r.sessionId === current ? " · current" : ""} · ${new Date(r.timestamp).toLocaleString()}`,
-  }));
-  const picked = await ctx.renderer.pickOne(items, "search hits (Enter = resume, Esc = cancel)");
-  if (picked === null) { ctx.replayHistory(); return; } // cancel: clear the overlay title note
-  const row = rows[Number(picked)];
-  if (row === undefined) return;
-  if (row.sessionId === current) { ctx.renderer.addSystemNote("that hit is in the current session"); return; }
-  ctx.switchSession(row.sessionId);
-}

package/src/tui/sextant-attach.ts

@@ -1,102 +0,0 @@
-/** 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";
-import { checkImageCount, loadImageAttachment } from "../core/images.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;
-  /** the connect wizard (draw-wizard.ts): the provider registry + credentials, behind the same
-   *  live-runtime optionality as `runtime` — a surface without them degrades to honest errors. */
-  wizard?: {
-    providers(): { key: string; label: string; configured?: boolean; local?: boolean; url?: "openai" | "anthropic" }[];
-    register(id: string, url: string, protocol: "openai" | "anthropic"): { ok: boolean; error?: string };
-    storeKey(provider: string, secret: string): { ok: boolean; error?: string };
-    models(provider: string): Promise<{ id: string; note?: string }[]>;
-    /** the model step's activate answer: pin the checked rows as the active list (registry
-     *  setModels — spec.models), empty = un-pin ("use them all"); makeDefault also switches */
-    activateModels(provider: string, models: readonly string[], makeDefault?: string): { ok: boolean; error?: string; models?: string[] };
-    test(provider: string, model: string): Promise<{ ok: boolean; detail: 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"),
-    // port #54: an @image mention stages onto the SAME store stage /attach writes — one stage, one cap
-    // count, one chip row. The note comes from the expansion (sextant/mentions.ts); the caps and the
-    // magic-byte sniff are loadImageAttachment's, the same seam /attach runs through.
-    attachImage: (abs) => {
-      const store = a.store();
-      const loaded = loadImageAttachment(abs);
-      if ("error" in loaded) return;
-      const staged = store.stagedAttachments;
-      if (checkImageCount(staged.length + 1) !== undefined) return;
-      store.stageAttachments([...staged, loaded]);
-    },
-    // the connect wizard's seams — absent when the surface has no wizard sources, and the
-    // overlay's own degradation covers that
-    ...(a.wizard !== undefined ? {
-      wizardProviders: () => a.wizard!.providers(),
-      wizardRegister: (id: string, url: string, protocol: "openai" | "anthropic") => a.wizard!.register(id, url, protocol),
-      wizardStoreKey: (provider: string, secret: string) => a.wizard!.storeKey(provider, secret),
-      wizardModels: (provider: string) => a.wizard!.models(provider),
-      wizardActivateModels: (provider: string, models: readonly string[], makeDefault?: string) => a.wizard!.activateModels(provider, models, makeDefault),
-      wizardTest: (provider: string, model: string) => a.wizard!.test(provider, model),
-    } : {}),
-    ...(a.petName !== undefined ? { petName: a.petName } : {}),
-  };
-}

package/src/tui/sextant-io.ts

@@ -1,202 +0,0 @@
-/** 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 { SEXTANT_MIN_COLS, SEXTANT_MIN_ROWS, type TerminalIO } from "../sextant/types.ts";
-import type { Renderer } from "./renderer.ts";
-import type { FocusTracker } from "./notify-seq.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;
-  isTTY?: boolean;
-  setRawMode?(mode: boolean): unknown;
-  setEncoding(enc: BufferEncoding): unknown;
-  resume(): unknown;
-  pause(): unknown;
-  on(event: "data", cb: (chunk: string | Buffer) => void): unknown;
-  on(event: "end", cb: () => void): unknown;
-  off(event: "data", cb: (chunk: string | Buffer) => void): unknown;
-  off(event: "end", cb: () => 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;
-  /** consumes CSI I / CSI O focus reports BEFORE the sextant's parser sees the chunk (tui/notify.ts) */
-  focus?: FocusTracker;
-}
-
-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 => {
-      const text = typeof d === "string" ? d : d.toString("utf8");
-      const rest = this.opts.focus ? this.opts.focus.feed(text) : text; // focus reports are consumed here, never parsed as keys
-      if (rest.length > 0) cb(rest);
-    };
-    this.stdin.on("data", h);
-    // EOF: the pipe on the other end closed. A TUI that keeps waiting on a dead stdin hangs forever —
-    // measured 60 s+ (killed only by the outer timeout) when rovecode was launched from a pipe, a
-    // script or a wrapper that closes stdin. Deliver Ctrl-C's shape (ETX) so the input layer treats
-    // this exactly as an interrupt: a running turn aborts, an idle surface exits, and the terminal
-    // is restored by the normal close path. Without input there is nothing to wait FOR.
-    const end = (): void => { cb("\x03"); };
-    this.stdin.on("end", end);
-    return () => { this.stdin.off("data", h); this.stdin.off("end", end); };
-  }
-  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) */
-/** `io.focus`: the FocusTracker the notifications decorator reads (tui/notify.ts); `io.stdin` for tests */
-export function pickRenderer(cli: { classic: boolean; pet?: string }, env: Env = process.env, stdout: RawStdout = process.stdout, io: { stdin?: RawStdin; focus?: FocusTracker } = {}): Renderer | undefined {
-  if (chooseSurface(cli, env, stdout) !== "sextant") return undefined;
-  const { SextantRenderer } = require("../sextant/sextant-renderer.ts") as typeof import("../sextant/sextant-renderer.ts");
-  return new SextantRenderer({ io: new ProcessIO(io.stdin ?? process.stdin, stdout, env, io.focus ? { focus: io.focus } : {}), truecolor: colorDepth(env) === "truecolor", ...(cli.pet !== undefined ? { pet: cli.pet } : {}), ...(env.ROVECODE_THEME ? { theme: env.ROVECODE_THEME } : {}) });
-}