rovecode 0.3.3 → 0.4.0-beta.2

package/src/tui/commands.ts

@@ -1,283 +0,0 @@
-/** Custom slash commands (port #30): `.rovecode/commands/*.md` (project) and `~/.rovecode/commands/*.md`
- *  (user scope, ROVECODE_HOME-aware) become `/name` commands in the TUI — autocomplete, /help,
- *  and dispatch through the same user-turn path a typed prompt takes.
- *
- *  Ported from opencode @ ebece6e (MIT), packages/opencode/src unless noted:
- *  - discovery: markdown files under a `command(s)/` dir, name = path sans extension
- *    (config/command.ts:13-39 load, config/entry-name.ts:15-19 configEntryNameFromPath);
- *    the frontmatter is the command's metadata and the markdown body its template
- *    (config/command.ts:26-30 `{ name, ...md.data, template: md.content.trim() }`); fields
- *    description/model (packages/core/src/v1/config/command.ts:5-12 — agent/variant/subtask
- *    have no rovecode counterpart; rovecode adds `mode` for plan/act, port #20).
- *  - precedence: the global config dir is loaded before the project's and later entries
- *    replace earlier ones (config/config.ts:473 mergeDeep) → project shadows user here.
- *  - templating (session/prompt.ts:1372-1395): quote-aware argument split (argsRegex :1594,
- *    quoteTrimRegex :1596), `$N` positional (placeholderRegex :1595), `$ARGUMENTS` = the whole
- *    argument string (:1391), and a template with no placeholder gets the arguments appended
- *    after a blank line (:1393-1395); `hints` (command/index.ts:36-44) lists the placeholders.
- *  - a per-command `model` overrides the session model for THAT prompt only (:1411-1412).
- *  Pattern reference only, no code ported: gemini-cli @ 0bd1d43 packages/cli/src/services/
- *  FileCommandLoader.ts — user dir first, project dir second, "last wins" (:85-90, :204-228),
- *  invalid files skipped with a report, never fatal (:277-298).
- *
- *  Deviations: flat directory (no subdirectory namespaces); names are lowercased and must
- *  match [a-z0-9_-]+; YAML-lite frontmatter (`key: value` lines — skills/index.ts
- *  parseFrontmatter, reused) instead of gray-matter, so an unterminated block, a `mode`
- *  outside plan|act, or an empty body skips the file with a boot warning (never a throw);
- *  substitution is ONE pass, so substituted text is never re-scanned, `$$` is a literal `$`,
- *  and a positional `$N` is exactly one token (upstream's "last placeholder absorbs the rest",
- *  prompt.ts:1387, is not ported); no `!\`shell\`` / `@file` injection (prompt.ts:1397-1408) —
- *  the template reaches the model as plain text; a built-in TUI command always beats a custom
- *  one of the same name (warned at boot); a symlinked *.md counts when it points at a file (a
- *  dangling link is reported unreadable); boot-warning echoes and descriptions are bounded.
- *
- *  TUI semantics (runCustomCommand): `mode` switches through the /plan-/act path and STAYS
- *  switched after the run — the switch is a durable session entry (port #20), and silently
- *  flipping back would desynchronize the status line from the session record; `model` is set
- *  the way /model does and restored after the run unless the user re-pointed it mid-run
- *  (/model is not busy-gated). With planActSeparateModels off, /model mirrors writes into
- *  both slots, so the restore does too — same as typing /model <prev> by hand. */
-
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { join, resolve } from "node:path";
-import type { AgentMode, ModeManager } from "../core/modes.ts";
-import { rovecodeHome } from "../providers/auth.ts";
-import { parseFrontmatter } from "../skills/index.ts";
-import { togglePlanAct, type ModeStateSlice } from "./modes-cmd.ts";
-import { expandBuiltinSlash } from "./builtin-prompts.ts"; // port #53: built-in prompt commands beat same-named custom ones
-import type { Renderer, SlashCommand } from "./renderer.ts";
-
-export type CommandScope = "project" | "user";
-
-export interface CustomCommand {
-  /** `/name`: the filename sans `.md`, lowercased; must match [a-z0-9_-]+ */
-  name: string;
-  description: string;
-  /** frontmatter `model:` — per-run override, applied the way /model does */
-  model?: string;
-  /** frontmatter `mode:` — the run happens in this plan/act mode */
-  mode?: AgentMode;
-  /** the markdown body: the prompt template */
-  body: string;
-  /** placeholders the template uses, for /help — opencode hints(): "$1 $2 $ARGUMENTS" */
-  hints: string[];
-  path: string;
-  scope: CommandScope;
-}
-
-export interface ParsedCommandFile { description?: string; model?: string; mode?: AgentMode; body: string }
-
-const NAME_RE = /^[a-z0-9_-]+$/;
-/** opencode prompt.ts:1594 minus its `[Image N]` alternative (no image parts reach this path). */
-const ARGS_RE = /(?:"[^"]*"|'[^']*'|[^\s"']+)/g;
-const QUOTE_TRIM_RE = /^["']|["']$/g;
-/** one pass: `$$` (literal), `$ARGUMENTS`, `$1`..`$9` */
-const PLACEHOLDER_RE = /\$(\$|ARGUMENTS|[1-9])/g;
-/** /help + palette rows stay one line; a 20k-char frontmatter field must not become one */
-const MAX_DESCRIPTION_CHARS = 200;
-
-/** Bounded echo (todo.ts `show` idiom): file content quoted back in a warning is clipped. */
-function clip(s: string, max: number): string {
-  return s.length > max ? s.slice(0, max - 1) + "…" : s;
-}
-
-// ---------- file format ----------
-
-/** Optional `---` frontmatter + body → command fields. `{ error }` names why a file must be
- *  skipped (unterminated block, `mode` outside plan|act, empty body). Never throws. */
-export function parseCommandFile(text: string): ParsedCommandFile | { error: string } {
-  let src = text.charCodeAt(0) === 0xfeff ? text.slice(1) : text; // drop a UTF-8 BOM
-  let fm: Record<string, string> = {};
-  let body = src;
-  if (src.startsWith("---")) {
-    if (!src.endsWith("\n")) src += "\n"; // parseFrontmatter finds the closing fence by its line end
-    const parsed = parseFrontmatter(src);
-    if (!parsed) return { error: "unterminated frontmatter (no closing ---)" };
-    fm = parsed.fm; body = parsed.body;
-  }
-  body = body.trim();
-  if (body === "") return { error: "empty command body (nothing to send)" };
-  const field = (k: string): string | undefined => { const v = fm[k]?.trim(); return v ? v : undefined; };
-  const mode = field("mode");
-  if (mode !== undefined && mode !== "plan" && mode !== "act") return { error: `mode must be "plan" or "act" (got "${clip(mode, 40)}")` }; // LOW-2: bounded echo
-  return { description: field("description"), model: field("model"), mode, body };
-}
-
-/** Placeholders a template uses: `$1..$9` sorted, then `$ARGUMENTS` (command/index.ts:36-44).
- *  `$$` escapes are dropped first so `$$1` does not count. */
-export function hints(body: string): string[] {
-  const src = body.replace(/\$\$/g, "");
-  const out = [...new Set(src.match(/\$[1-9]/g) ?? [])].sort();
-  if (src.includes("$ARGUMENTS")) out.push("$ARGUMENTS");
-  return out;
-}
-
-// ---------- discovery ----------
-
-export interface DiscoverOptions {
-  /** user-scope rovecode dir; default rovecodeHome() (ROVECODE_HOME → ~/.rovecode). Commands: `<home>/commands` */
-  home?: string;
-  /** built-in command names — a custom command with one of these names is dropped, with a warning */
-  reserved?: readonly string[];
-  /** more command folders — a plugin's (src/plugins) — scanned AFTER the folder of the same scope, so
-   *  your own `~/.rovecode/commands/x.md` or `.rovecode/commands/x.md` keeps `/x` over a plugin's */
-  extraDirs?: readonly { dir: string; scope: CommandScope }[];
-}
-
-export interface DiscoveredCommands { commands: CustomCommand[]; warnings: string[] }
-
-/** Scan `<home>/commands` then `<cwd>/.rovecode/commands`; a later (project) entry replaces an
- *  earlier (user) one of the same name. Missing dirs are silent (the common case); every
- *  other problem is a warning for the boot transcript, never a throw. Sorted by name. */
-export function discoverCommands(cwd: string, opts: DiscoverOptions = {}): DiscoveredCommands {
-  const warnings: string[] = [];
-  const reserved = new Set(opts.reserved ?? []);
-  const userDir = join(opts.home ?? rovecodeHome(), "commands");
-  const projectDir = join(cwd, ".rovecode", "commands");
-  const extra = (scope: CommandScope): [CommandScope, string][] => (opts.extraDirs ?? []).filter((e) => e.scope === scope).map((e) => [scope, e.dir]);
-  // cwd IS the rovecode home: one directory, scanned once (gemini-cli FileCommandLoader.ts:221-228)
-  const dirs: [CommandScope, string][] = resolve(userDir) === resolve(projectDir)
-    ? [["project", projectDir], ...extra("user"), ...extra("project")]
-    : [["user", userDir], ...extra("user"), ["project", projectDir], ...extra("project")];
-  const byName = new Map<string, CustomCommand>();
-  for (const [scope, dir] of dirs) {
-    for (const cmd of scanCommandDir(dir, scope, warnings)) {
-      // the verdict first, the path last: an 80-column terminal wraps a long path mid-line and the
-      // sentence must survive at the line start
-      if (reserved.has(cmd.name)) { warnings.push(`/${cmd.name} is a built-in command — built-in kept (${cmd.path})`); continue; }
-      const prev = byName.get(cmd.name);
-      if (prev?.scope === scope) { warnings.push(`${cmd.path}: /${cmd.name} already defined by ${prev.path} — first kept`); continue; }
-      byName.set(cmd.name, cmd); // project (scanned second) shadows user
-    }
-  }
-  return { commands: [...byName.values()].sort((a, b) => a.name.localeCompare(b.name)), warnings };
-}
-
-/** LOW-3: a symlinked `*.md` counts when its target is a file (a link to a directory is skipped
- *  like any directory); a DANGLING link stays in the list so the read below reports it unreadable. */
-function linksToFile(path: string): boolean {
-  try { return statSync(path).isFile(); } catch { return true; }
-}
-
-/** One directory's `*.md` files (top level only, sorted), each parsed or warned about. */
-function scanCommandDir(dir: string, scope: CommandScope, warnings: string[]): CustomCommand[] {
-  let files: string[];
-  try {
-    files = readdirSync(dir, { withFileTypes: true })
-      .filter((e) => /\.md$/i.test(e.name) && (e.isFile() || (e.isSymbolicLink() && linksToFile(join(dir, e.name)))))
-      .map((e) => e.name).sort();
-  } catch {
-    return []; // no such directory — silent, like the skills store
-  }
-  const out: CustomCommand[] = [];
-  for (const file of files) {
-    const path = join(dir, file);
-    const name = file.slice(0, -3).toLowerCase();
-    if (!NAME_RE.test(name)) { warnings.push(`${path}: skipped — command name "${name}" must match [a-z0-9_-]+`); continue; }
-    let text: string;
-    try {
-      text = readFileSync(path, "utf8");
-    } catch (e) {
-      warnings.push(`${path}: skipped — unreadable (${e instanceof Error ? e.message : String(e)})`);
-      continue;
-    }
-    const parsed = parseCommandFile(text);
-    if ("error" in parsed) { warnings.push(`${path}: skipped — ${parsed.error}`); continue; }
-    out.push({
-      name, description: clip(parsed.description ?? `custom command (${file})`, MAX_DESCRIPTION_CHARS), model: parsed.model, mode: parsed.mode,
-      body: parsed.body, hints: hints(parsed.body), path, scope,
-    });
-  }
-  return out;
-}
-
-// ---------- templating ----------
-
-/** Template → prompt. `$ARGUMENTS` = the whole argument string, `$1..$9` = one quote-aware token
- *  each ("" when missing), `$$` = a literal `$`. One pass, so substituted text is never
- *  re-scanned. A template without placeholders gets the arguments appended after a blank line
- *  (prompt.ts:1393-1395) so nothing the user typed is silently dropped. */
-export function renderCommand(cmd: Pick<CustomCommand, "body">, argString: string): string {
-  const raw = argString.trim();
-  const args = (raw.match(ARGS_RE) ?? []).map((a) => a.replace(QUOTE_TRIM_RE, ""));
-  let placeholder = false;
-  const out = cmd.body.replace(PLACEHOLDER_RE, (_m, tok: string) => {
-    if (tok === "$") return "$";
-    placeholder = true;
-    return tok === "ARGUMENTS" ? raw : (args[Number(tok) - 1] ?? "");
-  });
-  return placeholder || raw === "" ? out : `${out}\n\n${raw}`;
-}
-
-/** `rovecode run "/name args"` hook (main.ts call sites — see the port notes): a leading `/name`
- *  that names a discovered command renders to its prompt; anything else passes through
- *  verbatim. `model`/`mode` are TUI semantics and are not applied here. */
-export function expandSlashPrompt(prompt: string, cwd: string, opts: DiscoverOptions = {}): string {
-  // port #53: the built-in prompt commands (/init) are consulted FIRST — a built-in beats a
-  // same-named custom command, as in the TUI (aion commands.ts:216). Order matters: reversed, a
-  // repo file named init.md would silently swallow rovecode run "/init".
-  const builtin = expandBuiltinSlash(prompt, cwd);
-  if (builtin !== undefined) return builtin;
-  const m = /^\/(\S+)(?:\s+([\s\S]*))?$/.exec(prompt.trim());
-  if (!m) return prompt;
-  const cmd = discoverCommands(cwd, opts).commands.find((c) => c.name === m[1]!.toLowerCase());
-  return cmd ? renderCommand(cmd, m[2] ?? "") : prompt;
-}
-
-// ---------- TUI surface ----------
-
-/** Entries for Renderer.setCommands (editor autocomplete) — appended after the built-ins. */
-export function commandsForPalette(list: readonly CustomCommand[]): SlashCommand[] {
-  return list.map((c) => ({ name: c.name, description: c.description }));
-}
-
-/** `/help` tail: "" when there are none, else a "custom:" section (name, hints, description, scope). */
-export function helpForCommands(list: readonly CustomCommand[]): string {
-  if (list.length === 0) return "";
-  return "\ncustom:\n" + list
-    .map((c) => `/${c.name}${c.hints.length > 0 ? " " + c.hints.join(" ") : ""} — ${c.description} (${c.scope})`)
-    .join("\n");
-}
-
-/** What the TUI hands the dispatcher (app.ts builds it once; state is read live). */
-export interface CustomCommandCtx {
-  renderer: Renderer;
-  modes: ModeManager;
-  state: ModeStateSlice;
-  pushStatus: () => void;
-  /** the plain user-turn path (app.ts `submit`): echo, flush a pending mode switch, start the run */
-  submit: (text: string) => Promise<void>;
-}
-
-/** handleSlash `default:` hook: false when `name` is not a custom command (the caller reports
- *  "unknown command"); true after kicking off the run — fire-and-forget, the same shape as the
- *  other async slash commands. */
-export function dispatchCustomCommand(ctx: CustomCommandCtx, list: readonly CustomCommand[], name: string, arg: string): boolean {
-  const cmd = list.find((c) => c.name === name);
-  if (!cmd) return false;
-  void runCustomCommand(ctx, cmd, arg);
-  return true;
-}
-
-/** Busy-gated like /plan and /checkpoints — a rendered prompt with a model/mode attached cannot
- *  be queued as steering. `mode` → togglePlanAct (stays); `model` → setModel like /model,
- *  restored after the run unless the user re-pointed it meanwhile (header: TUI semantics). */
-export async function runCustomCommand(ctx: CustomCommandCtx, cmd: CustomCommand, arg: string): Promise<void> {
-  if (ctx.state.busy) { ctx.renderer.addSystemNote("finish or interrupt the run first (Esc)", "warn"); return; }
-  if (cmd.mode !== undefined && cmd.mode !== ctx.modes.mode) togglePlanAct(ctx.modes, cmd.mode, ctx.state, ctx.renderer, ctx.pushStatus);
-  const prev = ctx.modes.modelFor().model;
-  const override = cmd.model !== undefined && cmd.model !== prev;
-  if (override) {
-    ctx.modes.setModel({ model: cmd.model });
-    ctx.state.model = ctx.modes.modelFor().model;
-    ctx.renderer.addSystemNote(`model → ${cmd.model} for /${cmd.name} (restored after the run)`);
-    ctx.pushStatus();
-  }
-  try {
-    await ctx.submit(renderCommand(cmd, arg));
-  } finally {
-    if (override && ctx.modes.modelFor().model === cmd.model) {
-      ctx.modes.setModel({ model: prev }); ctx.state.model = prev; ctx.pushStatus();
-    }
-  }
-}

package/src/tui/config-view.ts

@@ -1,53 +0,0 @@
-/** `/config [all]` (aion port, re-shaped): the read-only TUI view of rovecode's ACTUAL settings model — the two
- *  settings.json scopes (core/settings.ts) merged the way the loaders merge them, plus the environment the
- *  process is running with. Aion's `describeSettings`/knob table is NOT ported: rovecode has no such table, and
- *  a view that invented one would describe a settings model the real loaders do not use. What IS shown is what
- *  the loaders read, keyed the way they read it:
- *    - files first: which of the two settings.json files exists (a missing project file is the common case,
- *      and "you could create one" is more useful than pretending it is empty);
- *    - then every settings.json key that is SET, with the scope that wins for it (project beats user — the
- *      merge in loadSettings) and the value; `verify: false` shown as read (a refusal, honoured from any file);
- *    - then the ROVECODE_* variables this process carries (names + values, values of keys never shown);
- *    - the permission level is resolved the way the CLI resolves it and stated in words.
- *  Nothing is written here; editing is the file by hand (rovecode has no `config set`). A value changed on
- *  disk mid-session is picked up on the next read — the loaders read per call — so this view is a snapshot of
- *  NOW, not of boot. Same ctx idiom as info-cmd.ts: renderer + cwd. */
-
-import type { Renderer } from "./renderer.ts";
-import { existsSync } from "node:fs";
-import { loadSettings, loadSettingsScoped, resolvePermission, settingsPath, type Settings } from "../core/settings.ts";
-import { rovecodeHome } from "../providers/auth.ts";
-
-export interface ConfigViewCtx { renderer: Pick<Renderer, "addSystemNote">; cwd: string; /** the CLI's explicit flag, when it gave one */ permissionFlag?: Parameters<typeof resolvePermission>[1] }
-
-const KEYS: readonly (keyof Settings)[] = ["permission", "effort", "bell", "notify", "notify_when", "notify_command", "verify", "lsp"];
-const short = (v: unknown): string => { const s = typeof v === "string" ? v : JSON.stringify(v); return s.length > 80 ? `${s.slice(0, 79)}…` : s; };
-
-/** the note text, pure — `all` also lists the keys nothing set and the env vars named-but-unset is out of scope:
- *  rovecode's env page (`rovecode help env`) is the complete list, this view shows what THIS run carries */
-export function renderConfigView(cwd: string, all: boolean, env: Readonly<Record<string, string | undefined>> = process.env, home: string = rovecodeHome(), flag?: Parameters<typeof resolvePermission>[1]): string {
-  const user = settingsPath("user", cwd);
-  const project = settingsPath("project", cwd);
-  const scoped = loadSettingsScoped(cwd, home);
-  const merged = loadSettings(cwd);
-  const lines: string[] = [];
-  lines.push(`settings — user: ${user}${existsSync(user) ? "" : " (absent)"} · project: ${project}${existsSync(project) ? "" : " (absent)"}`);
-  lines.push(`permission: ${resolvePermission(cwd, flag, env)}${scoped.dropped.length > 0 ? ` · the project file's ${scoped.dropped.join(", ")} ${scoped.dropped.length === 1 ? "is" : "are"} ignored until you trust that file (rovecode trust show)` : ""}`);
-  const set = KEYS.filter((k) => merged[k] !== undefined && k !== "permission");
-  if (set.length === 0) lines.push("(no settings.json key is set — every knob is at its default)");
-  for (const k of set) {
-    const scope = scoped.project[k] !== undefined ? "project" : "user";
-    lines.push(`${k} = ${short(merged[k])}  [${scope}]`);
-  }
-  const envNames = Object.keys(env).filter((k) => k.startsWith("ROVECODE_") && env[k] !== "").sort();
-  if (envNames.length > 0) {
-    if (all) for (const n of envNames) lines.push(`${n} = ${/KEY|TOKEN|SECRET/i.test(n) ? "(set — value not shown)" : short(env[n])}  [env]`);
-    else lines.push(`env: ${envNames.length} ROVECODE_* variable${envNames.length === 1 ? "" : "s"} set (/config all names them)`);
-  }
-  return lines.join("\n");
-}
-
-/** `/config [all]` */
-export function cmdConfigView(ctx: ConfigViewCtx, arg: string): void {
-  ctx.renderer.addSystemNote(renderConfigView(ctx.cwd, arg.trim() === "all", process.env, rovecodeHome(), ctx.permissionFlag));
-}

package/src/tui/context-cmds.ts

@@ -1,282 +0,0 @@
-/** TUI context commands (port #53): /compact [focus] · /clear · /init · /copy [n]. Split out of
- *  app.ts for the ADR-002 cap; app.ts adds the four palette entries (CONTEXT_COMMANDS) and the
- *  dispatch cases. The CALLER owns the swappable store, the mode manager and the session-switch
- *  routine, so everything runs through the injected ctx (session-cmd.ts shape).
- *
- *  /compact  ADR-007: the ONE strategy set. compactSession calls core/compaction.ts planCompaction +
- *            applyCompaction with the run's own RunConfig (rt.buildCfg) and the loop's CompactionCtx
- *            shape (trigger "manual"; tokenText = partsTokenText). PORT NOTE — this tree has no
- *            summarizer wired anywhere (rovecode's runtime builds none; grep `.summarize` finds only
- *            memory/recall's own), and its `Summarizer` is `(texts) => Promise<string>` with no signal
- *            argument (aion's #68 one takes the signal and returns usage/origin). So on THIS tree
- *            head-summarize falls back to keep-window at PLAN time and the note says "no summarizer
- *            wired on this surface" — that note is the feature working, not a degradation, and it is
- *            the user-visible text until #68 lands (owned by nimbus-2d as a core piece). The signal
- *            still matters: loop.ts:215 threads ctx.signal, and when #68 lands the abort path is
- *            already here — cmdCompact OWNS an AbortController bound through ctx.bindAbort (the app's
- *            Esc / ⌃c target, ShellCtx.bindAbort shape; the --plain REPL binds Ctrl-C the same way).
- *            A manual compaction must be DURABLE or the next run would see the full history again
- *            (the automatic one is per-run and transient — loop.ts rebuilds history from
- *            store.messages() every run): the outcome history becomes a new branch of the append-only
- *            tree (fresh-id copies chained under the summary/marker message as a new root; ADR-004 —
- *            nothing deleted, the earlier turns stay in the file on the previous branch), the leaf
- *            moves there (meta.json, like /new), and the compaction marker is persisted with
- *            store.appendEvent — the same event shape and call the loop uses (loop.ts:216-217) — so
- *            replay and `rovecode export` show it. A focus hint is accepted but NOT applied: none of
- *            the strategies takes instructions (the summarizer signature is texts only); the note says
- *            so.
- *  /clear    a fresh session in place through the app's switchSession: same cwd/renderer, the live
- *            mode and the model slots survive, the transcript is emptied, the previous session is
- *            untouched and resumable.
- *  /init     submits the built-in AGENTS.md prompt (builtin-prompts.ts, ported alongside) as a plain
- *            user turn — the write/edit goes through the approval seam like any tool call.
- *  /copy     the last (or n-th from the end) assistant message's text → the clipboard (clipboard.ts).
- *  All four are busy-gated with the shared "finish or interrupt the run first" note.
- *
- *  Pattern reference only, no code ported: gemini-cli @ 0bd1d43 packages/cli/src/ui/commands/
- *  {compressCommand,clearCommand,initCommand,copyCommand}.ts — force-compress shows original→new
- *  token counts (:49-61); /clear ends the recording, mints a new session id and clears the UI
- *  (:41-76); /copy takes the last model message's text parts (:24-41). */
-
-import { randomUUID } from "node:crypto";
-import { existsSync } from "node:fs";
-import { basename, isAbsolute, join } from "node:path";
-import { applyCompaction, planCompaction, DEFAULT_COMPACTION_STRATEGY, type CompactionCtx, type CompactionStrategy } from "../core/compaction.ts";
-import { estimateTokens } from "../core/context.ts";
-import { partsText, partsTokenText } from "../core/loop.ts";
-import { buildModeChangeEntry, modeFromEntries, type AgentMode, type ModeManager } from "../core/modes.ts";
-import type { SessionStore } from "../core/session.ts";
-import { ATTACHMENTS_DIR } from "../core/session-images.ts";
-import type { Message, MessagePart, RunConfig } from "../core/types.ts";
-import { expandBuiltinSlash, INIT_TARGET } from "./builtin-prompts.ts";
-import { copyToClipboard, type ClipboardOptions } from "./clipboard.ts";
-import type { ModeStateSlice } from "./modes-cmd.ts";
-import type { Renderer, SlashCommand } from "./renderer.ts";
-import { compactionNote, type CompactionEvent } from "./replay-marker.ts";
-
-/** palette + /help entries, appended to TUI_COMMANDS (reserved against custom commands like the rest).
- *  rovecode's SlashCommand carries a `group` — the /help topic (info-cmd.ts). /compact and /copy are
- *  session-scope facts (what the context holds, what to copy out of it); /init writes a project file,
- *  /clear starts over, so they sit with files & history and session. */
-export const CONTEXT_COMMANDS: SlashCommand[] = [
-  { name: "compact", description: "Compact the context now: /compact [focus] — the automatic strategy set, marker persisted", group: "session" },
-  { name: "clear", description: "Fresh session in place (transcript emptied; the previous session is kept — /resume <id>)", group: "session" },
-  { name: "init", description: "Analyse the repo and write AGENTS.md (an existing one gets targeted improvements)", group: "files & history" },
-  { name: "copy", description: "Copy the last assistant message to the clipboard: /copy [n] (n-th from the end)", group: "session" },
-];
-
-/** a session below this many messages on the active path is "short": one note, no plan, no model call */
-export const MIN_COMPACT_MESSAGES = 6;
-const BUSY_WARN = "finish or interrupt the run first (Esc)";
-
-export interface ContextCmdCtx {
-  renderer: Renderer;
-  cwd: string;
-  busy(): boolean;
-  /** the ACTIVE session store, read live */
-  store(): SessionStore;
-  modes: ModeManager;
-  /** the app's status slice (mode/model/provider/busy) — mutated in place like modes-cmd does */
-  state: ModeStateSlice;
-  /** the modes config's defaultMode ?? "act": what a session with no mode entry resumes to */
-  defaultMode: AgentMode;
-  /** the RunConfig a run would start with right now (rt.buildCfg) — the compaction strategy/budget source */
-  buildCfg(): RunConfig;
-  /** THIS TREE: no summarizer is wired anywhere (see the header), so this stays undefined in the TUI;
-   *  the field exists so #68's runtime wiring has a seam to land in and the tests can inject one.
-   *  rovecode's Summarizer shape: (texts: string[]) => Promise<string> */
-  summarize?: CompactionCtx["summarize"];
-  /** the app's interrupt target (Esc / ⌃c / quit abort it) — bound for /compact's lifetime, then
-   *  cleared with null (ShellCtx.bindAbort shape) */
-  bindAbort?(ac: AbortController | null): void;
-  /** rebind the app to session id (store, memory, mode) and replay it (app.ts switchSession) */
-  switchSession(id: string, announce?: boolean): void;
-  replayHistory(): void;
-  refreshUsage(): void;
-  pushStatus(): void;
-  /** the plain user-turn path (app.ts submit) */
-  submit(text: string): Promise<void>;
-  /** test seam: platform + spawner for /copy; default = the real chain */
-  clipboard?: ClipboardOptions;
-}
-
-// ---------- /compact ----------
-
-export type CompactOutcome =
-  | { kind: "compacted"; event: CompactionEvent; fallbackFrom?: CompactionStrategy; dropped: number; kept: number }
-  | { kind: "nothing"; reason: string };
-
-/** the surface's half of the loop's CompactionCtx (loop.ts:215) — what it wires for automatic compaction */
-export interface CompactDeps { model?: CompactionCtx["model"]; summarize?: CompactionCtx["summarize"]; native?: CompactionCtx["native"]; signal?: AbortSignal }
-
-/** The on-disk form of copied parts: a hydrated sidecar path (absolute, under <session>/attachments)
- *  goes back to the canonical `attachments/<file>` — a persisted absolute path is dropped at load
- *  (session-images.ts F3), so re-appending the in-memory form would silently lose the image. */
-function persistableParts(parts: readonly MessagePart[]): MessagePart[] {
-  return parts.map((p) => p.kind === "image" && p.path !== undefined && isAbsolute(p.path) ? { ...p, path: `${ATTACHMENTS_DIR}/${basename(p.path)}` } : p);
-}
-
-/** Compact the store's active path NOW through the ONE strategy set and make the result durable
- *  (header). Pure over (store, cfg, deps): no renderer, so the --plain REPL shares it. */
-export async function compactSession(store: SessionStore, cfg: RunConfig, deps: CompactDeps = {}): Promise<CompactOutcome> {
-  const history = store.messages();
-  const n = history.length;
-  if (n < MIN_COMPACT_MESSAGES) return { kind: "nothing", reason: `nothing to compact — ${n} message${n === 1 ? "" : "s"} on the active path (compaction needs at least ${MIN_COMPACT_MESSAGES})` };
-  const tokenText = (m: Message): string => partsTokenText(m.parts);
-  const tokensOf = (ms: readonly Message[]): number => ms.reduce((t, m) => t + estimateTokens(tokenText(m)), 0);
-  // PORT NOTE: aion passes trigger "manual"; rovecode's CompactionTrigger is "speculative" |
-  // "emergency" (aion's "manual" arrives with #68's core work, owned by 2d). "speculative" is the
-  // honest stand-in: a threshold-triggered plan — and the marker this writes says strategy + token
-  // counts only (compactionNote), so no surface reads the trigger word.
-  const cctx: CompactionCtx = { trigger: "speculative", tokenText, summarize: deps.summarize, native: deps.native, model: deps.model, signal: deps.signal };
-  const plan = planCompaction(history, cfg, cctx);
-  const out = plan ? await applyCompaction(history, plan, cfg, cctx) : null;
-  if (!out) return { kind: "nothing", reason: `nothing to compact — ${cfg.compactionStrategy ?? DEFAULT_COMPACTION_STRATEGY} found nothing droppable (${tokensOf(history)} tokens)` };
-  const tokensBefore = tokensOf(history);
-  const tokensAfter = tokensOf(out.history);
-  // durable branch: fresh-id copies (the same ids would be duplicate-id corruption) chained under a
-  // new root; the stage is parked meanwhile — append() folds staged attachments into ANY user message
-  const staged = store.stagedAttachments;
-  store.stageAttachments([]);
-  const prevLeaf = history.at(-1)?.id;
-  let parentId: string | null = null;
-  try {
-    for (const m of out.history) {
-      const copy: Message = { ...m, id: randomUUID(), parentId, parts: persistableParts(m.parts) };
-      store.append(copy);
-      parentId = copy.id;
-    }
-    if (parentId !== null) store.branch(parentId); // durable leaf (meta.json), like /new — a resume lands on the compacted branch
-  } catch (e) {
-    if (prevLeaf !== undefined) store.branch(prevLeaf); // a half-written branch is abandoned, the old path stays active
-    throw e;
-  } finally {
-    store.stageAttachments(staged);
-  }
-  // the marker, exactly as loop.ts persists the automatic one (rovecode's CompactionEvent has no
-  // fallback tag/usage fields — those arrive with #68; the marker already shows before → after tokens)
-  // the marker, exactly as loop.ts persists the automatic one (loop.ts:216-217). trigger is omitted:
-  // rovecode's RunEvent types it "speculative" | "emergency" only, and a manual compaction has no
-  // honest word in that union yet (#68) — absent beats a false one, and compactionNote renders
-  // strategy + counts, never the trigger.
-  const event: CompactionEvent = { type: "compaction", strategy: out.strategy, tokensBefore, tokensAfter };
-  store.appendEvent(event);
-  const original = new Set(history.map((m) => m.id));
-  const kept = out.history.filter((m) => original.has(m.id)).length;
-  return { kind: "compacted", event, dropped: n - kept, kept, ...(out.fallbackFrom ? { fallbackFrom: out.fallbackFrom } : {}) };
-}
-
-/** The detail line after the marker's before/after line. rovecode's plan-time fallback carries
- *  `fallbackFrom` ("head-summarize" when no summarizer is wired — THIS TREE'S normal case) but no
- *  reason text; the wording names the wiring, which is the thing missing here (aion #68 adds the
- *  apply-time reason with the fenced summarizer). */
-export function compactDetails(res: Extract<CompactOutcome, { kind: "compacted" }>, focus: string): string {
-  const s = (k: number): string => (k === 1 ? "" : "s");
-  return `${res.dropped} message${s(res.dropped)} dropped, ${res.kept} kept — the earlier turns stay in the session file on the previous branch` +
-    (res.fallbackFrom ? ` · ${res.fallbackFrom} could not run on this surface (no summarizer wired) — ${res.event.strategy} ran instead` : "") +
-    (focus ? ` · focus "${focus}" not applied — the compaction strategies take no instructions` : "");
-}
-
-/** Both lines for a surface without replay (the --plain REPL): the marker wording, then the details. */
-export function compactNoteLines(res: CompactOutcome, focus: string): string[] {
-  return res.kind === "nothing" ? [res.reason] : [compactionNote(res.event), compactDetails(res, focus)];
-}
-
-/** /compact [focus] — busy-gated, and it HOLDS the busy flag while it runs (a concurrent submit queues
- *  as steering instead of starting a run — a future summarizer would be a model call) without a
- *  renderer spinner: there is no run for the surface to settle (the sextant would mark one "stopped").
- *  The transcript is replayed from the compacted path, so what the user sees is what the model gets:
- *  the summary/marker note, the kept turns, then the persisted marker line (before → after tokens). */
-export async function cmdCompact(ctx: ContextCmdCtx, focus: string): Promise<void> {
-  if (ctx.busy()) { ctx.renderer.addSystemNote(BUSY_WARN, "warn"); return; }
-  const store = ctx.store();
-  ctx.state.busy = true;
-  const ac = new AbortController(); // Esc / ⌃c abort the in-flight summarize call — bound like `!cmd` (shell-cmd.ts), cleared after
-  ctx.bindAbort?.(ac);
-  let res: CompactOutcome;
-  try {
-    res = await compactSession(store, ctx.buildCfg(), { model: ctx.modes.modelFor(), summarize: ctx.summarize, signal: ac.signal }); // the runtime's summarizer, the command's signal
-  } catch (e) {
-    res = { kind: "nothing", reason: `compaction failed: ${e instanceof Error ? e.message : String(e)} — the session is unchanged` };
-  } finally {
-    ctx.bindAbort?.(null);
-    ctx.state.busy = false;
-  }
-  if (res.kind === "nothing") { ctx.renderer.addSystemNote(res.reason, res.reason.startsWith("compaction failed") ? "error" : "info"); ctx.pushStatus(); return; }
-  // a mode entry that lived in the dropped head would make a resume land in the default mode:
-  // re-record the live mode on the new branch (durable entry, same shape flushModeSwitch writes)
-  const resumesAs = modeFromEntries(store.messages()) ?? ctx.defaultMode;
-  if (resumesAs !== ctx.modes.mode) store.append(buildModeChangeEntry({ from: resumesAs, to: ctx.modes.mode }, store.messages().at(-1)?.id ?? null));
-  ctx.replayHistory(); ctx.refreshUsage(); ctx.pushStatus();
-  ctx.renderer.addSystemNote(compactDetails(res, focus));
-}
-
-// ---------- /clear ----------
-
-/** /clear — a fresh session in place. switchSession restores the CONFIG default mode for a session
- *  with no entries; a clear keeps the LIVE mode, recorded the way /plan records it (a pending notice
- *  the next submit — or quit — flushes as a durable entry), and the in-memory model slots carry over. */
-export function cmdClear(ctx: ContextCmdCtx): void {
-  if (ctx.busy()) { ctx.renderer.addSystemNote(BUSY_WARN, "warn"); return; }
-  const old = ctx.store().id;
-  const mode = ctx.modes.mode;
-  const id = randomUUID();
-  ctx.switchSession(id, false);
-  if (ctx.modes.mode !== mode) {
-    ctx.modes.toggle(mode);
-    const cur = ctx.modes.modelFor();
-    ctx.state.mode = mode; ctx.state.model = cur.model; ctx.state.provider = cur.provider;
-    ctx.pushStatus();
-  }
-  ctx.renderer.addSystemNote(`cleared — fresh session ${id.slice(0, 8)} in the same directory; session ${old.slice(0, 8)} kept (/resume ${old.slice(0, 8)})`);
-}
-
-// ---------- /init ----------
-
-/** /init — the built-in AGENTS.md prompt through the plain user-turn path. Busy-gated like a custom
- *  command (runCustomCommand): a built-in prompt is never queued as steering. */
-export async function cmdInit(ctx: ContextCmdCtx): Promise<void> {
-  if (ctx.busy()) { ctx.renderer.addSystemNote(BUSY_WARN, "warn"); return; }
-  const prompt = expandBuiltinSlash("/init", ctx.cwd);
-  if (prompt === undefined) return; // unreachable: "init" is in BUILTIN_PROMPTS
-  ctx.renderer.addSystemNote(existsSync(join(ctx.cwd, INIT_TARGET))
-    ? `${INIT_TARGET} exists — asking the agent for targeted improvements (edits go through the usual approval)`
-    : `analysing the repository to write ${INIT_TARGET} (the write goes through the usual approval)`);
-  await ctx.submit(prompt);
-}
-
-// ---------- /copy ----------
-
-/** The n-th-from-the-end assistant message WITH text (tool-call-only turns do not count) → the
- *  clipboard; one note either way, never a throw. Shared with the --plain REPL. */
-export async function copyAssistantMessage(messages: readonly Message[], n: number, opts: ClipboardOptions = {}): Promise<{ text: string; tone: "info" | "warn" }> {
-  const texts = messages.filter((m) => m.role === "assistant").map((m) => partsText(m.parts)).filter((t) => t.trim() !== "");
-  if (texts.length === 0) return { text: "nothing to copy — no assistant message with text yet", tone: "warn" };
-  const pick = texts[texts.length - n];
-  if (pick === undefined) return { text: `nothing to copy — only ${texts.length} assistant message${texts.length === 1 ? "" : "s"} with text (asked for number ${n} from the end)`, tone: "warn" };
-  const res = await copyToClipboard(pick, opts);
-  if (res.ok) return { text: `copied ${n === 1 ? "the last assistant message" : `assistant message ${n} from the end`} (${pick.length} chars) to the clipboard via ${res.tool}`, tone: "info" };
-  return { text: `clipboard unavailable — tried ${res.tried.join(", ") || "nothing"}${res.detail ? ` (${res.detail})` : ""}; the text stays in the transcript`, tone: "warn" };
-}
-
-/** /copy [n] — n defaults to 1 (the last); any other argument is a usage note. */
-export async function cmdCopy(ctx: ContextCmdCtx, arg: string): Promise<void> {
-  if (ctx.busy()) { ctx.renderer.addSystemNote(BUSY_WARN, "warn"); return; }
-  const n = arg === "" ? 1 : /^[1-9]\d*$/.test(arg) ? Number(arg) : NaN;
-  if (Number.isNaN(n)) { ctx.renderer.addSystemNote("usage: /copy [n] — copies the last assistant message; n counts back from the latest (2 = the one before)", "warn"); return; }
-  const line = await copyAssistantMessage(ctx.store().messages(), n, ctx.clipboard ?? {});
-  ctx.renderer.addSystemNote(line.text, line.tone);
-}
-
-// ---------- dispatch ----------
-
-/** handleSlash hook for the four names (CONTEXT_COMMANDS); fire-and-forget like the other async slash commands. */
-export async function runContextCommand(ctx: ContextCmdCtx, cmd: string, arg: string): Promise<void> {
-  switch (cmd) {
-    case "compact": return cmdCompact(ctx, arg);
-    case "clear": return cmdClear(ctx);
-    case "init": return cmdInit(ctx);
-    case "copy": return cmdCopy(ctx, arg);
-    default: return;
-  }
-}