@rungs/cli 0.3.0 → 0.4.0

package/src/backlog.ts

@@ -1,5 +1,20 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { dirname, join, relative, resolve, sep } from 'node:path';
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import {
+  preflightEmittedPaths,
+  resolveEmittedPath,
+  UnsafeEmittedPathError,
+  type ResolvedEmittedPath,
+} from './emitted-path.ts';
 import { walk } from './glob.ts';
 
 /**
@@ -36,6 +51,74 @@ export interface ArchivePlan {
   held: { file: string; reason: string }[];
 }
 
+export interface ResolvedArchiveTree {
+  /** Normalized portable path recorded in the archive plan. */
+  root: string;
+  items: ResolvedEmittedPath;
+  archive: ResolvedEmittedPath;
+  itemsExists: boolean;
+  archiveExists: boolean;
+}
+
+interface PreparedArchiveMove {
+  move: ArchiveMove;
+  from: ResolvedEmittedPath;
+  to: ResolvedEmittedPath;
+}
+
+interface PreparedArchiveRewrite {
+  file: string;
+  path: ResolvedEmittedPath;
+  original: string;
+  updated: string;
+  links: number;
+}
+
+interface PreparedArchive {
+  moves: PreparedArchiveMove[];
+  rewrites: PreparedArchiveRewrite[];
+}
+
+const ARCHIVE_OPERATION = 'backlog archive';
+
+const missingEntry = (error: unknown) =>
+  error instanceof Error && 'code' in error && (error.code === 'ENOENT' || error.code === 'ENOTDIR');
+
+function existingDirectory(path: ResolvedEmittedPath): boolean {
+  try {
+    if (!statSync(path.absolute).isDirectory()) {
+      throw new UnsafeEmittedPathError(ARCHIVE_OPERATION, path.target, 'the existing archive tree entry is not a directory');
+    }
+    return true;
+  } catch (error) {
+    if (error instanceof UnsafeEmittedPathError) throw error;
+    if (missingEntry(error)) return false;
+    throw new UnsafeEmittedPathError(ARCHIVE_OPERATION, path.target, 'the archive tree entry cannot be inspected');
+  }
+}
+
+/**
+ * Resolve the two archive-tree directories before callers inspect either one.
+ * Appending the fixed names also validates the configured root as portable
+ * repository-relative data without treating the root and its children as
+ * conflicting file emissions.
+ */
+export function resolveArchiveTree(repoRoot: string, backlogRoot = 'docs/backlog'): ResolvedArchiveTree {
+  const [items, archive] = preflightEmittedPaths(repoRoot, [
+    { moduleName: ARCHIVE_OPERATION, target: `${backlogRoot}/items` },
+    { moduleName: ARCHIVE_OPERATION, target: `${backlogRoot}/archive` },
+  ]);
+  const suffix = '/items';
+  const root = items.target.slice(0, -suffix.length);
+  return {
+    root,
+    items,
+    archive,
+    itemsExists: existingDirectory(items),
+    archiveExists: existingDirectory(archive),
+  };
+}
+
 /** Statuses whose work can no longer change. Mirrors backlog README §8. */
 const FINISHED = new Set(['done', 'rejected']);
 
@@ -47,13 +130,22 @@ const posix = (p: string) => p.split(sep).join('/');
 const LINK = /\]\((?!https?:|#|mailto:)([^)\s#]+)((?:#[^)\s]*)?)\)/g;
 
 export function planArchive(repoRoot: string, backlogRoot = 'docs/backlog'): ArchivePlan {
-  const itemsDir = join(repoRoot, ...backlogRoot.split('/'), 'items');
-  const archiveDir = join(repoRoot, ...backlogRoot.split('/'), 'archive');
+  const tree = resolveArchiveTree(repoRoot, backlogRoot);
   const moves: ArchiveMove[] = [];
   const held: ArchivePlan['held'] = [];
 
-  const files = walk(repoRoot);
-  const items = files.filter((f) => posix(f).startsWith(posix(relative(repoRoot, itemsDir)) + '/') && f.endsWith('.md'));
+  if (!tree.itemsExists) return { root: tree.root, moves, rewrites: [], held };
+
+  // Walk the canonical contained directories directly. The repository-wide
+  // walker intentionally does not follow directory aliases; an inward alias
+  // is nevertheless a valid archive tree and must retain normal behavior.
+  const beneath = (directory: ResolvedEmittedPath) =>
+    walk(directory.absolute)
+      .filter((file) => file.endsWith('.md'))
+      .map((file) => `${directory.target}/${posix(file)}`)
+      .sort();
+  const items = beneath(tree.items);
+  const archived = tree.archiveExists ? beneath(tree.archive) : [];
 
   for (const rel of items) {
     // The **basename**, exactly — not a suffix of the path. `/TEMPLATE\.md$/i`
@@ -64,7 +156,8 @@ export function planArchive(repoRoot: string, backlogRoot = 'docs/backlog'): Arc
     // to the wrong end reads as careful and is not.
     const base = posix(rel).split('/').pop()!;
     if (/^(README|TEMPLATE)\.md$/i.test(base)) continue;
-    const text = readFileSync(join(repoRoot, rel), 'utf8');
+    const source = resolveEmittedPath(repoRoot, ARCHIVE_OPERATION, rel);
+    const text = readFileSync(source.absolute, 'utf8');
     const status = field(text, 'status');
     const id = field(text, 'id');
     if (!FINISHED.has(status)) continue;
@@ -82,12 +175,14 @@ export function planArchive(repoRoot: string, backlogRoot = 'docs/backlog'): Arc
       // as unfinished, so an epic whose children had all landed could never be
       // archived and the hold message named five done items as outstanding. The
       // more finished an epic got, the more stuck it became.
-      const archived = files.filter((f) => posix(f).startsWith(posix(relative(repoRoot, archiveDir)) + '/') && f.endsWith('.md'));
       const unfinished = children.filter((c) => {
         const f = items.find((i) => i.includes(`${c}-`)) ?? archived.find((i) => i.includes(`${c}-`));
         // Still `!f` → genuinely unknown, and an unknown holds. A child nobody
         // can find is not evidence that it finished.
-        return !f || !FINISHED.has(field(readFileSync(join(repoRoot, f), 'utf8'), 'status'));
+        return (
+          !f ||
+          !FINISHED.has(field(readFileSync(resolveEmittedPath(repoRoot, ARCHIVE_OPERATION, f).absolute, 'utf8'), 'status'))
+        );
       });
       if (unfinished.length) {
         held.push({ file: rel, reason: `epic with unfinished children: ${unfinished.join(', ')}` });
@@ -102,22 +197,16 @@ export function planArchive(repoRoot: string, backlogRoot = 'docs/backlog'): Arc
       id,
       status,
       from: rel,
-      to: posix(join(relative(repoRoot, archiveDir), posix(rel).split('/').pop()!)),
+      to: `${tree.archive.target}/${posix(rel).split('/').pop()!}`,
     });
   }
 
-  // Where each moved file ends up, keyed by its absolute old path, so a link can
-  // be looked up by what it resolves to rather than by how it was spelled.
-  const moved = new Map(moves.map((m) => [resolve(repoRoot, m.from), m.to]));
-  const rewrites: ArchivePlan['rewrites'] = [];
-
-  for (const rel of files) {
-    if (!isRewritable(rel)) continue;
-    const links = retargets(repoRoot, rel, moved).length;
-    if (links || moved.has(resolve(repoRoot, rel))) rewrites.push({ file: rel, links });
-  }
-
-  return { root: backlogRoot, moves, rewrites, held };
+  const provisional = { root: tree.root, moves, rewrites: [], held };
+  const prepared = prepareArchive(repoRoot, provisional);
+  return {
+    ...provisional,
+    rewrites: prepared.rewrites.map(({ file, links }) => ({ file, links })),
+  };
 }
 
 /**
@@ -145,17 +234,31 @@ function isRewritable(rel: string): boolean {
  * of those were equivalent spellings of an unmoved target. Rewriting them would
  * have been a repo-wide reflow disguised as an archive.
  */
-function retargets(repoRoot: string, rel: string, moved: Map<string, string>): { href: string; to: string }[] {
+function retargets(
+  repoRoot: string,
+  rel: string,
+  moved: Map<string, string>,
+  source = readFileSync(join(repoRoot, ...rel.split('/')), 'utf8'),
+): { href: string; to: string }[] {
   const oldDir = dirname(resolve(repoRoot, rel));
-  const selfMoved = moved.get(resolve(repoRoot, rel));
+  const movedDestination = (path: string) => {
+    const lexical = moved.get(path);
+    if (lexical) return lexical;
+    try {
+      return moved.get(realpathSync.native(path));
+    } catch {
+      return undefined;
+    }
+  };
+  const selfMoved = movedDestination(resolve(repoRoot, rel));
   const newDir = dirname(resolve(repoRoot, selfMoved ?? rel));
   const out: { href: string; to: string }[] = [];
 
-  for (const m of readFileSync(join(repoRoot, rel), 'utf8').matchAll(LINK)) {
+  for (const m of source.matchAll(LINK)) {
     const href = m[1];
     if (href.includes('{{')) continue; // a template link, resolved at install
     const target = resolve(oldDir, decodeURIComponent(href));
-    const targetMoved = moved.get(target);
+    const targetMoved = movedDestination(target);
     if (!targetMoved && !selfMoved) continue;
     if (!targetMoved && !existsSync(target)) continue; // already broken; not this command's to fix
     const targetNew = targetMoved ? resolve(repoRoot, targetMoved) : target;
@@ -168,30 +271,233 @@ function retargets(repoRoot: string, rel: string, moved: Map<string, string>): {
   return out;
 }
 
-export function applyArchive(repoRoot: string, plan: ArchivePlan): void {
-  const moved = new Map(plan.moves.map((m) => [resolve(repoRoot, m.from), m.to]));
-
-  // Rewrite before moving. Every path is computed from the plan rather than from
-  // the filesystem, so the order is a choice — and this order means a crash
-  // halfway leaves the files still where the links say they are.
-  for (const rel of walk(repoRoot)) {
-    if (!isRewritable(rel)) continue;
-    const edits = retargets(repoRoot, rel, moved);
-    if (!edits.length) continue;
-    const path = join(repoRoot, rel);
-    let text = readFileSync(path, 'utf8');
-    // Replace through the same matcher that found them, so a href appearing in
-    // prose as well as in a link cannot be hit by a bare string replace.
-    text = text.replace(LINK, (whole, href: string, anchor: string) => {
-      const edit = edits.find((e) => e.href === href);
-      return edit ? `](${edit.to}${anchor})` : whole;
+function requireRegularFile(path: ResolvedEmittedPath, purpose: string): void {
+  if (path.leafAlias) {
+    throw new UnsafeEmittedPathError(
+      ARCHIVE_OPERATION,
+      path.target,
+      `the ${purpose} is a symlink or junction leaf`,
+    );
+  }
+  try {
+    if (!lstatSync(path.absolute).isFile()) {
+      throw new UnsafeEmittedPathError(ARCHIVE_OPERATION, path.target, `the ${purpose} is not a regular file`);
+    }
+  } catch (error) {
+    if (error instanceof UnsafeEmittedPathError) throw error;
+    if (missingEntry(error)) {
+      throw new UnsafeEmittedPathError(ARCHIVE_OPERATION, path.target, `the ${purpose} no longer exists`);
+    }
+    throw new UnsafeEmittedPathError(ARCHIVE_OPERATION, path.target, `the ${purpose} cannot be inspected`);
+  }
+}
+
+function requireMissingDestination(path: ResolvedEmittedPath): void {
+  if (path.leafAlias) {
+    throw new UnsafeEmittedPathError(
+      ARCHIVE_OPERATION,
+      path.target,
+      'the archive destination is an existing symlink or junction leaf',
+    );
+  }
+  try {
+    lstatSync(path.absolute);
+    throw new UnsafeEmittedPathError(ARCHIVE_OPERATION, path.target, 'the archive destination already exists');
+  } catch (error) {
+    if (error instanceof UnsafeEmittedPathError) throw error;
+    if (!missingEntry(error)) {
+      throw new UnsafeEmittedPathError(ARCHIVE_OPERATION, path.target, 'the archive destination cannot be inspected');
+    }
+  }
+}
+
+function requireCanonicalDescendant(
+  directory: ResolvedEmittedPath,
+  path: ResolvedEmittedPath,
+  purpose: string,
+): void {
+  const fromDirectory = relative(directory.absolute, path.absolute);
+  if (
+    !fromDirectory ||
+    fromDirectory === '..' ||
+    fromDirectory.startsWith(`..${sep}`) ||
+    isAbsolute(fromDirectory)
+  ) {
+    throw new UnsafeEmittedPathError(
+      ARCHIVE_OPERATION,
+      path.target,
+      `the ${purpose} resolves outside the canonical '${directory.target}' tree`,
+    );
+  }
+}
+
+function prepareMoves(repoRoot: string, plan: ArchivePlan, tree: ResolvedArchiveTree): PreparedArchiveMove[] {
+  if (plan.root !== tree.root) {
+    throw new UnsafeEmittedPathError(
+      ARCHIVE_OPERATION,
+      plan.root,
+      `the plan root does not match its normalized archive root '${tree.root}'`,
+    );
+  }
+
+  const itemsPrefix = `${tree.items.target}/`;
+  const archivePrefix = `${tree.archive.target}/`;
+  for (const move of plan.moves) {
+    if (!move.from.startsWith(itemsPrefix)) {
+      throw new UnsafeEmittedPathError(
+        ARCHIVE_OPERATION,
+        move.from,
+        `an archive source must be below '${tree.items.target}'`,
+      );
+    }
+    const expected = `${archivePrefix}${move.from.split('/').pop()!}`;
+    if (move.to !== expected) {
+      throw new UnsafeEmittedPathError(
+        ARCHIVE_OPERATION,
+        move.to,
+        `the archive destination for '${move.from}' must be '${expected}'`,
+      );
+    }
+  }
+
+  const resolved = preflightEmittedPaths(
+    repoRoot,
+    plan.moves.flatMap((move) => [
+      { moduleName: ARCHIVE_OPERATION, target: move.from },
+      { moduleName: ARCHIVE_OPERATION, target: move.to },
+    ]),
+  );
+
+  return plan.moves.map((move, index) => {
+    const from = resolved[index * 2];
+    const to = resolved[index * 2 + 1];
+    requireCanonicalDescendant(tree.items, from, 'archive source');
+    requireCanonicalDescendant(tree.archive, to, 'archive destination');
+    requireRegularFile(from, 'archive source');
+    requireMissingDestination(to);
+
+    const source = readFileSync(from.absolute, 'utf8');
+    if (field(source, 'id') !== move.id || field(source, 'status') !== move.status || !FINISHED.has(move.status)) {
+      throw new UnsafeEmittedPathError(
+        ARCHIVE_OPERATION,
+        move.from,
+        'the archive plan is stale or does not match the source item frontmatter',
+      );
+    }
+    return { move, from, to };
+  });
+}
+
+function preparedText(source: string, edits: { href: string; to: string }[]): string {
+  // Replace through the same matcher that found the links, so an href appearing
+  // in prose as well as in a link cannot be hit by a bare string replace.
+  return source.replace(LINK, (whole, href: string, anchor: string) => {
+    const edit = edits.find((candidate) => candidate.href === href);
+    return edit ? `](${edit.to}${anchor})` : whole;
+  });
+}
+
+function rewriteSummary(rewrites: PreparedArchiveRewrite[]): ArchivePlan['rewrites'] {
+  return rewrites
+    .map(({ file, links }) => ({ file, links }))
+    .sort((left, right) => left.file.localeCompare(right.file));
+}
+
+function prepareArchive(repoRoot: string, plan: ArchivePlan, verifyRecordedRewrites = false): PreparedArchive {
+  const tree = resolveArchiveTree(repoRoot, plan.root);
+  const moves = prepareMoves(repoRoot, plan, tree);
+
+  if (verifyRecordedRewrites) {
+    const recorded = preflightEmittedPaths(
+      repoRoot,
+      plan.rewrites.map((rewrite) => ({
+        moduleName: ARCHIVE_OPERATION,
+        target: rewrite.file,
+        writeExisting: true,
+      })),
+    );
+    recorded.forEach((path) => requireRegularFile(path, 'recorded rewrite target'));
+  }
+
+  // Where each moved file ends up, keyed by its lexical old path, so a link is
+  // selected by what its written spelling resolves to. Actual I/O below uses
+  // the canonical paths that were validated for this operation.
+  const moved = new Map<string, string>();
+  for (const { move, from } of moves) {
+    moved.set(resolve(repoRoot, ...move.from.split('/')), move.to);
+    moved.set(from.absolute, move.to);
+  }
+
+  // Prefer the archive plan's lexical spelling for a moved source, then the
+  // previously recorded rewrite spelling. The general walker can also see the
+  // canonical side of an inward directory alias; deduplicating by canonical
+  // identity prevents one physical file from being prepared twice.
+  const candidatePaths: { file: string; path: ResolvedEmittedPath }[] = [];
+  const seenCanonical = new Set<string>();
+  const addCandidate = (file: string) => {
+    if (!isRewritable(file)) return;
+    const path = resolveEmittedPath(repoRoot, ARCHIVE_OPERATION, file);
+    if (seenCanonical.has(path.absolute)) return;
+    seenCanonical.add(path.absolute);
+    candidatePaths.push({ file, path });
+  };
+  moves.forEach(({ move }) => addCandidate(move.from));
+  if (verifyRecordedRewrites) plan.rewrites.forEach(({ file }) => addCandidate(file));
+  walk(repoRoot).sort().forEach(addCandidate);
+
+  const drafts = candidatePaths
+    .flatMap(({ file, path }) => {
+      const original = readFileSync(path.absolute, 'utf8');
+      const edits = retargets(repoRoot, file, moved, original);
+      if (!edits.length) return [];
+      return [{ file, original, updated: preparedText(original, edits), links: edits.length }];
     });
-    writeFileSync(path, text);
+
+  const paths = preflightEmittedPaths(
+    repoRoot,
+    drafts.map((rewrite) => ({
+      moduleName: ARCHIVE_OPERATION,
+      target: rewrite.file,
+      writeExisting: true,
+    })),
+  );
+  const rewrites = drafts.map((rewrite, index) => ({ ...rewrite, path: paths[index] }));
+  rewrites.forEach(({ path }) => requireRegularFile(path, 'rewrite target'));
+
+  if (verifyRecordedRewrites) {
+    const expected = [...plan.rewrites].sort((left, right) => left.file.localeCompare(right.file));
+    const actual = rewriteSummary(rewrites);
+    if (JSON.stringify(expected) !== JSON.stringify(actual)) {
+      throw new UnsafeEmittedPathError(
+        ARCHIVE_OPERATION,
+        plan.root,
+        'the archive plan is stale: its complete rewrite set no longer matches the repository',
+      );
+    }
   }
 
-  for (const m of plan.moves) {
-    const to = join(repoRoot, ...m.to.split('/'));
-    mkdirSync(dirname(to), { recursive: true });
-    renameSync(join(repoRoot, m.from), to);
+  return { moves, rewrites };
+}
+
+export function applyArchive(repoRoot: string, plan: ArchivePlan): void {
+  const prepared = prepareArchive(repoRoot, plan, true);
+
+  // Check every captured source again before the first mutation. This catches
+  // ordinary stale-plan edits without allowing an earlier rewrite to land.
+  for (const rewrite of prepared.rewrites) {
+    if (readFileSync(rewrite.path.absolute, 'utf8') !== rewrite.original) {
+      throw new UnsafeEmittedPathError(
+        ARCHIVE_OPERATION,
+        rewrite.file,
+        'the rewrite target changed after archive preflight',
+      );
+    }
   }
+
+  // Rewrite before moving. Every mutation uses the canonical paths carried by
+  // the validated operation, so an inward alias works and an outward alias can
+  // never be followed during application.
+  for (const move of prepared.moves) mkdirSync(dirname(move.to.absolute), { recursive: true });
+  for (const rewrite of prepared.rewrites) writeFileSync(rewrite.path.absolute, rewrite.updated);
+  for (const move of prepared.moves) renameSync(move.from.absolute, move.to.absolute);
 }

package/src/check.ts

@@ -1,12 +1,13 @@
-import { appendFileSync, existsSync, readFileSync } from 'node:fs';
+import { appendFileSync, existsSync, readFileSync, realpathSync } from 'node:fs';
 import { execSync } from 'node:child_process';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { parse } from 'smol-toml';
 import { ENGINES, isImplemented, type Finding } from './engines.ts';
 import { walk } from './glob.ts';
 import { resolveParams, substitute, type Params } from './substitute.ts';
 import { loadAllModules } from './manifest.ts';
+import { selectEngineTable } from './engine-table.ts';
 
 const MODULES = join(dirname(fileURLToPath(import.meta.url)), '..', 'modules');
 
@@ -79,6 +80,55 @@ export class UnknownTierError extends Error {
   }
 }
 
+function commandText(value: unknown): string {
+  if (value === undefined || value === null) return '';
+  return Buffer.isBuffer(value) ? value.toString('utf8') : String(value);
+}
+
+function normalizeCommandText(value: unknown, repoRoot: string): string {
+  let text = commandText(value).replace(/\r\n?/g, '\n').trim();
+  const absolute = resolve(repoRoot);
+  const roots = [absolute];
+  try {
+    roots.push(realpathSync.native(absolute));
+  } catch {
+    // A command failure still needs a diagnostic if the checkout disappears or
+    // cannot be canonicalized while its error is being reported.
+  }
+  const variants = [...new Set(roots.flatMap((root) => [
+    root,
+    root.replaceAll('\\', '/'),
+    root.replaceAll('/', '\\'),
+  ]))].sort((left, right) => right.length - left.length);
+  for (const variant of variants) {
+    const escaped = variant.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    text = text.replace(new RegExp(escaped, process.platform === 'win32' ? 'gi' : 'g'), '<repo>');
+  }
+  return text;
+}
+
+/** Preserve actionable command output while keeping land attribution independent of root spelling and EOL. */
+function commandFailure(error: any, repoRoot: string): Finding {
+  const stderr = normalizeCommandText(error?.stderr, repoRoot);
+  const stdout = normalizeCommandText(error?.stdout, repoRoot);
+  const fallback = normalizeCommandText(error?.message, repoRoot);
+  const status = typeof error?.status === 'number'
+    ? String(error.status)
+    : error?.signal
+      ? `signal ${error.signal}`
+      : 'unknown';
+  const streams = [
+    ...(stderr ? [`stderr:\n${stderr}`] : []),
+    ...(stdout ? [`stdout:\n${stdout}`] : []),
+  ];
+  const detail = streams.length ? streams.join('\n') : fallback;
+  const diagnostic = `command exited with status ${status}${detail ? `\n${detail}` : ''}`;
+  return {
+    message: diagnostic,
+    identity: `command:${status}${detail ? `\n${detail}` : ''}`,
+  };
+}
+
 /**
  * `only` narrows the run to named gate ids. Attribution needs it: after a merged
  * tree goes red, `land` re-runs **just the failing gates** against the merge base
@@ -114,7 +164,7 @@ export function runGates(repoRoot: string, tier?: string, now = () => Date.now()
         execSync(g.command, { cwd: repoRoot, stdio: 'pipe' });
       } catch (e: any) {
         status = 'fail';
-        findings = [{ message: String(e.stderr ?? e.stdout ?? e.message).trim().split('\n').slice(-3).join(' ') }];
+        findings = [commandFailure(e, repoRoot)];
       }
     } else if (!g.engine || !isImplemented(g.engine)) {
       // Never green. An engine named in a table and missing from the CLI is an
@@ -129,13 +179,7 @@ export function runGates(repoRoot: string, tier?: string, now = () => Date.now()
         findings = [{ message: `table '${g.table}' not found` }];
       } else {
         try {
-          const key = tableKey(g.engine);
-          let section = table[key] ?? table;
-          // An array table holds one entry per gate; select by trailing id.
-          if (Array.isArray(section) && section.some((s: any) => s?.id)) {
-            const mine = section.filter((s: any) => !s.id || g.id.includes(s.id));
-            if (mine.length) section = mine;
-          }
+          const section = selectEngineTable(table, g.engine, g.id);
           const r = ENGINES[g.engine](section, repoRoot, files);
           findings = r.findings;
           examined = r.examined;
@@ -206,29 +250,6 @@ export function installedParams(repoRoot: string): Params {
   return defaults;
 }
 
-export const tableKey = (engine: string) =>
-  ({
-    'file-budget': 'file_budget',
-    sections: 'sections',
-    'frontmatter-schema': 'frontmatter_schema',
-    'link-integrity': 'link_integrity',
-    'file-population': 'file_population',
-    'gate-meta': 'gate_meta',
-    'id-integrity': '__whole__',
-    'render-freshness': 'render_freshness',
-    'register-schema': 'register_schema',
-    'self-declared-closure': 'self_declared_closure',
-    'filename-schema': 'filename_schema',
-    'cross-reference': 'cross_reference',
-    'git-status-reconcile': 'merged_status',
-    'computed-claim': 'computed_claim',
-    'term-ownership': 'term_ownership',
-    'rule-propagation': 'rule_propagation',
-    'git-state': 'git_state',
-    'merge-driver-check': 'merge_driver_check',
-    'board-reconcile': 'board_reconcile',
-  })[engine] ?? engine;
-
 /**
  * ADR-0005 tier A. One line per gate per run: what the runner directly observes
  * and nothing that needs interpretation. Local, gitignored, never transmitted.