@henols/vice-mcp 0.2.1 → 0.2.2

package/r2000-project.ts

@@ -1,190 +0,0 @@
-#!/usr/bin/env node
-// r2000-project.ts -- the ONE authoritative place in this repo that builds a
-// `.regen2000proj` file. This module performs no filesystem or network I/O:
-// callers read the source bytes and write the returned JSON text themselves;
-// this module only transforms bytes into the wire shape regenerator2000
-// loads. Nothing else in this repo may hand-build a project file -- if a
-// future caller needs a `.regen2000proj`, it imports `synthesizeProject`
-// from here rather than re-deriving the shape.
-//
-// WHY THIS EXISTS (D-01): Phase 9 already proved a working bootstrap route --
-// drive the TUI's own Save-As flow over a synthetic pty and a scripted
-// keystroke sequence. That route works, but it costs `tmux` as a declared
-// prerequisite this project does not otherwise need, AND it still requires a
-// post-save JSON edit to force `settings.use_illegal_opcodes` (the TUI's own
-// Save-As does not expose that setting). Synthesising the project file
-// directly in Node removes all four costs at once: no pty, no modal TUI, no
-// keystroke encoding, no terminal-size assumption, and no post-edit -- the
-// forced setting is written correctly the first time, by construction.
-//
-// WHAT NOT TO DO (two concrete past mistakes, both from Phase 9's own
-// evidence and CONTEXT.md's D-01/D-04):
-//   1. Do NOT write `raw_data_base64` as a plain (uncompressed) base64
-//      payload. regenerator2000 loads the project file expecting the value
-//      to be gzip-then-base64 encoded; an uncompressed payload was tried
-//      during Phase 9's probe and failed to load with
-//      `Error loading file: invalid gzip header`. Always run the bytes
-//      through `node:zlib`'s `gzipSync` first.
-//   2. Do NOT add a version pin or a `--version` allow-list anywhere near
-//      this module. D-04 explicitly rejects that shape: it blocks a user on
-//      a newer, perfectly working regenerator2000 build, and it still
-//      cannot detect a schema break that lands *within* a permitted
-//      version range. The compatibility strategy here is minimality --
-//      write only the fields `ProjectState` requires (no `#[serde(default)]`
-//      on the Rust side) plus the two deliberately-forced settings, and let
-//      every other field's own default carry the rest. The self-check that
-//      this is compatible is running a real regenerator2000 against the
-//      synthesised file once (see `r2000-project.test.ts`'s gated
-//      integration half), never a version table.
-//
-// Ground truth for the shape below was independently re-verified against the
-// installed regenerator2000-core-0.9.20 crate source (not merely paraphrased
-// from CONTEXT.md) -- see
-// `.planning/phases/10-adoption-boundaries-automated-bootstrap-and-the-removal/evidence/10-environment-recheck.txt`
-// for the file:line citations. Summary: `ProjectState`'s only three fields
-// without a `#[serde(default...)]` are `origin`, `raw_data` (serde-renamed
-// to `raw_data_base64`), and `blocks`; `origin` is `Addr`, a
-// `#[serde(transparent)]` newtype over `u16`, so it serialises as a plain
-// JSON number; and `System`, `DocumentSettings.system`'s type, is likewise
-// `#[serde(transparent)]` over `String`, so `settings.system` is a plain
-// JSON string, with the C64 constant equal to the exact literal
-// `Commodore 64`.
-//
-// `.vsf` is deliberately NOT an input to this module (D-03). Phase 9 found
-// `.vsf`'s machine-type field only reads correctly by coincidence --
-// `"C64SC"` matches none of regenerator2000's literal `System` arms and
-// falls through to that tool's own C64 default.
-//
-// FLOW-02 (D-11.1-01): this comment used to end by naming a specific
-// numbered phase as the eventual owner of closing that gap. That phase
-// shipped and never touched `.vsf` bootstrap, so the pointer was false the
-// moment that phase closed -- a phase number is a planning artifact, not a
-// durable remediation path. The idea is recorded as backlog, not assigned
-// to any phase: see
-// `.planning/todos/pending/2026-08-20-vsf-as-a-bootstrap-input.md`. (This is
-// a comment, not a user-facing string literal, so it is fixed here by hand
-// rather than by `docs-dangling-refs.test.ts`'s guard -- see that guard's
-// header for why it is deliberately scoped to string literals only.)
-
-import { gzipSync, gunzipSync } from "node:zlib";
-
-/** The exact literal regenerator2000's `System::C64` constant serialises as
- * (`types.rs`, `#[serde(transparent)] pub struct System(String)`). This is
- * the only system string this module ever writes unless a caller passes an
- * explicit override. */
-export const R2000_SYSTEM_C64 = "Commodore 64";
-
-export interface SynthesizeOptions {
-  /** Load address (`ProjectState.origin`). `Addr` is `#[serde(transparent)]`
-   * over `u16`, so this is written as a plain JSON number -- never a hex
-   * string, never an object. */
-  origin: number;
-  /** `DocumentSettings.system`, a plain JSON string. Defaults to
-   * `R2000_SYSTEM_C64`. This module never infers, detects or defaults the
-   * machine type from the payload bytes -- an explicit caller-supplied (or
-   * defaulted-to-C64) value is the whole point (D-05): it is what makes
-   * Phase 9's `.vsf` machine-type coincidence unreachable rather than
-   * merely mitigated, because there is no inference path here to get
-   * wrong. */
-  system?: string;
-}
-
-/**
- * Builds the JSON text of a `.regen2000proj` file from raw program bytes.
- *
- * The object written is EXACTLY four top-level keys: `origin`,
- * `raw_data_base64`, `blocks`, and `settings` (itself exactly two keys:
- * `use_illegal_opcodes` and `system`). Every other `ProjectState` member
- * (`version`, `labels`, `user_side_comments`, `cursor_address`, and so on)
- * carries its own `#[serde(default...)]` on the Rust side, so omitting them
- * is the forward-compatibility strategy (D-04), not an oversight -- a field
- * this module does not write is a field a future regenerator2000 release
- * can freely add, rename the default of, or restructure without ever
- * breaking this synthesiser. `version` is deliberately not written; it
- * defaults to the crate's current `PROJECT_FORMAT_VERSION` on load.
- *
- * `settings.use_illegal_opcodes` and `settings.system` are deliberately NOT
- * configurable to be turned off or omitted -- there is no flag, no option,
- * no code path that skips writing either:
- *   - `use_illegal_opcodes` defaults to `false` on the Rust side
- *     (`settings.rs`). Illegal-opcode-*correct* decoding is the entire
- *     reason this project's now-removed `toacme` had caveats in the first
- *     place; making this setting optional here would silently reintroduce
- *     that exact defect as a configuration choice rather than closing it
- *     (D-05).
- *   - An explicit `system` on every synthesised project (rather than
- *     omitting the key and letting the Rust-side default apply) is what
- *     makes Phase 9's `.vsf` machine-type limit unreachable through this
- *     route rather than merely mitigated -- there is no coincidental
- *     fallback to fall into, because a value is always supplied.
- */
-export function synthesizeProject(bytes: Uint8Array, opts: SynthesizeOptions): string {
-  const { origin, system = R2000_SYSTEM_C64 } = opts;
-
-  if (!Number.isInteger(origin) || origin < 0 || origin > 0xffff) {
-    throw new Error(
-      `synthesizeProject: origin ${origin} is out of range -- expected an integer 0..0xffff (0..65535)`,
-    );
-  }
-  if (bytes.length === 0) {
-    throw new Error("synthesizeProject: payload is empty -- a .regen2000proj must carry at least one byte");
-  }
-
-  const raw_data_base64 = gzipSync(bytes).toString("base64");
-
-  const project = {
-    origin,
-    raw_data_base64,
-    blocks: [] as unknown[],
-    settings: {
-      // Forced true, never configurable -- see the function doc comment
-      // above and D-05. Do not add a parameter that overrides this.
-      use_illegal_opcodes: true,
-      // Always written explicitly, never omitted -- see the function doc
-      // comment above and D-05/Phase 9's .vsf finding.
-      system,
-    },
-  };
-
-  return JSON.stringify(project);
-}
-
-/**
- * Parses a `.prg` file: a little-endian 2-byte load address followed by the
- * payload bytes. This is the C64 program-file convention every C64 loader
- * (and this project's own `acme-build` output) already follows.
- */
-export function parsePrg(bytes: Uint8Array): { origin: number; body: Uint8Array } {
-  if (bytes.length < 3) {
-    throw new Error(
-      `parsePrg: input is ${bytes.length} byte(s) -- a .prg needs at least 3 bytes (2-byte load address plus at least 1 payload byte)`,
-    );
-  }
-  const origin = bytes[0]! | (bytes[1]! << 8);
-  const body = bytes.subarray(2);
-  return { origin, body };
-}
-
-/**
- * Returns the load address (`0`) for a flat 64K RAM capture, and throws for
- * anything else. Flat 64K is in scope because `R2000-06` names it directly
- * and it is exactly the shape `c64-ram-capture` already produces (D-03) --
- * this function does not attempt to support any other flat-image size.
- */
-export function flatImageOrigin(bytes: Uint8Array): number {
-  if (bytes.length !== 65536) {
-    throw new Error(
-      `flatImageOrigin: input is ${bytes.length} byte(s) -- a flat 64K capture must be exactly 65536 bytes`,
-    );
-  }
-  return 0;
-}
-
-/**
- * The inverse of the `raw_data_base64` encoding step: base64-decode then
- * gunzip. Exported so tests can prove the payload round-trips exactly,
- * rather than asserting against an opaque blob.
- */
-export function decodeRawData(base64: string): Uint8Array {
-  return gunzipSync(Buffer.from(base64, "base64"));
-}

package/r2000-symbols.ts

@@ -1,388 +0,0 @@
-#!/usr/bin/env node
-// r2000-symbols.ts -- the ONE authoritative place in this repo for the
-// symbol round trip between regenerator2000's annotation store and stock
-// VICE's symbol table (R2000-14/R2000-15, ARCHITECTURE.md Rule A20).
-//
-// WHY THIS FILE EXISTS: static-analysis symbols going OUT to VICE
-// (`exportLabels()`) and live-discovered symbols coming IN from VICE
-// (`importLabels()`) must flow through explicit adapter code -- neither side
-// may parse the other's internal representation (Rule A20). This module is
-// that adapter. It reuses `stock-symbols.ts`'s existing `al C:xxxx .Name`
-// parser (`parseViceLabelFile()`, exported there for exactly this reuse)
-// rather than adding this repo's THIRD copy of that format --
-// `stock-symbols.ts` and `acme-build/scripts/acme.mjs`'s `curateLabels()`
-// are the two that already exist.
-//
-// MEASURED FACTS this module's behaviour depends on:
-//   - `--export_lbl` exports USER labels only. Measured (Phase 9, and
-//     re-confirmed by this plan's own round-trip test): an annotated
-//     project emits exactly the labels a caller set via
-//     `r2000_set_label_name`/`--import_lbl` -- the auto-generated `a_D011` /
-//     `a_D020` / `e_FFD2` externals are NOT exported. A test asserting an
-//     `a_`-prefixed name appears in an `exportLabels()` result is testing
-//     the wrong thing.
-//   - `--import_lbl` under plain `--headless` DISCARDS. `main.rs:800-806` is
-//     `if headless && !mcp_server { return Ok(()) }`: an argv of
-//     `--import_lbl <path> --headless <proj>` imports the labels into
-//     memory and then hits that early return WITHOUT ever calling save, so
-//     the import is silently discarded -- measured live: two names imported
-//     that way, and a subsequent `--export_lbl` read back from disk
-//     returned only the pre-existing label. `r2000-launch.ts`'s
-//     `buildImportLblArgs()` makes this combination unbuildable by always
-//     pairing `--mcp-server-stdio` (which sets both `headless` AND
-//     `mcp_server`, `main.rs:709-711`, skipping the early return) --
-//     `r2000-symbol-roundtrip.test.ts` pins the trap itself with a
-//     hand-built argv, so that builder's pairing stays provably load-bearing
-//     rather than merely assumed.
-//
-// WHAT NOT TO DO, named concretely:
-//   - Never add a second `al C:xxxx .Name` regex anywhere in this file.
-//     Every read of a label file's TEXT goes through
-//     `stock-symbols.ts`'s exported `parseViceLabelFile()`.
-//   - Never call `vice_symbols_load` (`stock-symbols.ts`'s handlers)
-//     incrementally. `regenerateAndReload()` below regenerates the WHOLE
-//     `.lbl` and returns its path for the CALLER to hand to
-//     `vice_symbols_load` exactly once -- `vice_symbols_load` is
-//     deliberately replace-not-merge (T-05-02-05), so a full regeneration is
-//     what keeps that semantics correct rather than a limitation. A merge
-//     mode on `vice_symbols_load` itself was rejected: it would reopen a
-//     v0.2.0 decision and make a tool advertised on both backends diverge in
-//     semantics.
-//   - Never build `--import_lbl`'s argv by hand in this file. It comes ONLY
-//     from `r2000-launch.ts`'s `buildImportLblArgs()` -- there is no literal
-//     `"--import_lbl"` string anywhere below.
-//   - Never report an import as persisted on the strength of a
-//     no-error response alone. `importLabels()` below proves persistence
-//     TWICE: once via `saveAndVerify()`'s content-hash check (inside the
-//     import session), and independently via a fresh `exportLabels()` from
-//     disk, in a BRAND NEW process, after the import session has fully
-//     closed. `ImportLabelsResult` is a discriminated union
-//     (`diskVerified: true | false`) specifically so a caller cannot
-//     mistake "the import call returned no error" for "the names are
-//     actually on disk".
-//   - Never let an illegal label name from a `.lbl` file reach a spawned
-//     child (T-11-NAME-INJECT, closed). `importLabels()` validates every
-//     name against `r2000-acme-ident.ts`'s `assertLegalAcmeIdentifier()`
-//     BEFORE `buildImportLblArgs()` is ever called -- REJECT, never
-//     sanitize, matching `r2000-tools.ts`'s `r2000_set_label_name` posture.
-import { existsSync, mkdtempSync, readFileSync, rmSync, statSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { buildExportLblArgs, buildImportLblArgs, runR2000 } from "./r2000-launch.ts";
-import { withR2000Session, saveAndVerify } from "./r2000-mcp-client.ts";
-import { runR2000Tool } from "./r2000-tools.ts";
-import { parseViceLabelFile, MAX_LABEL_FILE_BYTES } from "./stock-symbols.ts";
-import { assertLegalAcmeIdentifier } from "./r2000-acme-ident.ts";
-
-/** This module's own error class, following `r2000-tools.ts`'s
- * `R2000StorePathError` / `r2000-launch.ts`'s `R2000ViceFlagError` minimal
- * shape (message-only, `.name` set to the class name). Never thrown for a
- * ceiling violation on a `.lbl` file's TEXT -- those come from
- * `stock-symbols.ts`'s `StockSymbolsError`, surfaced verbatim, never
- * re-wrapped as this class. Reserved for this module's OWN failure modes:
- * a nonzero regenerator2000 exit, a missing output file despite a zero
- * exit, an oversized file caught before `parseViceLabelFile()` is ever
- * called, or (T-11-NAME-INJECT, closed) an illegal label name caught in
- * `importLabels()` before any child is spawned -- naming the offending
- * name, its 1-based line number, and that line's own text. */
-export class R2000SymbolsError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "R2000SymbolsError";
-  }
-}
-
-export interface LabelEntry {
-  name: string;
-  address: number;
-}
-
-export interface ExportLabelsOptions {
-  projectPath: string;
-  outPath: string;
-}
-
-export interface ExportLabelsResult {
-  path: string;
-  symbolCount: number;
-  symbols: LabelEntry[];
-  skippedLines: number;
-  duplicateNames: number;
-  lineCount: number;
-}
-
-/**
- * The export leg (R2000-14). Runs `buildExportLblArgs()` through
- * `runR2000()`, then READS THE PRODUCED FILE BACK through
- * `stock-symbols.ts`'s existing parser to validate it and return the parsed
- * symbol list plus a count.
- *
- * The read-back is not optional, for two independent reasons: a
- * regenerator2000 exit code has lied before (`r2000-verify.ts`'s founding
- * incident, D-10 -- a zero exit alongside content that should have failed),
- * and the parse is the only thing that proves the produced file is in the
- * format `vice_symbols_load` actually accepts. Ceiling violations from
- * `parseViceLabelFile()` (`StockSymbolsError`) are surfaced VERBATIM, never
- * re-wrapped -- only this function's OWN failure modes (nonzero exit,
- * missing file, oversized file) throw `R2000SymbolsError`.
- */
-export async function exportLabels({ projectPath, outPath }: ExportLabelsOptions): Promise<ExportLabelsResult> {
-  const argv = buildExportLblArgs({ projectPath, outPath });
-  const result = runR2000(argv);
-  if (result.status !== 0) {
-    throw new R2000SymbolsError(
-      `exportLabels: regenerator2000 exited ${result.status} for "${projectPath}" -- stderr: ${result.stderr || "(empty)"}`,
-    );
-  }
-  if (!existsSync(outPath)) {
-    throw new R2000SymbolsError(
-      `exportLabels: regenerator2000 exited 0 but did not produce "${outPath}" -- a lying zero exit code has ` +
-        "happened before (r2000-verify.ts's founding incident, D-10); refusing to trust the exit code alone.",
-    );
-  }
-
-  let size: number;
-  try {
-    size = statSync(outPath).size;
-  } catch (err) {
-    throw new R2000SymbolsError(
-      `exportLabels: could not stat "${outPath}" (${err instanceof Error ? err.message : String(err)})`,
-    );
-  }
-  if (size > MAX_LABEL_FILE_BYTES) {
-    throw new R2000SymbolsError(
-      `exportLabels: "${outPath}" is ${size} bytes, which exceeds the ${MAX_LABEL_FILE_BYTES}-byte ceiling`,
-    );
-  }
-
-  const text = readFileSync(outPath, "utf8");
-  // Reused verbatim -- stock-symbols.ts's ONE parser, never a second regex.
-  // A ceiling violation here (StockSymbolsError) propagates unmodified.
-  const parsed = parseViceLabelFile(text);
-
-  const symbols: LabelEntry[] = Array.from(parsed.table.byName.entries()).map(([name, address]) => ({ name, address }));
-
-  return {
-    path: outPath,
-    symbolCount: parsed.symbolCount,
-    symbols,
-    skippedLines: parsed.skippedLines,
-    duplicateNames: parsed.duplicateNames,
-    lineCount: parsed.lineCount,
-  };
-}
-
-export interface ImportLabelsOptions {
-  projectPath: string;
-  lblPath: string;
-}
-
-export interface ImportLabelsVerified {
-  diskVerified: true;
-  importedNames: string[];
-  /** The fresh, independent `exportLabels()` result used to prove
-   * persistence -- a caller can inspect it without re-exporting itself. */
-  exported: ExportLabelsResult;
-}
-
-export interface ImportLabelsUnverified {
-  diskVerified: false;
-  importedNames: string[];
-  /** Names present in the imported `.lbl` file that a fresh export from
-   * disk did NOT contain. Always non-empty when `diskVerified` is `false`. */
-  missingNames: string[];
-  reason: string;
-}
-
-/**
- * A discriminated union, deliberately -- `diskVerified: true` and
- * `diskVerified: false` are structurally distinct shapes, so a caller
- * cannot read `result.importedNames` and mistake "the import call returned
- * no error" for "the names are actually on disk" (the plan's own required
- * distinction). Only the `true` variant carries `exported`; only the
- * `false` variant carries `missingNames`/`reason`.
- */
-export type ImportLabelsResult = ImportLabelsVerified | ImportLabelsUnverified;
-
-/**
- * The import leg (R2000-15, the D-28 path). Runs `buildImportLblArgs()` --
- * which ALWAYS carries `--mcp-server-stdio` -- and, over that SAME stdio
- * session, calls `r2000_save_project` through `r2000-mcp-client.ts`'s
- * `saveAndVerify()`. `--import_lbl` mutates only IN-MEMORY state
- * (`main.rs:800-806` is why the save must be explicit); `saveAndVerify()`
- * proves the save changed the project file's own content hash on disk.
- *
- * That alone is `r2000-mcp-client.ts`'s own T-11-FALSESUCCESS proof, not
- * THIS module's. `importLabels()` proves persistence a SECOND, independent
- * way: after the import session has fully closed, a BRAND NEW process
- * (`exportLabels()`, a fresh `runR2000()` child) re-reads the project from
- * disk and re-exports its labels. Only when every name in the caller's
- * `.lbl` file appears in that fresh export does this function report
- * `diskVerified: true`.
- *
- * The caller-supplied `.lbl` file itself is ceiling-checked BEFORE any
- * child process is spawned (T-11-LBL-SIZE): a byte-size check against
- * `stock-symbols.ts`'s own `MAX_LABEL_FILE_BYTES`, then a full
- * `parseViceLabelFile()` pass, whose `StockSymbolsError` ceiling violations
- * (`MAX_LABEL_FILE_LINES`/`MAX_SYMBOLS`) propagate verbatim -- an oversized
- * or over-populated `.lbl` never reaches regenerator2000 at all.
- *
- * Every discovered name is then validated against `r2000-acme-ident.ts`'s
- * `assertLegalAcmeIdentifier()`, also BEFORE any spawn (T-11-NAME-INJECT,
- * closed): an illegal name throws `R2000SymbolsError` naming the offending
- * name, its 1-based line number, and that line's own text -- REJECT, never
- * sanitize, the same posture `r2000-tools.ts`'s `r2000_set_label_name`
- * takes on the tool-surface entry route.
- */
-export async function importLabels({ projectPath, lblPath }: ImportLabelsOptions): Promise<ImportLabelsResult> {
-  let size: number;
-  try {
-    size = statSync(lblPath).size;
-  } catch (err) {
-    throw new R2000SymbolsError(
-      `importLabels: could not stat "${lblPath}" (${err instanceof Error ? err.message : String(err)})`,
-    );
-  }
-  if (size > MAX_LABEL_FILE_BYTES) {
-    throw new R2000SymbolsError(
-      `importLabels: "${lblPath}" is ${size} bytes, which exceeds the ${MAX_LABEL_FILE_BYTES}-byte ceiling`,
-    );
-  }
-
-  const inputText = readFileSync(lblPath, "utf8");
-  // Reused verbatim -- same parser as exportLabels(). A ceiling violation
-  // here (StockSymbolsError) propagates unmodified, before any spawn.
-  const inputParsed = parseViceLabelFile(inputText);
-  const importedNames = Array.from(inputParsed.table.byName.keys());
-
-  // T-11-NAME-INJECT (route B, closed): every discovered label name is
-  // validated against the one ACME identifier seam (r2000-acme-ident.ts)
-  // BEFORE any child is spawned -- REJECT, never sanitize, matching
-  // r2000-tools.ts's r2000_set_label_name posture. The offending line is
-  // located by a substring search over the already-read inputText, never a
-  // second `al C:` regex (this module's own header forbids a third parser
-  // for that format, T-11-LBL-PARSER-DUP).
-  for (const name of importedNames) {
-    try {
-      assertLegalAcmeIdentifier(name, "importLabels label name");
-    } catch (err) {
-      const reason = err instanceof Error ? err.message : String(err);
-      const inputLines = inputText.split(/\r?\n/);
-      const lineIndex = inputLines.findIndex((line) => line.includes(name));
-      const lineNumber = lineIndex === -1 ? 0 : lineIndex + 1;
-      const lineText = lineIndex === -1 ? "(line not found)" : inputLines[lineIndex];
-      throw new R2000SymbolsError(
-        `importLabels: "${lblPath}" line ${lineNumber} carries an illegal label name "${name}" (${reason}) -- ` +
-          `line text: ${JSON.stringify(lineText)}. REJECTED, never sanitized or quoted, before any child is spawned.`,
-      );
-    }
-  }
-
-  // buildImportLblArgs() is the ONLY producer of this argv -- there is no
-  // literal "--import_lbl" string anywhere in this file.
-  const argv = buildImportLblArgs({ projectPath, lblPath });
-  await withR2000Session(projectPath, (call) => saveAndVerify(projectPath, call), { argv });
-
-  // Independent proof #2: a brand-new process, after the import session has
-  // fully closed, re-reads the project from disk and re-exports its labels.
-  const verifyDir = mkdtempSync(join(tmpdir(), "r2000-symbols-verify-"));
-  try {
-    const reExportPath = join(verifyDir, "reexport.lbl");
-    const exported = await exportLabels({ projectPath, outPath: reExportPath });
-    const exportedNames = new Set(exported.symbols.map((s) => s.name));
-    const missingNames = importedNames.filter((n) => !exportedNames.has(n));
-
-    if (missingNames.length > 0) {
-      return {
-        diskVerified: false,
-        importedNames,
-        missingNames,
-        reason:
-          `importLabels: saveAndVerify() reported a changed content hash for "${projectPath}", but a fresh ` +
-          `exportLabels() from disk is missing ${missingNames.length} of ${importedNames.length} imported ` +
-          `name(s): ${missingNames.join(", ")}`,
-      };
-    }
-
-    return { diskVerified: true, importedNames, exported };
-  } finally {
-    rmSync(verifyDir, { recursive: true, force: true });
-  }
-}
-
-export interface RegenerateAndReloadOptions {
-  projectPath: string;
-  outPath: string;
-  address: number;
-  name: string;
-}
-
-export interface RegenerateAndReloadResult {
-  path: string;
-  symbolCount: number;
-  symbols: LabelEntry[];
-}
-
-/**
- * D-29: the store is the merge point for a live-discovered name. Writes
- * `name` at `address` into the store FIRST (via the curated
- * `r2000_set_label_name`, `r2000-tools.ts`'s `runR2000Tool()` -- which
- * auto-saves internally before its session exits), THEN regenerates the
- * WHOLE `.lbl` with `exportLabels()`, and returns the path for the CALLER
- * to hand to `vice_symbols_load` EXACTLY ONCE.
- *
- * This function deliberately does NOT call `vice_symbols_load` itself --
- * see this module's header for why an incremental/repeated load would
- * violate `vice_symbols_load`'s replace-not-merge semantics (T-05-02-05).
- *
- * Note (T-11-NAME-INJECT, closed): an illegal `name` now REJECTS this
- * function's returned promise -- `r2000_set_label_name`'s own pre-spawn
- * `assertLegalLabelArg()` gate (`r2000-tools.ts`) fires inside
- * `runR2000Tool()`'s `assertCuratedTool()` call, before `runR2000Tool()`'s
- * own `try` block, rather than surfacing as `setResult.isError` the way a
- * regenerator2000-side failure would. This function had no production
- * caller when that note was written, so no existing behaviour depended on
- * the old `isError`-shaped outcome -- superseded in place by the formal
- * status below rather than left as an aside.
- *
- * LIBRARY-ONLY (Phase 11 IN-02, D-11.1-06): as of this phase,
- * `regenerateAndReload()` is a library-only export -- available for
- * programmatic use, with NO PRODUCTION CALLER anywhere in this repo
- * (`.claude/mcp/vice/`, `.claude/skills/`, `scripts/`). A future phase must
- * not assume it is wired into any real workflow just because it is the
- * named D-29 live-discovery merge point.
- *
- * The proven live path for the symbol round trip is NOT this function --
- * it is `r2000 export-lbl` -> `vice_symbols_load` -> live discovery ->
- * `r2000_set_label_name` -> `r2000 import-lbl`, documented as one closed
- * loop in `c64-program-recon/SKILL.md`. `R2000-15` is satisfied through
- * that sequence, not through this convenience wrapper. Giving this
- * function a caller would mean inventing a new CLI verb or skill entry
- * point it was never actually proven through -- out of this phase's scope
- * fence (11.1-CONTEXT.md).
- *
- * ADOPTION CONDITION: if `regenerateAndReload()` ever acquires a real
- * production caller, the `LIBRARY-ONLY` marker above must be deleted in
- * the SAME commit that adds the caller. `r2000-symbol-roundtrip.test.ts`
- * enforces this as a biconditional, in both directions: zero callers
- * requires the marker present; one or more callers requires the marker
- * absent. The two can never legally disagree.
- */
-export async function regenerateAndReload({
-  projectPath,
-  outPath,
-  address,
-  name,
-}: RegenerateAndReloadOptions): Promise<RegenerateAndReloadResult> {
-  const setResult = await runR2000Tool("r2000_set_label_name", { project: projectPath, address, name });
-  if (setResult.isError) {
-    throw new R2000SymbolsError(
-      `regenerateAndReload: r2000_set_label_name failed for "${name}" at ${address}: ` +
-        `${setResult.content.map((c) => c.text).join(" ")}`,
-    );
-  }
-
-  const exported = await exportLabels({ projectPath, outPath });
-  return { path: exported.path, symbolCount: exported.symbolCount, symbols: exported.symbols };
-}