rovecode 0.3.3 → 0.4.0-beta.2

package/src/memory/scope.ts

@@ -1,182 +0,0 @@
-/** Memory scoping: WHERE a remembered fact lands, and the one-time move of the old per-session store.
- *
- *  Until 2026-09-07 both blocks were built over ONE directory, `<cwd>/.rovecode/sessions/<id>/memory`, which got
- *  two things wrong at once. Every fact died with the session id — a new session is a new uuid directory and
- *  nothing carried anything forward — and the USER block, whose entire purpose is preferences that follow the
- *  person from project to project, was written INSIDE the repository. A private preference in someone's checkout
- *  is the wrong file in the wrong place; that is what this module fixes.
- *
- *    MEMORY → `<cwd>/.rovecode/memory/MEMORY.md`  — this project, shared by every session in it (two sessions in
- *             the same checkout see the same facts; the ledger's optimistic concurrency serialises their edits)
- *    USER   → `<ROVECODE_HOME | ~/.rovecode>/memory/USER.md` — the person, across every project, never in a repo
- *
- *  A note with NO scope goes to MEMORY: an unscoped project fact landing in the user file could carry something
- *  private out of one project and into every other, while the reverse is only a nuisance. `#<text>` and
- *  `/memory <text>` append to MEMORY; `/memory --user <text>` is the only composer path to USER; the memory_edit
- *  tool has no default at all (`block` is a required enum).
- *
- *  LEGACY (the pre-2026-09-07 layout): `<sessions>/<id>/memory/`. Processed ONCE per legacy store — when a block's
- *  scoped target has never been used (neither its file nor its `.versions.jsonl` sidecar exists) the legacy file
- *  and sidecar are copied forward, history intact, BEFORE the BlockStore takes its boot snapshot, so a resumed
- *  session keeps its memory in the prompt. A target already in use is never overwritten; the block is reported as
- *  skipped. NOTHING OF THE USER'S IS EVER DELETED: the legacy files stay exactly where they are, and a small
- *  marker beside them records the outcome so the copy and its note happen once and are said once.
- *
- *  TRUST: `<cwd>/.rovecode/memory/MEMORY.md` is repo data — committable, and it goes into the system prompt — so a
- *  cloned repository could put text of its choosing in front of the model. The gate is core/trust.ts, the same
- *  digest store as project mcp.json and hooks.ts, with one adaptation that matters: a plain digest gate over a file
- *  that changes on every note would re-ask constantly and be switched off within a day, so the store SELF-TRUSTS
- *  the file after a write it performed itself (the `mcp add --project` precedent — what we wrote, we vouch for).
- *  Narrowly: only a write that actually landed through this store, never "the file looks close enough". A MEMORY.md
- *  that arrived from a clone or a hand-edit is READ but WITHHELD from the prompt with one boot note, and writes to
- *  it are REFUSED (memory/blocks.ts capCheck) — appending our own note to a stranger's file would launder its
- *  content into the next prompt. `rovecode trust` accepts it, exactly as for the other project files. The USER
- *  block lives in the user's own home and is never gated. */
-
-import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { isTrustedFile, trustFile, untrustedFileNote } from "../core/trust.ts";
-import { rovecodeHome } from "../providers/auth.ts";
-import { LEDGER_SUFFIX } from "../skills/versioned.ts";
-import { BLOCK_FILES, BlockStore, cutAtCap, defaultCaps, type BlockCaps, type BlockDirs, type BlockName, type BlockStoreOptions } from "./blocks.ts";
-
-/** the memory sub-directory of a scope's state dir */
-export const MEMORY_DIR = "memory";
-/** written beside a legacy store's files once it has been processed (copied or skipped) — the "once" of the header */
-export const LEGACY_MARKER = ".copied-forward.json";
-/** an over-cap legacy block is copied cut to this share of the cap, so the migrated store can still take a note */
-export const LEGACY_CUT_RATIO = 0.9;
-const BLOCKS: readonly BlockName[] = ["memory", "user"];
-
-/** `<cwd>/.rovecode/memory` — the MEMORY block's home for this project */
-export function projectMemoryDir(cwd: string): string { return join(cwd, ".rovecode", MEMORY_DIR); }
-/** `<ROVECODE_HOME | ~/.rovecode>/memory` — the USER block's home, the same home providers.json and plugins.json use */
-export function userMemoryDir(home: string = rovecodeHome()): string { return join(home, MEMORY_DIR); }
-/** the pre-2026-09-07 per-session store: `<sessions>/<id>/memory` */
-export function legacySessionMemoryDir(sessionsDir: string, sessionId: string): string { return join(sessionsDir, sessionId, MEMORY_DIR); }
-/** the scoped directories a runtime's BlockStore is built over */
-export function scopedBlockDirs(cwd: string, home?: string): BlockDirs {
-  return { memory: projectMemoryDir(cwd), user: userMemoryDir(home) };
-}
-
-/** true when `block` has never been written under `dir`: neither its file nor its ledger sidecar exists */
-export function blockUnused(dir: string, block: BlockName): boolean {
-  const file = join(dir, BLOCK_FILES[block]);
-  return !existsSync(file) && !existsSync(file + LEDGER_SUFFIX);
-}
-
-export interface MigrationResult {
-  /** the legacy store that was read */
-  from: string;
-  /** blocks copied forward (file + sidecar when present) */
-  copied: BlockName[];
-  /** blocks the legacy store had but whose scoped target is already in use — left alone */
-  skipped: BlockName[];
-  /** copied blocks whose legacy file was over the block cap: the copy is cut at the cap (present only when non-empty) */
-  cut?: BlockName[];
-}
-
-/** Copy a legacy `<session>/memory` store forward into the scoped dirs, block by block, only where the target is
- *  unused (header rules), then leave the marker. The legacy files are never modified or removed. null when the
- *  legacy dir holds no block file (nothing to migrate) or was processed before — the caller stays silent in both. */
-export function migrateLegacyMemory(legacyDir: string, dirs: BlockDirs, caps: BlockCaps = defaultCaps): MigrationResult | null {
-  if (existsSync(join(legacyDir, LEGACY_MARKER))) return null;
-  const result: MigrationResult = { from: legacyDir, copied: [], skipped: [] };
-  const cut: BlockName[] = [];
-  for (const block of BLOCKS) {
-    const src = join(legacyDir, BLOCK_FILES[block]);
-    if (!existsSync(src)) continue;
-    if (!blockUnused(dirs[block], block)) { result.skipped.push(block); continue; }
-    mkdirSync(dirs[block], { recursive: true });
-    const text = readFileSync(src, "utf8");
-    // over the cap: the copy is cut to LEGACY_CUT_RATIO of the cap (line boundary) so the store has room for notes
-    // — the legacy file keeps the whole text, because nothing of the user's is deleted by a migration
-    if (text.length > caps[block]) { writeFileSync(join(dirs[block], BLOCK_FILES[block]), cutAtCap(text, Math.floor(caps[block] * LEGACY_CUT_RATIO))); cut.push(block); }
-    else copyFileSync(src, join(dirs[block], BLOCK_FILES[block]));
-    if (existsSync(src + LEDGER_SUFFIX)) copyFileSync(src + LEDGER_SUFFIX, join(dirs[block], BLOCK_FILES[block] + LEDGER_SUFFIX));
-    result.copied.push(block);
-  }
-  if (result.copied.length + result.skipped.length === 0) return null;
-  if (cut.length > 0) result.cut = cut;
-  writeFileSync(join(legacyDir, LEGACY_MARKER), JSON.stringify({ at: new Date().toISOString(), copied: result.copied, skipped: result.skipped, cut }) + "\n");
-  return result;
-}
-
-/** The transcript note for a processed legacy store; null when there was nothing to process (or it was processed
- *  before). A pure skip — every block's target already in use — says so once instead of dropping silently. */
-export function migrationNote(r: MigrationResult | null, dirs: BlockDirs): string | null {
-  if (!r) return null;
-  const files = (blocks: readonly BlockName[]): string => blocks.map((b) => BLOCK_FILES[b]).join(", ");
-  if (r.copied.length === 0) {
-    return `memory: legacy per-session store ${r.from} not copied — ${files(r.skipped)} already ${r.skipped.length === 1 ? "has" : "have"} content in the scoped store (/memory shows it; the legacy files are still there if you need the text — this note shows once)`;
-  }
-  const copied = r.copied.map((b) => `${BLOCK_FILES[b]} → ${dirs[b]}`).join(", ");
-  const cut = r.cut && r.cut.length > 0 ? ` (${files(r.cut)} cut to fit the block cap — the legacy file keeps the whole text)` : "";
-  const skipped = r.skipped.length > 0 ? `; ${files(r.skipped)} not copied — the scoped store already has content` : "";
-  return `memory: copied ${copied} forward from the legacy per-session store ${r.from} (left in place; in the prompt from this run on)${cut}${skipped}`;
-}
-
-/** The copy-forward is OUR OWN write of the user's own file, so the file it produces is trusted at the moment it is
- *  written — exactly like a note we append. Without this, migrating a legacy store would hand the person a MEMORY.md
- *  that this machine then refused to put in the prompt, which is the opposite of what the migration is for. */
-function trustMigrated(r: MigrationResult | null, dirs: BlockDirs, home: string): void {
-  if (r?.copied.includes("memory")) trustFile(home, join(dirs.memory, BLOCK_FILES.memory));
-}
-
-/** The store options for `cwd`: withhold a project MEMORY.md this machine has not approved, and keep the digest
- *  current for the writes we perform ourselves (header — the narrow self-trust). A MEMORY.md that does not exist
- *  yet is not withheld: the first note creates it, and creating it is our own write. */
-export function scopedStoreOptions(cwd: string, home: string = rovecodeHome()): BlockStoreOptions {
-  const file = join(projectMemoryDir(cwd), BLOCK_FILES.memory);
-  const withhold: BlockName[] = existsSync(file) && !isTrustedFile(home, file) ? ["memory"] : [];
-  return {
-    ...(withhold.length > 0 ? { withhold } : {}),
-    // only the project block needs a digest: USER.md lives in the user's own home and is never gated
-    onCommit: (block, path) => { if (block === "memory") trustFile(home, path); },
-  };
-}
-
-/** The boot notes about the store itself: a withheld project block, a block over its cap. */
-export function storeNotes(blocks: BlockStore, cwd: string): string[] {
-  const notes: string[] = [];
-  void cwd;
-  for (const b of BLOCKS) {
-    if (blocks.isWithheld(b)) {
-      notes.push(untrustedFileNote(blocks.path(b), "it is not in the prompt and cannot be written to (it came with this repository, and a repo file would be choosing what the model reads); /memory still shows it"));
-    }
-    const over = blocks.overCap(b);
-    if (over) notes.push(`memory: ${blocks.path(b)} holds ${over.readCut ? "more than the read cap" : `${over.chars} chars`} — over the ${over.cap}-char cap; the prompt shows the first ${over.cap} and memory_edit is refused until the file is trimmed`);
-  }
-  return notes;
-}
-
-export interface ScopedMemory {
-  blocks: BlockStore;
-  /** the boot notes for the surface's transcript (the one-time copy-forward, a withheld or over-cap block), else null */
-  note: string | null;
-}
-
-/** Build the runtime's BlockStore over the scoped dirs AFTER the one-time legacy copy for `sessionId`, so the boot
- *  snapshot already carries a resumed session's migrated memory. */
-export function openScopedMemory(d: { cwd: string; sessionsDir: string; sessionId: string; home?: string }): ScopedMemory {
-  const home = d.home ?? rovecodeHome();
-  const dirs = scopedBlockDirs(d.cwd, home);
-  const migrated = migrateLegacyMemory(legacySessionMemoryDir(d.sessionsDir, d.sessionId), dirs);
-  trustMigrated(migrated, dirs, home); // before the store reads: what we just copied is ours, not the repo's
-  const migration = migrationNote(migrated, dirs);
-  const blocks = new BlockStore(dirs, defaultCaps, scopedStoreOptions(d.cwd, home));
-  const notes = [...(migration ? [migration] : []), ...storeNotes(blocks, d.cwd)];
-  return { blocks, note: notes.length > 0 ? notes.join("\n") : null };
-}
-
-/** TUI session switch (tui/app.ts): memory is project-scoped, so the store STAYS — unless the switched-to session
- *  carries a legacy store that copies forward, in which case a FRESH BlockStore is handed back so the migrated text
- *  is in the prompt now rather than only next run. A pure-skip note returns without a new store. */
-export function adoptLegacyMemory(cwd: string, sessionsDir: string, sessionId: string, home: string = rovecodeHome()): { blocks?: BlockStore; note: string | null } {
-  const dirs = scopedBlockDirs(cwd, home);
-  const r = migrateLegacyMemory(legacySessionMemoryDir(sessionsDir, sessionId), dirs);
-  trustMigrated(r, dirs, home);
-  const note = migrationNote(r, dirs);
-  if (r && r.copied.length > 0) return { blocks: new BlockStore(dirs, defaultCaps, scopedStoreOptions(cwd, home)), note };
-  return { note };
-}

package/src/memory/store.ts

@@ -1,105 +0,0 @@
-/** Bounded memory (ADR-008): typed records with budgets, decay, dedup, provenance.
- *  Memory edits flow through the tool pipeline so policy applies. */
-
-import { createHash } from "node:crypto";
-import { mkdirSync, existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-export type MemoryKind = "task" | "episodic" | "semantic";
-
-export interface MemoryRecord {
-  id: string;
-  kind: MemoryKind;
-  text: string;
-  createdAt: number;
-  lastAccessedAt: number;
-  accessCount: number;
-  /** where this came from: session id, tool call, user */
-  provenance: string;
-  tags: string[];
-}
-
-export interface MemoryLimits {
-  maxRecords: number;
-  maxCharsPerRecord: number;
-  /** records unused for this many ms get decayed (deleted at the tail) */
-  decayAfterMs: number;
-}
-
-export const defaultLimits: MemoryLimits = { maxRecords: 500, maxCharsPerRecord: 2_000, decayAfterMs: 1000 * 60 * 60 * 24 * 14 };
-
-function dedupKey(r: MemoryRecord): string {
-  return createHash("sha256").update(r.kind + "|" + r.text.replace(/\s+/g, " ").trim().toLowerCase()).digest("hex").slice(0, 16);
-}
-
-export class MemoryStore {
-  private records: MemoryRecord[] = [];
-  private seen = new Set<string>();
-
-  constructor(private readonly dir: string, private readonly limits: MemoryLimits = defaultLimits) {
-    mkdirSync(dir, { recursive: true });
-    const p = join(dir, "memory.json");
-    if (existsSync(p)) {
-      this.records = JSON.parse(readFileSync(p, "utf8")) as MemoryRecord[];
-      this.seen = new Set(this.records.map(dedupKey));
-    }
-  }
-
-  private persist(): void {
-    writeFileSync(join(this.dir, "memory.json"), JSON.stringify(this.records, null, 2));
-  }
-
-  add(kind: MemoryKind, text: string, provenance: string, tags: string[] = []): { ok: boolean; reason?: string } {
-    const trimmed = text.trim();
-    if (trimmed.length === 0) return { ok: false, reason: "empty record" };
-    if (trimmed.length > this.limits.maxCharsPerRecord) return { ok: false, reason: `record exceeds ${this.limits.maxCharsPerRecord} chars` };
-    const rec: MemoryRecord = {
-      id: createHash("sha256").update(kind + trimmed + Date.now()).digest("hex").slice(0, 12),
-      kind, text: trimmed, createdAt: Date.now(), lastAccessedAt: Date.now(), accessCount: 0, provenance, tags,
-    };
-    const key = dedupKey(rec);
-    if (this.seen.has(key)) return { ok: false, reason: "duplicate" };
-    this.seen.add(key);
-    this.records.push(rec);
-    this.enforceLimits();
-    this.persist();
-    return { ok: true };
-  }
-
-  private enforceLimits(): void {
-    const now = Date.now();
-    // decay: drop stale records beyond the cap, oldest-accessed first
-    this.records = this.records.filter((r) => now - r.lastAccessedAt < this.limits.decayAfterMs);
-    if (this.records.length > this.limits.maxRecords) {
-      this.records.sort((a, b) => a.lastAccessedAt - b.lastAccessedAt);
-      this.records = this.records.slice(this.records.length - this.limits.maxRecords);
-    }
-  }
-
-  /** Recency × access × simple lexical relevance. */
-  retrieve(query: string, limit = 5, kind?: MemoryKind): MemoryRecord[] {
-    const terms = query.toLowerCase().split(/\W+/).filter((t) => t.length > 2);
-    const now = Date.now();
-    const scored = this.records
-      .filter((r) => !kind || r.kind === kind)
-      .map((r) => {
-        const text = r.text.toLowerCase();
-        const hits = terms.reduce((n, t) => n + (text.includes(t) ? 1 : 0), 0);
-        const recency = 1 / (1 + (now - r.lastAccessedAt) / 3_600_000);
-        const score = hits * 2 + Math.log1p(r.accessCount) + recency;
-        return { r, score };
-      })
-      .filter((s) => s.score > 0.3)
-      .sort((a, b) => b.score - a.score)
-      .slice(0, limit);
-    for (const s of scored) { s.r.accessCount++; s.r.lastAccessedAt = now; }
-    this.persist();
-    return scored.map((s) => s.r);
-  }
-
-  stats(): { count: number; byKind: Record<string, number> } {
-    const byKind: Record<string, number> = {};
-    for (const r of this.records) byKind[r.kind] = (byKind[r.kind] ?? 0) + 1;
-    return { count: this.records.length, byKind };
-  }
-}

package/src/memory/tools.ts

@@ -1,99 +0,0 @@
-/** memory_edit tool (hermes memory_tool pattern): add/replace/remove on the bounded
- *  markdown blocks. Failures (bad match, cap overflow, bad args) count toward a
- *  per-turn cap of 3; at the cap the tool returns a terminal skip so the agent
- *  stops burning turns on memory writes (hermes #42405). */
-
-import type { Tool, ToolContext, ToolOutput } from "../core/types.ts";
-import { BlockStore, type BlockName } from "./blocks.ts";
-
-const MAX_FAILURES_PER_TURN = 3;
-const CAP_MESSAGE = "save skipped: memory at capacity or repeatedly failing";
-
-let turnFailureCount = 0;
-
-export function resetTurnFailureCount(): void { turnFailureCount = 0; }
-
-export function turnFailures(): number { return turnFailureCount; }
-
-export interface MemoryEditArgs {
-  op: "add" | "replace" | "remove";
-  block: BlockName;
-  text?: string;
-  oldText?: string;
-  newText?: string;
-}
-
-/** Build the tool bound to a store instance (the store is per-session). */
-export function memoryEditTool(store: BlockStore): Tool {
-  return {
-    schema: {
-      name: "memory_edit",
-      description:
-        `Edit long-term memory blocks. Ops: add(text) appends a line; replace(oldText,newText) requires oldText to match exactly once; remove(oldText) same. ` +
-        `block: "memory" (session/task facts, cap ${store.cap("memory")} chars) or "user" (stable user preferences, cap ${store.cap("user")} chars). ` +
-        `Failures count toward a per-turn budget of ${MAX_FAILURES_PER_TURN}; after that saves are skipped until next turn.`,
-      args: {
-        type: "object",
-        properties: {
-          op: { type: "string", enum: ["add", "replace", "remove"] },
-          block: { type: "string", enum: ["memory", "user"] },
-          text: { type: "string", description: "text to add (op=add)" },
-          oldText: { type: "string", description: "exact text to replace/remove; must match exactly once" },
-          newText: { type: "string", description: "replacement text (op=replace; empty removes)" },
-        },
-        required: ["op", "block"],
-      },
-    },
-    kind: "memory",
-    sequential: true,
-    async execute(args: unknown, _ctx: ToolContext): Promise<ToolOutput> {
-      const a = args as MemoryEditArgs;
-      if (turnFailureCount >= MAX_FAILURES_PER_TURN) {
-        return { ok: false, output: CAP_MESSAGE };
-      }
-      const block = a.block === "user" ? "user" : a.block === "memory" ? "memory" : undefined;
-      if (!block) return fail(`invalid block: ${String(a.block)}`);
-
-      let res;
-      switch (a.op) {
-        case "add":
-          if (typeof a.text !== "string" || a.text.trim().length === 0) {
-            return fail("op=add requires non-empty text");
-          }
-          res = store.add(block, a.text);
-          break;
-        case "replace":
-          if (typeof a.oldText !== "string" || a.oldText.length === 0) {
-            return fail("op=replace requires oldText");
-          }
-          if (typeof a.newText !== "string") return fail("op=replace requires newText (use \"\" to delete)");
-          res = store.replace(block, a.oldText, a.newText);
-          break;
-        case "remove":
-          if (typeof a.oldText !== "string" || a.oldText.length === 0) {
-            return fail("op=remove requires oldText");
-          }
-          res = store.remove(block, a.oldText);
-          break;
-        default:
-          return fail(`invalid op: ${String(a.op)}`);
-      }
-
-      if (!res.ok) {
-        return fail(res.reason ?? "edit failed", res.current, res.limit);
-      }
-      return {
-        ok: true,
-        output: `${a.op} ok: ${block} block now ${res.current}/${res.limit} chars`,
-        data: { block, chars: res.current, limit: res.limit },
-      };
-    },
-  };
-}
-
-/** Every failure path routes through here so the per-turn counter stays honest. */
-function fail(reason: string, current?: number, limit?: number): ToolOutput {
-  turnFailureCount++;
-  const detail = current !== undefined && limit !== undefined ? ` (current ${current}/${limit} chars)` : "";
-  return { ok: false, output: `memory_edit failed: ${reason}${detail}; failures this turn: ${turnFailureCount}/${MAX_FAILURES_PER_TURN}` };
-}

package/src/plugins/cli.ts

@@ -1,119 +0,0 @@
-/** `rovecode plugin …` — list · add · remove · enable · disable · trust · untrust · show. A pure
- *  command function over injected cwd/home/output so tests drive it without a process; cli/main.ts
- *  wires `case "plugin"` to it with process.cwd() and rovecodeHome(). Nothing here imports plugin
- *  code: `show` and `list` read manifests and folder digests only, so an untrusted project plugin can
- *  be inspected before it is ever run — that inspection is what `trust` asks the human to do. */
-
-import { relative } from "node:path";
-import { rovecodeHome } from "../providers/auth.ts";
-import { discoverPlugins, type DiscoveredPlugin, type PluginScope } from "./discover.ts";
-import { addPlugin, removePlugin, scopeRoot, setPluginEnabled, trustPlugin, untrustPlugin, type Spawn } from "./install.ts";
-import { contributions } from "./manifest.ts";
-import { pluginFiles, statePath } from "./state.ts";
-
-export interface PluginCliDeps {
-  cwd?: string;
-  home?: string;
-  out?: (line: string) => void;
-  err?: (line: string) => void;
-  spawn?: Spawn;
-}
-
-export const PLUGIN_USAGE = [
-  "usage: rovecode plugin <command>",
-  "  list                       every plugin in ~/.rovecode/plugins and .rovecode/plugins, with its status",
-  "  add <folder|git-url> [--project] [--force]",
-  "                             copy (or shallow-clone) a plugin into the user scope, or this repo's .rovecode/plugins",
-  "  remove <name> [--project]  delete the installed copy",
-  "  enable <name> · disable <name>",
-  "                             switch a plugin off/on in every scope (~/.rovecode/plugins.json)",
-  "  trust <name>               approve a PROJECT plugin's current files on this machine — until they change",
-  "  untrust <name>             withdraw that approval",
-  "  show <name>                manifest, files and what it contributes, without running any of it",
-  "status: active · disabled · untrusted (project plugin not yet approved here) · broken (see problems)",
-].join("\n");
-
-const flag = (args: string[], name: string): boolean => args.includes(name);
-const words = (args: string[]): string[] => args.filter((a) => !a.startsWith("--"));
-
-export async function cmdPlugin(args: string[], deps: PluginCliDeps = {}): Promise<number> {
-  const cwd = deps.cwd ?? process.cwd(), home = deps.home ?? rovecodeHome();
-  const out = deps.out ?? ((l) => console.log(l)), err = deps.err ?? ((l) => console.error(l));
-  const [sub = "list", ...rest] = args;
-  const scope: PluginScope = flag(rest, "--project") ? "project" : "user";
-  const name = words(rest)[0];
-  switch (sub) {
-    case "list": case "ls": {
-      const { plugins, warnings } = discoverPlugins(cwd, { home });
-      if (plugins.length === 0) { out(`no plugins. add one: rovecode plugin add <folder|git-url>   (user: ${scopeRoot("user", cwd, home)}, project: ${relative(cwd, scopeRoot("project", cwd, home)) || "."})`); }
-      for (const p of plugins) out(row(p));
-      for (const w of warnings) err(`warning: ${w}`);
-      return 0;
-    }
-    case "add": {
-      const src = name;
-      if (!src) { err(PLUGIN_USAGE); return 2; }
-      const r = await addPlugin(src, { cwd, home, scope, force: flag(rest, "--force"), ...(deps.spawn ? { spawn: deps.spawn } : {}) });
-      if (!r.ok) { err(`plugin add: ${r.error}`); return 1; }
-      out(`added ${r.name}@${r.manifest.version} (${r.scope}) → ${r.dir}`);
-      for (const c of contributions(r.manifest)) out(`  ${c}`);
-      if (r.scope === "project") out(`  trusted on this machine (recorded in ${statePath(home)}); a change to its files will ask again`);
-      out("restart rovecode to load it — plugins are read once per process, like hooks");
-      return 0;
-    }
-    case "remove": case "rm": {
-      if (!name) { err(PLUGIN_USAGE); return 2; }
-      const r = removePlugin(name, { cwd, home, scope });
-      if (!r.ok) { err(`plugin remove: ${r.error}`); return 1; }
-      out(`removed ${name} (${scope}) from ${r.dir}`);
-      return 0;
-    }
-    case "enable": case "disable": {
-      if (!name) { err(PLUGIN_USAGE); return 2; }
-      const known = discoverPlugins(cwd, { home }).plugins.some((p) => p.name === name);
-      if (!known) err(`warning: no installed plugin named "${name}" — the setting is recorded anyway`);
-      const path = setPluginEnabled(name, sub === "enable", home);
-      out(`${name} ${sub}d (${path})`);
-      return 0;
-    }
-    case "trust": {
-      if (!name) { err(PLUGIN_USAGE); return 2; }
-      const p = discoverPlugins(cwd, { home }).plugins.find((x) => x.name === name && x.scope === "project");
-      if (!p) { err(`plugin trust: no project plugin "${name}" under ${scopeRoot("project", cwd, home)}`); return 1; }
-      if (p.manifest === null) { err(`plugin trust: "${name}" is broken — fix it first:`); for (const w of p.problems) err(`  ${w}`); return 1; }
-      const r = trustPlugin(name, { cwd, home });
-      if (!r.ok) { err(`plugin trust: ${r.error}`); return 1; }
-      out(`trusted ${name}@${p.manifest.version} — ${pluginFiles(p.dir).length} files, digest ${r.digest.slice(0, 12)}…`);
-      for (const c of contributions(p.manifest)) out(`  ${c}`);
-      out("it loads on the next start; `rovecode plugin show " + name + "` lists every file it brings");
-      return 0;
-    }
-    case "untrust": {
-      if (!name) { err(PLUGIN_USAGE); return 2; }
-      out(untrustPlugin(name, { cwd, home }) ? `untrusted ${name}` : `${name} was not trusted`);
-      return 0;
-    }
-    case "show": case "info": {
-      if (!name) { err(PLUGIN_USAGE); return 2; }
-      const p = discoverPlugins(cwd, { home }).plugins.find((x) => x.name === name);
-      if (!p) { err(`plugin show: no plugin "${name}"`); return 1; }
-      out(row(p));
-      out(`  folder:  ${p.dir}`);
-      if (p.digest) out(`  digest:  ${p.digest}`);
-      if (p.manifest) for (const c of contributions(p.manifest)) out(`  ${c}`);
-      for (const f of pluginFiles(p.dir)) out(`  - ${f}`);
-      for (const w of p.problems) out(`  ! ${w}`);
-      if (p.status === "untrusted") out(`  run \`rovecode plugin trust ${p.name}\` after reading the files above`);
-      return 0;
-    }
-    case "help": case "--help": case "-h": out(PLUGIN_USAGE); return 0;
-    default: err(`unknown plugin command "${sub}"\n${PLUGIN_USAGE}`); return 2;
-  }
-}
-
-/** one list row: `name@version  scope  status  — description` */
-export function row(p: DiscoveredPlugin): string {
-  const v = p.manifest ? `@${p.manifest.version}` : "";
-  const desc = p.manifest?.description ? ` — ${p.manifest.description}` : "";
-  return `${(p.name + v).padEnd(28)} ${p.scope.padEnd(8)} ${p.status.padEnd(9)}${desc}`.trimEnd();
-}

package/src/plugins/discover.ts

@@ -1,108 +0,0 @@
-/** Plugins: discovery. Two roots — `~/.rovecode/plugins/<name>/` (user) and `<cwd>/.rovecode/plugins/
- *  <name>/` (project) — each subfolder with a `plugin.json` is a plugin. Sync and filesystem-only:
- *  nothing is imported here, so `rovecode plugin list` can show a hostile plugin without running it.
- *
- *  Status decides what load.ts may do with a plugin:
- *    active     — will be imported and wired
- *    disabled   — the human switched it off (plugins.json)
- *    untrusted  — a PROJECT plugin whose folder digest the human has not approved on this machine;
- *                 listed, never imported (state.ts explains why the record lives in the user home)
- *    broken     — no usable manifest; listed with its reasons so the author can fix it
- *  Same name in both roots: the project copy shadows the user copy (the commands loader's rule) and
- *  says so. ROVECODE_NO_PLUGINS=1 skips discovery the way ROVECODE_NO_HOOKS=1 skips hooks. */
-
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { rovecodeHome } from "../providers/auth.ts";
-import { normalizeEntry, type McpServerConfig } from "../mcp/config.ts";
-import { MANIFEST_FILE, parseManifest, type PluginManifest } from "./manifest.ts";
-import { isDir, isTrusted, loadState, pluginDigest, type PluginState } from "./state.ts";
-
-export type PluginScope = "user" | "project";
-export type PluginStatus = "active" | "disabled" | "untrusted" | "broken";
-
-export interface DiscoveredPlugin {
-  name: string;
-  /** absolute plugin folder */
-  dir: string;
-  scope: PluginScope;
-  manifest: PluginManifest | null;
-  status: PluginStatus;
-  /** folder digest (state.ts); null when the folder could not be walked */
-  digest: string | null;
-  /** why it is broken / what the manifest dropped — the author's fix list */
-  problems: string[];
-  /** the declarative halves, resolved here because they need no code run: the runtime wires them
-   *  synchronously at construction (the commands and skills loaders, the MCP config) and only the
-   *  entry module waits for load.ts. Filled for every plugin with a manifest; the runtime reads
-   *  them for ACTIVE ones only. */
-  commandsDir: string | null;
-  skillsDir: string | null;
-  mcp: McpServerConfig[];
-}
-
-export interface DiscoverOptions { home?: string; state?: PluginState }
-export interface Discovered { plugins: DiscoveredPlugin[]; warnings: string[] }
-
-/** the two roots, project last so it shadows; one root when cwd IS the home (commands.ts idiom) */
-export function pluginRoots(cwd: string, home: string): [PluginScope, string][] {
-  const user = join(home, "plugins"), project = join(cwd, ".rovecode", "plugins");
-  return resolve(user) === resolve(project) ? [["project", project]] : [["user", user], ["project", project]];
-}
-
-export function discoverPlugins(cwd: string, opts: DiscoverOptions = {}): Discovered {
-  const out: Discovered = { plugins: [], warnings: [] };
-  if (process.env.ROVECODE_NO_PLUGINS === "1") return out;
-  const home = opts.home ?? rovecodeHome();
-  const state = opts.state ?? loadState(home);
-  const byName = new Map<string, DiscoveredPlugin>();
-  for (const [scope, root] of pluginRoots(cwd, home)) {
-    if (!isDir(root)) continue;
-    let names: string[];
-    try { names = readdirSync(root).sort(); } catch (e) { out.warnings.push(`${root}: cannot list — ${(e as Error).message}`); continue; }
-    for (const folder of names) {
-      const dir = join(root, folder);
-      if (!isDir(dir) || !existsSync(join(dir, MANIFEST_FILE))) continue; // a stray file or a folder without a manifest is not a plugin
-      const p = readPlugin(dir, folder, scope, state);
-      const prev = byName.get(p.name);
-      if (prev) out.warnings.push(`${dir}: plugin "${p.name}" shadows ${prev.dir} (project over user)`);
-      byName.set(p.name, p);
-      for (const w of p.problems) out.warnings.push(w);
-    }
-  }
-  out.plugins = [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
-  return out;
-}
-
-/** one folder → its DiscoveredPlugin: manifest, status, digest, and the declarative halves resolved
- *  (a named commands/skills dir must exist; MCP entries go through the same normalizer as mcp.json) */
-export function readPlugin(dir: string, folder: string, scope: PluginScope, state: PluginState): DiscoveredPlugin {
-  const file = join(dir, MANIFEST_FILE);
-  const problems: string[] = [];
-  let manifest: PluginManifest | null = null;
-  try { manifest = parseManifest(readFileSync(file, "utf8"), file, problems); }
-  catch (e) { problems.push(`${file}: cannot read — ${(e as Error).message}`); }
-  let digest: string | null = null;
-  try { digest = pluginDigest(dir); } catch { digest = null; }
-  const name = manifest?.name ?? folder;
-  if (manifest && manifest.name !== folder) problems.push(`${file}: name "${manifest.name}" differs from its folder "${folder}" — the manifest name is the plugin's identity`);
-  let status: PluginStatus;
-  if (manifest === null) status = "broken";
-  else if (state.disabled.includes(name)) status = "disabled";
-  else if (scope === "project" && (digest === null || !isTrusted(state, dir, digest))) status = "untrusted";
-  else status = "active";
-  const tag = `plugin ${name}`;
-  const commandsDir = manifest ? dirOrProblem(dir, manifest.commands, `${tag}: commands`, problems) : null;
-  const skillsDir = manifest ? dirOrProblem(dir, manifest.skills, `${tag}: skills`, problems) : null;
-  const mcp: McpServerConfig[] = [];
-  if (manifest?.mcp) for (const [n, raw] of Object.entries(manifest.mcp)) { const c = normalizeEntry(n, raw, file, problems); if (c) mcp.push(c); }
-  return { name, dir, scope, manifest, status, digest, problems, commandsDir, skillsDir, mcp };
-}
-
-function dirOrProblem(base: string, rel: string | undefined, what: string, problems: string[]): string | null {
-  if (!rel) return null;
-  const p = join(base, rel);
-  try { if (statSync(p).isDirectory()) return p; } catch { /* below */ }
-  problems.push(`${what} directory "${rel}" does not exist — ignored`);
-  return null;
-}