rovecode 0.3.2 → 0.4.0-beta.2

package/src/tui/git-plain.ts

@@ -1,58 +0,0 @@
-/** `/commit` and `/undo` for `rovecode --plain` (port #65): the readline REPL has no Renderer, so this adapter maps
- *  the handful of Renderer calls git-cmds.ts makes onto console lines and the REPL's own y/n question — the SAME
- *  cmdCommit / cmdUndo run (one implementation, ADR-002), the same bash-tool dispatch and approval chain. A denied
- *  card cannot prefill a readline prompt, so the draft is printed for copy-and-resubmit instead. */
-
-import type { Runtime } from "../cli/runtime.ts";
-import { cmdCommit, cmdUndo, type GitCmdCtx } from "./git-cmds.ts";
-import type { ApprovalAnswer, AssistantView, Renderer, RendererHooks, StatusInfo } from "./renderer.ts";
-import type { ApprovalFn } from "../core/types.ts";
-
-export interface PlainGitDeps {
-  rt: GitCmdCtx["rt"] & Pick<Runtime, "store">;
-  /** the REPL's own approver (its y/n asker) — what a card would have asked, asked on the line */
-  approve: ApprovalFn | undefined;
-  yolo: boolean;
-  /** the REPL's readline question (answers arrive trimmed + lowercased) */
-  ask(question: string): Promise<string>;
-  /** console.log by default; tests capture */
-  out?: (line: string) => void;
-  /** Share the REPL's busy/interrupt state with shell and model turns. */
-  busy?: () => boolean;
-  bindAbort?: (ac: AbortController | null) => void;
-}
-
-/** the console Renderer: notes, tool card lines, the approval question; everything else inert */
-export function plainRenderer(ask: PlainGitDeps["ask"], out: (line: string) => void): Renderer {
-  const oneLine = (s: string): string => s.replace(/\n/g, " ⏎ ");
-  return {
-    start(_h: RendererHooks): void {}, stop(): void {}, setCommands(): void {},
-    addUser(text: string): void { out(text); },
-    addSystemNote(text: string, tone: "info" | "warn" | "error" = "info"): void { out(`  ${tone === "info" ? "" : `${tone}: `}${text}`); },
-    beginAssistant(): AssistantView { return { append() {}, done() {} }; },
-    toolStart(_id: string, tool: string, args: string): void { out(`\n  → ${tool} ${args}`); },
-    toolUpdate(): void {},
-    toolEnd(_id: string, ok: boolean, preview: string): void { out(`  ← ${ok ? "ok" : "FAIL"} ${oneLine(preview)}`); },
-    async askApproval(tool: string, argsPreview: string, detail?: string): Promise<ApprovalAnswer> {
-      out(`\n  approval needed: ${tool} ${argsPreview}`);
-      if (detail) for (const l of detail.split("\n")) out(`    ${l}`);
-      const a = await ask("  allow? [y]es / [n]o: ");
-      return a === "y" || a === "yes" ? "once" : "deny";
-    },
-    async askQuestion(): Promise<null> { return null; },
-    async pickOne(): Promise<null> { return null; },
-    clearTranscript(): void {},
-    prefillEditor(text: string): void { out(`  resubmit with: ${oneLine(text)}`); }, // no editor to prefill in --plain
-    setBusy(_b: boolean, _label?: string): void {},
-    setStatus(_i: StatusInfo): void {},
-  };
-}
-
-/** `/commit [message]` or `/undo` typed at the `--plain` prompt (the REPL gates a busy run before calling this) */
-export async function runPlainGitCommand(deps: PlainGitDeps, text: string): Promise<void> {
-  const renderer = plainRenderer(deps.ask, deps.out ?? console.log);
-  const ctx: GitCmdCtx = { renderer, rt: deps.rt, store: () => deps.rt.store, approve: () => deps.approve, yolo: () => deps.yolo, busy: deps.busy ?? (() => false), setBusy(): void {}, bindAbort: deps.bindAbort ?? (() => {}) };
-  const line = text.trim();
-  if (line === "/undo") await cmdUndo(ctx);
-  else if (line === "/commit" || line.startsWith("/commit ")) await cmdCommit(ctx, line.slice("/commit".length));
-}

package/src/tui/info-cmd.ts

@@ -1,150 +0,0 @@
-/** TUI info commands, extracted from app.ts for the ADR-002 cap (wiring pass): /help /status
- *  /cost /skills /memory /export read state and print a note; /todos (port #32) and /tasks
- *  (port #26) surface the agent-maintained lists. Nothing here moves the session leaf — the
- *  CALLER owns the swappable store/blocks and the status slice, so every read runs through
- *  the injected ctx (same shape as session-cmd / checkpoints-cmd). */
-
-import type { Runtime } from "../cli/runtime.ts";
-import { exportSession } from "../cli/export.ts";
-import { describeSandbox } from "../core/sandbox-config.ts";
-import type { SessionStore } from "../core/session.ts";
-import { formatTaskList, isTerminal } from "../core/tasks.ts";
-import type { BlockStore } from "../memory/blocks.ts";
-import type { ModelCatalog } from "../providers/catalog.ts";
-import { loadTodos, renderTodos, todoStatusLabel } from "../tools/todo.ts";
-import { helpForCommands, type CustomCommand } from "./commands.ts";
-import { memoryCommand } from "./memory-note.ts";
-import { buildCostNote } from "./cost.ts";
-import type { Renderer, SlashCommand } from "./renderer.ts";
-import { join } from "node:path";
-
-export interface InfoStateSlice { provider: string; model: string; turns: number; tokensIn: number; tokensOut: number }
-
-export interface InfoCmdCtx {
-  renderer: Renderer;
-  /** the runtime slices the info commands read: cwd, config provenance, sandbox rung, skills, tasks */
-  rt: Pick<Runtime, "cwd" | "projectContext" | "sandbox" | "skillStore" | "tasks">;
-  /** <cwd>/.rovecode/sessions — todos.json lives under <sessionsDir>/<session id> */
-  sessionsDir: string;
-  /** the ACTIVE session store, read live (/sessions and a root /rewind swap it) */
-  store(): SessionStore;
-  /** the ACTIVE memory block store, read live (swapped with the session) */
-  blocks(): BlockStore;
-  /** provider/model/turns/tokens exactly as the status line shows them */
-  state: InfoStateSlice;
-  commands: { builtin: readonly SlashCommand[]; custom: readonly CustomCommand[] };
-  /** /cost pricing + context window (offline snapshot; `/cost refresh` is the TUI's one fetch) */
-  catalog: ModelCatalog;
-}
-
-/** /help topics in display order; a command with an unknown or missing group lands under "more" at the end */
-export const HELP_GROUP_ORDER: readonly string[] = ["start here", "session", "model & provider", "modes & safety", "files & history", "info"];
-
-/** /help — the built-ins grouped by topic (SlashCommand.group), one plain line each, then the "custom:" tail (port #30). */
-export function cmdHelp(ctx: InfoCmdCtx): void {
-  ctx.renderer.addSystemNote(groupedHelp(ctx.commands.builtin) + helpForCommands(ctx.commands.custom));
-}
-
-/** pure: the grouped body /help prints (tests read it without a renderer) */
-export function groupedHelp(builtin: readonly SlashCommand[]): string {
-  const groups = new Map<string, SlashCommand[]>();
-  for (const c of builtin) { const g = c.group !== undefined && HELP_GROUP_ORDER.includes(c.group) ? c.group : "more"; const l = groups.get(g) ?? []; l.push(c); groups.set(g, l); }
-  const order = [...HELP_GROUP_ORDER, "more"].filter((g) => groups.has(g));
-  return order.map((g) => `${g}\n` + groups.get(g)!.map((c) => `  /${c.name} — ${c.description}`).join("\n")).join("\n");
-}
-
-/** /status — provider/model/turns/tokens, the active executor rung + its origin (port #27), and
- *  config provenance (port #8 HIGH-2: dropped/truncated sources must be visible). */
-export function cmdStatus(ctx: InfoCmdCtx): void {
-  const pc = ctx.rt.projectContext;
-  const cfgBits = pc.sources.map((s) => s.chars === 0 ? `${s.path} (dropped)` : s.truncated ? `${s.path} (truncated)` : s.path);
-  if (pc.skippedFiles > 0) cfgBits.push(`+${pc.skippedFiles} skipped (file cap)`);
-  const s = ctx.state;
-  ctx.renderer.addSystemNote(
-    `provider=${s.provider} model=${s.model} turns=${s.turns} tokens=${s.tokensIn}in/${s.tokensOut}out` +
-    `\nsandbox: ${describeSandbox(ctx.rt.sandbox)}` +
-    `\nconfig: ${cfgBits.length > 0 ? cfgBits.join(", ") : "(none)"}`,
-  );
-}
-
-/** /cost [refresh] — ports #5+#6: normalized usage (incl. cache traffic) priced per message at its
- *  origin model; `refresh` re-fetches models.dev pricing (24h disk cache) — the live half is
- *  user-invoked only, so the TUI stays network-free unless asked. */
-export function cmdCost(ctx: InfoCmdCtx, arg: string): void {
-  if (arg === "refresh") {
-    void ctx.catalog.refresh().then((ok) => ctx.renderer.addSystemNote(
-      ok ? "model catalog refreshed from models.dev" : "catalog refresh failed — using the offline snapshot",
-      ok ? "info" : "warn",
-    ));
-    return;
-  }
-  ctx.renderer.addSystemNote(buildCostNote(ctx.store().messages(), ctx.catalog, { provider: ctx.state.provider, model: ctx.state.model }));
-}
-
-/** /skills — installed skills, one `name — description` row each. */
-export function cmdSkills(ctx: InfoCmdCtx): void {
-  const rows = ctx.rt.skillStore.list().map((s) => `${s.name} — ${s.description}`);
-  ctx.renderer.addSystemNote(rows.length ? rows.join("\n") : "(no skills installed)");
-}
-
-/** `/memory` — both blocks as the store holds them NOW, each with the file it lives in; `/memory --user` the USER
- *  block alone; `/memory <text>` appends to MEMORY and `/memory --user <text>` to USER (tui/memory-note.ts, the
- *  same append path as `#<text>` and the memory_edit tool). It shows the live text rather than renderForPrompt()
- *  so an edit made this run is visible immediately, with a hint that the prompt picks it up next run — and it
- *  names the paths, because the bug this replaced was a note landing somewhere the person did not mean. */
-export function cmdMemory(ctx: InfoCmdCtx, arg = ""): void {
-  const r = memoryCommand(ctx.blocks(), arg);
-  ctx.renderer.addSystemNote(r.text, r.tone);
-}
-
-/** /export [--json] [path] [--force] — port #38: write THIS session as markdown (raw JSONL with
- *  --json), local only. Read-only over the store (exportSession re-reads from disk), so no busy
- *  gate; a spaced path stays whole (every non-flag word joins the path). */
-export function cmdExport(ctx: InfoCmdCtx, arg: string): void {
-  try {
-    const words = arg.split(/\s+/).filter(Boolean);
-    const res = exportSession(ctx.sessionsDir, ctx.store().id, {
-      json: words.includes("--json"), force: words.includes("--force"),
-      out: words.filter((w) => !w.startsWith("-")).join(" ") || undefined, cwd: ctx.rt.cwd,
-    });
-    ctx.renderer.addSystemNote(`exported ${res.format} → ${res.path}`);
-  } catch (e) {
-    ctx.renderer.addSystemNote(e instanceof Error ? e.message : String(e), "error");
-  }
-}
-
-/** /todos — port #32: the agent-maintained list at <session>/todos.json as checkbox rows. A
- *  corrupt file is a warning above the (empty) list, never a throw (loadTodos contract). */
-export function cmdTodos(ctx: InfoCmdCtx): void {
-  const { items, note } = loadTodos(join(ctx.sessionsDir, ctx.store().id));
-  if (note) ctx.renderer.addSystemNote(note, "warn");
-  ctx.renderer.addSystemNote(items.length > 0 ? renderTodos(items) : "(no todos — the agent maintains the list with todo_write)");
-}
-
-/** Status-bar label for the session's list ("todos 1/3"); undefined when empty, so the app omits
- *  the key and plain surfaces never see a blank segment. */
-export function todoLabel(sessionDir: string): string | undefined {
-  return todoStatusLabel(loadTodos(sessionDir).items) || undefined;
-}
-
-/** /tasks [cancel <id>|cancel all] — port #26: the runtime TaskManager's snapshot (the same rows
- *  as the tool's `list` action). Cancel acknowledges the REQUEST here; the "cancelled" line itself
- *  arrives through the app's task subscription when the child run has actually settled (a queued
- *  task settles at once, a running one when its aborted run returns) — one terminal note per task. */
-export function cmdTasks(ctx: InfoCmdCtx, arg: string): void {
-  const words = arg.split(/\s+/).filter(Boolean);
-  const tasks = ctx.rt.tasks;
-  if (words.length === 0) { ctx.renderer.addSystemNote(formatTaskList(tasks.list())); return; }
-  if (words[0] !== "cancel" || words.length !== 2) { ctx.renderer.addSystemNote("usage: /tasks [cancel <id>|cancel all]", "warn"); return; }
-  const id = words[1]!;
-  if (id === "all") {
-    const n = tasks.cancelAll();
-    ctx.renderer.addSystemNote(n === 0 ? "no queued or running tasks to cancel" : `cancelling ${n} task${n === 1 ? "" : "s"}`);
-    return;
-  }
-  const before = tasks.status(id);
-  if (!before) { ctx.renderer.addSystemNote(`unknown task '${id}' — list with /tasks`, "warn"); return; }
-  if (isTerminal(before.status)) { ctx.renderer.addSystemNote(`task ${id} already ${before.status}`); return; }
-  tasks.cancel(id);
-  ctx.renderer.addSystemNote(`cancelling task ${id} (${before.label})`);
-}

package/src/tui/input-plain.ts

@@ -1,76 +0,0 @@
-/** Port #78: --plain shell/mention parity over rovecode's existing dispatch and hashline attachments.
- *  No second executor, classifier, policy or file reader. Unlike aion, rovecode's approval contract has
- *  once/always/deny (no persistent-save verdict), and mentions carry read-tool anchors, not XML file blocks.
- *  This console renderer shares the REPL's once/always/deny approval ladder; git confirmations stay yes/no. */
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import type { Runtime } from "../cli/runtime.ts";
-import type { ApprovalFn } from "../core/types.ts";
-import { expandMentions } from "../sextant/mentions.ts";
-import { cmdAttach, type AttachCtx } from "./attach.ts";
-import type { Renderer } from "./renderer.ts";
-import { runShellLine, type ShellCtx } from "./shell-cmd.ts";
-
-export const PLAIN_APPROVAL_QUESTION = "  allow? [y]es / [a]lways / [n]o: ";
-type Ask = (question: string) => Promise<string>;
-type Out = (line: string) => void;
-const NL = String.fromCharCode(10);
-
-/** The existing REPL ladder, shared by model calls and shell calls; always is session-only. */
-export async function askPlainApproval(ask: Ask, tool: string, args: string, detail?: string, out: Out = console.log): ReturnType<ApprovalFn> {
-  out(`${NL}  approval needed: ${tool} ${args}`);
-  if (detail) for (const line of detail.split(NL)) out(`    ${line}`);
-  const answer = await ask(PLAIN_APPROVAL_QUESTION);
-  return answer === "a" ? "always" : answer === "n" || answer === "" ? "deny" : "once";
-}
-
-export interface PlainInputDeps {
-  rt: ShellCtx["rt"] & Pick<Runtime, "store" | "roots">;
-  yolo(): boolean;
-  busy(): boolean;
-  bindAbort(ac: AbortController | null): void;
-  ask: Ask;
-  modelRef(): { provider: string; model: string };
-  out?: Out;
-}
-
-/** Readline already echoed the typed input; only the tool cards and notes are printed here. */
-export function plainInputRenderer(ask: Ask, out: Out): Renderer {
-  return {
-    start() {}, stop() {}, setCommands() {}, addUser() {},
-    addSystemNote(text, tone = "info") { out(`  ${tone === "info" ? "" : `${tone}: `}${text}`); },
-    beginAssistant() { return { append() {}, done() {} }; },
-    toolStart(_id, tool, args) { out(`${NL}  → ${tool} ${args}`); },
-    toolUpdate() {},
-    toolEnd(_id, ok, preview) { out(`  ← ${ok ? "ok" : "FAIL"} ${preview.split(NL).join(" ⏎ ")}`); },
-    askApproval: (tool, args, detail) => askPlainApproval(ask, tool, args, detail, out),
-    async askQuestion() { return null; }, async pickOne() { return null; },
-    clearTranscript() {}, prefillEditor() {}, setBusy() {}, setStatus() {},
-  };
-}
-
-export async function runPlainShellLine(deps: PlainInputDeps, line: string): Promise<void> {
-  const out = deps.out ?? console.log;
-  const ctx: ShellCtx = {
-    renderer: plainInputRenderer(deps.ask, out), rt: deps.rt, store: () => deps.rt.store,
-    level: () => deps.yolo() ? "auto" : "ask",
-    approve: () => deps.yolo() ? undefined : (req) => askPlainApproval(deps.ask, req.tool, JSON.stringify(req.revisedArgs).slice(0, 140), undefined, out),
-    busy: () => deps.busy(), setBusy() {}, bindAbort: (ac) => deps.bindAbort(ac),
-  };
-  await runShellLine(ctx, line);
-}
-
-/** LAST transform before agentLoop: exact paths (like the classic renderer), added roots, existing
- *  containment/caps, valid edit anchors, and images staged on the same SessionStore through cmdAttach. */
-export function expandPlainInput(deps: PlainInputDeps, text: string): string {
-  const renderer = plainInputRenderer(deps.ask, deps.out ?? console.log);
-  const attach: AttachCtx = { renderer, cwd: deps.rt.cwd, store: () => deps.rt.store, modelRef: () => deps.modelRef() };
-  const result = expandMentions(text, {
-    cwd: deps.rt.cwd, roots: deps.rt.roots.dirs,
-    resolve: (path) => existsSync(resolve(deps.rt.cwd, path)) ? path : null,
-    attachImage: (path) => cmdAttach(attach, path),
-  });
-  for (const note of result.notes) renderer.addSystemNote(note, note.includes(": attached as an image (") ? "info" : "warn");
-  if (result.attached.length > 0) renderer.addSystemNote(`attached: ${result.attached.map((file) => `${file.path} (${file.shown} lines${file.capped ? ", capped" : ""})`).join(" · ")}`);
-  return result.text;
-}

package/src/tui/mcp-cmd.ts

@@ -1,128 +0,0 @@
-/** /mcp — the MCP market inside the TUI, through the two cards the surface already has. `/mcp [query]`
- *  opens the palette (Renderer.pickOne: the same box, keys and fuzzy filter as ⌃k) over the curated
- *  shelf plus the registry's matches; Enter on a row → if the server has several launch forms, one more
- *  pick; then the APPROVAL card (Renderer.askApproval) whose detail is the exact plan — command + args or
- *  URL, source, publisher, version, the env NAMES, the file — and only a yes writes. Kept out of app.ts
- *  (ADR-002 cap) like providers-cmd.ts.
- *
- *  Secrets: the TUI has no masked input, so nothing is ever asked here. An install that wants a key is
- *  written with `${NAME}` (config.ts fills it from the environment at launch) and the closing note says
- *  which names to export — or to run `rovecode mcp add <name>` on a shell, where the prompt is masked. */
-
-import type { Renderer, PickItem } from "./renderer.ts";
-import { installLabel, searchMarket, type MarketDeps, type MarketEntry } from "../mcp/market.ts";
-import { describePlan, fillPlan, namesWritten, planInstall, serverLine, writeServer, type McpScope } from "../mcp/market-install.ts";
-import { parseConfigFile } from "../mcp/config.ts";
-import { mcpTrustStatus, projectMcpFiles, trustMcpFile } from "../mcp/trust.ts";
-import { installLocalPackage, localLaunch, npxPackage } from "../mcp/local-package.ts";
-import { buildRecord, recordInstall } from "../market/manifest.ts";
-import { rovecodeHome } from "../providers/auth.ts";
-
-/** the subcommands the sextant offers after `/mcp ` (Enter completes the word, the name comes next) */
-export const MCP_SUBCOMMANDS = ["search", "info", "add", "remove", "list", "show", "trust", "untrust"] as const;
-export const MCP_COMMAND = { name: "mcp", choices: MCP_SUBCOMMANDS, choicesThen: "complete" as const, description: "Find and install an MCP server: /mcp [query] [--project] — the curated shelf, then the registry · /mcp trust approves this repo's MCP files", group: "modes & safety" };
-
-/** `/mcp trust` — one approval card per project MCP file: the file as preview, its servers as detail; a yes
- *  records the file's current bytes as trusted (mcp/trust.ts), so the NEXT launch loads it */
-async function trustProjectFiles(ctx: McpCmdCtx, home: string): Promise<void> {
-  const files = projectMcpFiles(ctx.cwd);
-  if (files.length === 0) { ctx.renderer.addSystemNote("mcp: no project MCP files here (.rovecode/mcp.json, .mcp.json)"); return; }
-  const anySet = new Proxy({}, { get: () => "set" }) as Record<string, string>;
-  for (const file of files) {
-    if (mcpTrustStatus(home, file) === "trusted") { ctx.renderer.addSystemNote(`mcp: ${file} is already trusted as it is now`); continue; }
-    const warnings: string[] = [];
-    const lines = parseConfigFile(file, warnings, anySet).map(serverLine).concat(warnings.map((w) => `! ${w}`));
-    const answer = await ctx.renderer.askApproval("mcp trust", file, lines.join("\n") || "(no servers in it)");
-    if (answer === "deny") { ctx.renderer.addSystemNote(`mcp: ${file} stays untrusted — nothing in it loads`); continue; }
-    const r = trustMcpFile(home, file);
-    ctx.renderer.addSystemNote(r.ok ? `mcp: trusted ${file} — restart me to connect; an edit asks again` : `mcp: ${r.reason}`, r.ok ? "info" : "warn");
-  }
-}
-
-export interface McpCmdCtx {
-  renderer: Renderer;
-  cwd: string;
-  home?: string;
-  /** registry access — tests inject a fixture fetch or `offline` */
-  market?: MarketDeps;
-  /** how `npm install` runs for the install-once pick — tests inject one that writes a fake node_modules */
-  spawn?: import("../mcp/local-package.ts").Spawn;
-}
-
-const clip = (s: string, n: number): string => (s.length > n ? s.slice(0, n - 1) + "…" : s);
-
-function pickItem(e: MarketEntry): PickItem {
-  const src = e.source === "curated" ? "curated" : `registry · ${e.publisher ?? "?"}`;
-  return { value: e.key, label: e.title ?? e.key, description: `${src}${e.status ? ` · ${e.status}` : ""} · ${clip(e.description, 60)}` };
-}
-
-export async function cmdMcp(ctx: McpCmdCtx, arg: string): Promise<void> {
-  const { renderer } = ctx;
-  const words = arg.split(/\s+/).filter(Boolean);
-  const scope: McpScope = words.includes("--project") ? "project" : "user";
-  const query = words.filter((w) => !w.startsWith("--")).join(" ");
-  const home = ctx.home ?? rovecodeHome();
-  if (words[0] === "trust") { await trustProjectFiles(ctx, home); return; }
-  const market: MarketDeps = { home, ...ctx.market };
-  const found = await searchMarket(query, market);
-  for (const n of found.notes) renderer.addSystemNote(`mcp: ${n}`, "warn");
-  if (found.entries.length === 0) { renderer.addSystemNote(`mcp: nothing matches "${query}" — the registry matches on the server's name`, "warn"); return; }
-  const key = await renderer.pickOne(found.entries.map(pickItem), query ? `mcp market · ${query}` : "mcp market");
-  if (key === null) return;
-  const entry = found.entries.find((e) => e.key === key);
-  if (!entry) return;
-  let pick = 0;
-  if (entry.installs.length > 1) {
-    const how = await renderer.pickOne(entry.installs.map((i, ix) => ({ value: String(ix), label: i.kind === "stdio" ? `run  ${installLabel(i)}` : `connect  ${i.url}` })), `${entry.title ?? entry.key} · how`);
-    if (how === null) return;
-    pick = Number(how);
-  }
-  // the install-once offer (mcp/local-package.ts) as one more pick, BEFORE the plan: the card the human
-  // approves is then the plan that runs. Esc here writes nothing; "as today" is the npx line unchanged.
-  const chosen = entry.installs[pick];
-  const offer = chosen !== undefined ? npxPackage(chosen) : undefined;
-  let local = false;
-  if (offer !== undefined && scope === "user") { // a project file is shared: install-once's absolute path has no place in it (planInstall refuses it too)
-    const how = await renderer.pickOne([
-      { value: "local", label: `install once — node starts it in ~0.4 s`, description: `runs npm install now: ${offer.spec}'s code lands under ~/.rovecode/mcp (typically 20–30 MB, one time); no network needed to start` },
-      { value: "npx", label: `run through npx at every start — as today`, description: `~2 s per start, re-resolves the package and asks the npm registry each time; nothing installed now` },
-    ], `${entry.title ?? entry.key} · how to start it`);
-    if (how === null) return;
-    local = how === "local";
-  }
-  const plan = planInstall(entry, { scope, cwd: ctx.cwd, home, pick, ...(local ? { local: true } : {}) });
-  if ("error" in plan) { renderer.addSystemNote(`mcp: ${plan.error}`, "warn"); return; }
-  // the approval card: title = what is being done, preview = the one line that runs, detail = the whole plan
-  // (for install-once the detail says, in words, that npm runs and code lands on this machine)
-  const answer = await renderer.askApproval("mcp add", `${plan.name} ← ${plan.local ? `node ${plan.local.pkg.spec} (installed once)` : installLabel(plan.install)}`, describePlan(plan, "env").join("\n"));
-  if (answer === "deny") { renderer.addSystemNote("mcp: nothing written"); return; }
-  // install-once: npm first; only its success reaches the file, and what landed goes on record
-  let launch: { command: string; args: string[] } | undefined;
-  let pkgRecord: NonNullable<Parameters<typeof buildRecord>[1]["package"]> | undefined;
-  if (plan.local) {
-    renderer.addSystemNote(`mcp: npm install ${plan.local.pkg.spec} → ${plan.local.prefix} …`);
-    const lr = await installLocalPackage(plan.local.pkg, plan.local.prefix, ctx.spawn ? { spawn: ctx.spawn } : {});
-    if (!lr.ok) { renderer.addSystemNote(`mcp: ${lr.error} — nothing written`, "error"); return; }
-    launch = localLaunch(lr.pkg, plan.local.pkg.rest);
-    pkgRecord = { name: lr.pkg.name, version: lr.pkg.version, prefix: plan.local.prefix, bin: lr.pkg.bin, missing: lr.pkg.missing,
-      ...(lr.pkg.integrity !== undefined ? { integrity: lr.pkg.integrity } : {}), ...(lr.pkg.resolved !== undefined ? { resolved: lr.pkg.resolved } : {}) };
-  }
-  let trusted: boolean | undefined;
-  const raw = fillPlan(plan, {}, launch); // no answers: required asks become ${NAME}, optional ones are left out — the file works without them
-  try {
-    // the card just approved this exact content: a project file is trusted as written (mcp/trust.ts)
-    trusted = writeServer(plan.file, plan.name, raw, scope === "project" ? { trustHome: home } : {}).trusted;
-  } catch (e) { renderer.addSystemNote(`mcp: ${e instanceof Error ? e.message : String(e)}`, "error"); return; }
-  renderer.addSystemNote(`mcp: added "${plan.name}" → ${plan.file}${trusted === true ? " (trusted as written)" : ""} — restart me to connect (servers are read once per process)`);
-  if (pkgRecord) {
-    recordInstall(buildRecord({ kind: "mcp", id: entry.key, source: entry.source, ...(entry.version !== undefined ? { version: entry.version } : {}) },
-      { scope, target: plan.file, package: pkgRecord, installedBy: "mcp add" }), { cwd: ctx.cwd, home });
-    renderer.addSystemNote(`mcp: installed ${pkgRecord.name} ${pkgRecord.version} once → ${plan.local!.prefix}${pkgRecord.integrity !== undefined ? " (integrity recorded in installed.json)" : ""}`);
-    if (pkgRecord.missing?.length) renderer.addSystemNote(`mcp: record incomplete: ${pkgRecord.missing.join("; ")}`, "warn");
-  }
-  if (trusted === false) renderer.addSystemNote("mcp: that file already held servers you have not approved, so it is NOT trusted yet — /mcp trust shows them", "warn");
-  // only the names the FILE now refers to: an optional ask that was left out is not something to go and set
-  const named = namesWritten(plan, raw);
-  if (named.length) renderer.addSystemNote(`mcp: set ${named.join(", ")} in your environment before the restart — or run \`rovecode mcp add ${entry.key}\` on a shell, which asks for them masked`, "warn");
-  if (plan.pending.length) renderer.addSystemNote(`mcp: fill in ${plan.pending.join(", ")} in that file's args before use`, "warn");
-}

package/src/tui/memory-note.ts

@@ -1,77 +0,0 @@
-/** `#<text>` memory shortcut + `/memory [--user] [text]`. A prompt LINE that starts with `#` appends the rest of
- *  the line to the MEMORY block (the project store, memory/scope.ts) — no model turn, one transcript note — the way
- *  `!cmd` short-circuits the prompt (tui/shell-cmd.ts). Pattern source: Claude Code's `#` "add to memory" shortcut
- *  (proprietary — PATTERN ONLY, no code copied).
- *
- *  The classifier is deliberately narrow, because the obvious version swallows pasted code: a note is ONE line
- *  whose trimmed text is `#` followed by a letter or digit (`#always use bun`, `#1 is flaky`). Everything else is a
- *  prompt for the model — any submission with a newline (a pasted `#include …` block, a shebang script), `#`,
- *  `# heading`, `##x`, `#!…`, `#[…]`, `#-flag`, and a `#` INSIDE a line (`fix the #1 bug`).
- *
- *  The edit lands on disk and in the live store at once (memory_edit and /memory see it); the prompt keeps its boot
- *  snapshot and picks the note up on the NEXT run (memory/blocks.ts). Both surfaces share this module. No store is
- *  constructed here — the ACTIVE runtime store is injected, so a session switch cannot leave this writing to a
- *  store nobody reads. */
-
-import type { BlockName, BlockStore } from "../memory/blocks.ts";
-import type { Renderer } from "./renderer.ts";
-
-/** the classifier's opener: `#` then a letter or digit (any script) */
-const NOTE_OPENER = /^#[\p{L}\p{N}]/u;
-
-/** The note of a `#<text>` line, or null when the submission is a prompt for the model (header rule). */
-export function memoryNoteLine(text: string): string | null {
-  if (/[\r\n]/.test(text)) return null; // a multi-line submission is pasted content, never a note
-  const t = text.trim();
-  if (!NOTE_OPENER.test(t)) return null;
-  return t.slice(1).trim();
-}
-
-export type Tone = "info" | "warn";
-
-const LABEL: Readonly<Record<BlockName, string>> = { memory: "MEMORY", user: "USER" };
-
-/** Append `text` to `block` through the store (cap, trust and ledger guarded); the line says WHERE it landed —
- *  the path is the point, since the whole bug this replaced was a note landing somewhere the person did not mean. */
-export function appendMemory(store: BlockStore, block: BlockName, text: string): { ok: boolean; text: string; tone: Tone } {
-  const r = store.add(block, text);
-  if (!r.ok) return { ok: false, tone: "warn", text: `memory: not saved to ${LABEL[block]} — ${r.reason ?? "edit failed"}` };
-  return { ok: true, tone: "info", text: `memory: noted in ${LABEL[block]} (${r.current}/${r.limit} chars, ${store.path(block)}) — in the prompt from the next run` };
-}
-
-export interface MemoryNoteCtx {
-  renderer: Pick<Renderer, "addUser" | "addSystemNote">;
-  /** the ACTIVE block store, read live */
-  blocks(): BlockStore;
-}
-
-/** Run one `#<text>` line: echo it, append to MEMORY, note the outcome. false = not a note line (nothing done). */
-export function runMemoryNote(ctx: MemoryNoteCtx, line: string): boolean {
-  const note = memoryNoteLine(line);
-  if (note === null) return false;
-  ctx.renderer.addUser(line.trim());
-  const r = appendMemory(ctx.blocks(), "memory", note);
-  ctx.renderer.addSystemNote(r.text, r.tone);
-  return true;
-}
-
-/** the /memory hints under a block: an edit this run, a block withheld from the prompt, a block over its cap */
-function blockHints(store: BlockStore, b: BlockName): string {
-  const over = store.overCap(b);
-  return (store.edited(b) ? "\n(edited this run — in the prompt from the next run)" : "")
-    + (store.isWithheld(b) ? "\n(not in the prompt and not writable — it came with this repository; rovecode trust show)" : "")
-    + (over ? `\n(over the ${over.cap}-char cap — the prompt shows the first ${over.cap}; trim the file)` : "");
-}
-
-/** `/memory` → both blocks as the store holds them NOW (live text, path, and a hint when an edit this run is not
- *  yet in the prompt); `/memory --user` → the USER block alone; `/memory <text>` appends to MEMORY and
- *  `/memory --user <text>` to USER (the same append path as `#<text>` and memory_edit add). */
-export function memoryCommand(store: BlockStore, arg: string): { text: string; tone: Tone } {
-  const a = arg.trim();
-  const user = a === "--user" || a.startsWith("--user ");
-  const text = user ? a.slice("--user".length).trim() : a;
-  if (text) { const r = appendMemory(store, user ? "user" : "memory", text); return { text: r.text, tone: r.tone }; }
-  const blocks: BlockName[] = user ? ["user"] : ["memory", "user"];
-  const shown = blocks.map((b) => `# ${LABEL[b]} — ${store.path(b)}\n${store.liveText(b) || "(empty)"}${blockHints(store, b)}`);
-  return { text: shown.join("\n\n"), tone: "info" };
-}

package/src/tui/modes-cmd.ts

@@ -1,45 +0,0 @@
-/** TUI glue for plan/act modes (port #20), extracted from app.ts for the ADR-002 cap.
- *  Pure functions over the ModeManager + the app's mutable state slice. */
-
-import { ModeManager, applyModeRules, buildModeChangeEntry, modeSwitchOf, planModePromptSection, type AgentMode } from "../core/modes.ts";
-import type { SessionStore } from "../core/session.ts";
-import type { AgentDefinition, RunConfig } from "../core/types.ts";
-import type { Renderer } from "./renderer.ts";
-
-export interface ModeStateSlice { provider: string; model: string; mode: AgentMode; busy: boolean }
-
-/** /plan and /act — busy-gated toggle; updates the state slice from the mode's model slot. */
-export function togglePlanAct(modes: ModeManager, cmd: AgentMode, state: ModeStateSlice, renderer: Renderer, pushStatus: () => void): void {
-  if (state.busy) { renderer.addSystemNote("finish or interrupt the run first (Esc)", "warn"); return; }
-  const sw = modes.toggle(cmd);
-  if (!sw) { renderer.addSystemNote(`already in ${cmd} mode`); return; }
-  const cur = modes.modelFor();
-  state.mode = modes.mode; state.model = cur.model; state.provider = cur.provider;
-  renderer.addSystemNote(cmd === "plan" ? "plan mode: read-only tools — writes/shell/spawn denied by policy" : "act mode: full toolset restored");
-  pushStatus();
-}
-
-/** Run-start enforcement: plan mode appends read-only rules AFTER the base set
- *  (last-match-wins overrides even yolo) and steers the system prompt. */
-export function applyModeToRun(modes: ModeManager, cfg: RunConfig, def: AgentDefinition): void {
-  cfg.permissionRules = applyModeRules(modes.mode, cfg.permissionRules);
-  if (modes.mode !== "plan") return;
-  delete cfg.verify; // plan mode changes nothing and runs nothing: the verify gate (core/verify-gate.ts) is off here, not merely idle
-  const base = def.systemPrompt;
-  def.systemPrompt = (v) => (typeof base === "function" ? base(v) : base) + "\n\n" + planModePromptSection();
-}
-
-/** MED-2: a pending mode switch must survive quit and session swaps, not just the
- *  next submit — flush it as a durable entry so resume restores the last mode.
- *  Round-trip cancellations have no pending switch, so nothing lands for them. */
-export function flushModeSwitch(modes: ModeManager, store: SessionStore): void {
-  const sw = modes.consumeSwitchNotice();
-  if (sw) store.append(buildModeChangeEntry(sw, store.messages().at(-1)?.id ?? null));
-}
-
-/** LOW-3: replay label for a system entry — mode switches render as a human line
- *  ("mode → plan"), never the raw <mode_notice> XML the entry carries. */
-export function replayLabel(entry: unknown, text: string): string {
-  const sw = modeSwitchOf(entry);
-  return sw ? `mode → ${sw.to}` : text;
-}

package/src/tui/notify-seq.ts

@@ -1,100 +0,0 @@
-/** Notification sequences + focus tracking for the interactive TUI — PURE: no I/O, no env reads, no timers, no settings.
- *
- *  Pattern source: openai/codex (Apache-2.0, pattern level; no code copied) — codex-rs/tui/src/notifications/mod.rs (the
- *  `auto` backend chooser: OSC 9 on Ghostty / iTerm2 / kitty / Warp / WezTerm, else BEL; the not-OSC-9 list incl. Windows
- *  Terminal, VsCode, AppleTerminal, Alacritty, Vte, Konsole), codex-rs/tui/src/notifications/osc9.rs (the tmux DCS
- *  passthrough: `ESC P tmux ;` + the OSC with every ESC doubled + `ESC \`, and its three test vectors),
- *  codex-rs/terminal-detection/src/lib.rs (the env markers each terminal sets; TERM_PROGRAM masks nothing here — any
- *  marker counts), codex-rs/tui/src/chatwidget/notifications.rs (the whitespace-normalised, capped preview). The
- *  focus-report idiom (DECSET 1004 → CSI I / CSI O) is xterm's. OSC 777 (rxvt-unicode / VTE `notify;title;body`), the
- *  control-byte scrub and the argv parser are rovecode's own.
- *
- *  Why a scrub at all: the model's last answer rides inside an OSC payload whose own terminator is BEL — an embedded BEL
- *  or ESC would end the toast early or start a second sequence. Nothing a model wrote reaches the wire unfiltered. */
-
-export type Env = Readonly<Record<string, string | undefined>>;
-export type NotifyMethod = "bell" | "osc9" | "osc777";
-export type NotifyKind = "run_end" | "approval" | "question";
-export interface NotifyDetail { tool?: string; argsPreview?: string; question?: string; lastText?: string }
-
-export const BEL = "\x07";
-/** DECSET 1004: the terminal reports focus changes as CSI I (in) / CSI O (out) */
-export const FOCUS_ON = "\x1b[?1004h";
-export const FOCUS_OFF = "\x1b[?1004l";
-export const FOCUS_IN = "\x1b[I";
-export const FOCUS_OUT = "\x1b[O";
-
-/** strip every C0 / C1 control byte (tab, newline, CR count as whitespace first, so words never fuse), collapse
- *  whitespace, trim, and cut to `max` characters with a closing `…` */
-export function scrub(text: string, max: number): string {
-  const flat = text.replace(/[\x00-\x1f\x7f-\x9f]/g, (c) => (/\s/.test(c) ? " " : "")).replace(/\s+/g, " ").trim();
-  if (max <= 0) return "";
-  return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
-}
-
-const has = (env: Env, key: string): boolean => (env[key] ?? "") !== "";
-/** codex terminal-detection normalisation of TERM_PROGRAM: spaces, `-`, `_`, `.` dropped, lower-cased */
-const program = (env: Env): string => (env.TERM_PROGRAM ?? "").replace(/[\s_.-]/g, "").toLowerCase();
-
-/** `auto`: OSC 9 only where codex lists a toast-capable terminal (Ghostty, iTerm2, kitty, Warp, WezTerm), else the bell
- *  (Windows Terminal, vscode, Apple_Terminal, alacritty, VTE, unknown). OSC 777 is never picked automatically. */
-export function autoMethod(env: Env): NotifyMethod {
-  const p = program(env), term = env.TERM ?? "";
-  const ghostty = p === "ghostty" || term === "xterm-ghostty" || has(env, "GHOSTTY_RESOURCES_DIR");
-  const iterm = p === "itermapp" || p === "iterm" || p === "iterm2" || has(env, "ITERM_SESSION_ID");
-  const kitty = p === "kitty" || term === "xterm-kitty" || has(env, "KITTY_WINDOW_ID");
-  const warp = p === "warpterminal" || p === "warp";
-  const wezterm = p === "wezterm" || has(env, "WEZTERM_VERSION");
-  return ghostty || iterm || kitty || warp || wezterm ? "osc9" : "bell";
-}
-
-/** inside tmux (a non-empty TMUX): OSC sequences must ride a DCS passthrough to reach the outer terminal */
-export const isTmux = (env: Env): boolean => has(env, "TMUX");
-
-/** the byte-exact sequence for one notification (`msg` already scrubbed by the caller): bell `\x07`; osc9 `ESC ] 9 ; msg BEL`;
- *  osc777 `ESC ] 777 ; notify ; rovecode ; msg BEL`; under tmux the two OSC forms become `ESC P tmux ;` + the sequence with
- *  every ESC doubled + `ESC \` (BEL needs no wrap, tmux passes it through) */
-export function sequenceFor(method: NotifyMethod, msg: string, tmux: boolean): string {
-  if (method === "bell") return BEL;
-  const osc = method === "osc9" ? `\x1b]9;${msg}\x07` : `\x1b]777;notify;rovecode;${msg}\x07`;
-  return tmux ? `\x1bPtmux;${osc.replace(/\x1b/g, "\x1b\x1b")}\x1b\\` : osc;
-}
-
-/** the human line a toast shows — every part scrubbed and capped (approval: ≤ 40 chars of args; question ≤ 60; answer ≤ 120) */
-export function message(kind: NotifyKind, d: NotifyDetail): string {
-  if (kind === "approval") return `approval needed: ${scrub(d.tool ?? "", 40)} ${scrub(d.argsPreview ?? "", 40)}`.trimEnd();
-  if (kind === "question") return `question: ${scrub(d.question ?? "", 60)}`;
-  const last = scrub(d.lastText ?? "", 120);
-  return last ? `run finished: ${last}` : "run finished";
-}
-
-export type Argv = string[] | { error: string };
-export const isArgvError = (a: Argv): a is { error: string } => !Array.isArray(a);
-
-/** `notify_command` text → argv: a JSON string array when it starts with `[` (`["notify-send","rovecode"]`), else split on
- *  whitespace; NEVER handed to a shell (a Windows path with `\` or an argument holding spaces needs the JSON form). `{ error }`
- *  for a `[`-prefixed value that is not a non-empty array of non-empty strings, and for an empty argv. */
-export function parseArgv(value: string): Argv {
-  const text = value.trim();
-  if (text.startsWith("[")) {
-    let parsed: unknown;
-    try { parsed = JSON.parse(text); } catch (e) { return { error: `not a JSON array (${e instanceof Error ? e.message : String(e)})` }; }
-    if (!Array.isArray(parsed) || parsed.length === 0 || !parsed.every((x) => typeof x === "string" && x.length > 0)) return { error: "a JSON array must hold one or more non-empty strings" };
-    return parsed as string[];
-  }
-  const words = text.split(/\s+/).filter((w) => w.length > 0);
-  return words.length === 0 ? { error: "empty command" } : words;
-}
-
-/** Consumes CSI I / CSI O (focus in / out) from a raw input chunk BEFORE the surface's parser sees it. `focused` starts
- *  true: a terminal that never reports focus reads as focused — watched — so `notify_when: unfocused` stays silent there
- *  instead of ringing on every run. No carry across chunks — the classic surface feeds StdinBuffer-reassembled sequences
- *  and the sextant's parseInput degrades a split CSI to a harmless unknown key. */
-export class FocusTracker {
-  focused = true;
-  /** the chunk with every focus report removed (the flag follows the LAST one in it); "" when nothing else was there */
-  feed(chunk: string): string {
-    if (!chunk.includes("\x1b[")) return chunk;
-    return chunk.replace(/\x1b\[([IO])/g, (_m, c: string) => { this.focused = c === "I"; return ""; });
-  }
-}