@bongos/core 1.21.174 → 1.21.176

package/scripts/gds/copy-inventory.js

@@ -1,571 +1,7 @@
 #!/usr/bin/env node
+// scripts/gds/copy-inventory.js — @bongos-forwarder (task 1004848). Generated by
+// scripts/bongos/codemod-rename-scripts-gds.js; do not edit.
+// The real script is scripts/bongos/copy-inventory.js. This forwarder keeps callers that still name
+// the old path working, and warns once so they get repointed. Task 1003706 removes it.
 'use strict';
-//
-// scripts/gds/copy-inventory.js — the COPY REGISTRY (R01 of goal 1000074, the
-// artist's loop; from idea 1000736).
-//
-// WHAT IT IS FOR. The owner's ABI brief gives the artist the project's TEXT: no
-// slop, story and ideology communicated, purpose and gravitas, re-text-writing.
-// None of that is exercisable today, because the copy is scattered across 23 hall
-// HTML files, 34 hall JS files, the status dashboard and a server-rendered landing
-// template. This command is the inventory that makes it findable — read-only: no
-// editing, no queue, no UI (those are R02/R03).
-//
-// DELIBERATELY IN THE gen-* FAMILY: pure-ish (fs only — no DB, no network, no
-// clock, no randomness), deterministic byte-for-byte on the same tree, emitting one
-// machine-readable registry and one human report. Same posture as gen-repo-map /
-// gen-api-docs: a command you run and commit.
-//
-// THE SURFACE MISMATCH, RECORDED RATHER THAN ASSUMED AWAY. The design contract
-// (modules/ui-design/docs/design-contract.md) says UI components live under
-// `src/ui/<surface>/`, and that a surface directory is the unit a design adapter
-// targets. This tree has no `src/ui/` at all (the adapters moved to
-// modules/ui-design/adapters/ in task 1003324) — the real UI is modules/hall-ui/public
-// and modules/status-ui/public.
-// So this tool maps REAL paths onto contract-shaped surface ids and reports the
-// mismatch in its own output. Do not "fix" that by pretending the contract layout
-// exists.
-//
-// EVERY ROW NAMES ITS RENDER PATH (`origin`), which is what makes the inventory
-// trustworthy: html-text, html-attr:<attr>, html-title, js-markup (text inside
-// markup a script builds), js-notice (toast/alert/confirm), js-text-assign
-// (.textContent/.innerText/.title). A string this tool cannot tie to one of those
-// paths is not listed at all — the first cut filtered "literals that look like
-// prose" and produced 2144 rows of mostly code, including `use strict` 34 times.
-//
-// Run:  node scripts/gds/copy-inventory.js            (writes both artifacts)
-//       node scripts/gds/copy-inventory.js --check     (exit 1 if artifacts stale)
-//       node scripts/gds/copy-inventory.js --json      (registry to stdout, no write)
-
-const fs = require('node:fs');
-const path = require('node:path');
-const crypto = require('node:crypto');
-const { sameContent } = require('./gen-freshness'); // eol-insensitive freshness (CRLF checkouts)
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..');
-// Repo-relative paths that end up INSIDE the checked-in artifacts are joined with
-// '/', never path.join: CI compares the committed bytes, so a Windows run baking
-// 'modules\hall-ui\public' in would rewrite ~1600 lines and never match again.
-// (fs still resolves forward slashes on Windows, so reads are unaffected.)
-const REGISTRY_REL = 'docs/copy-registry.json';
-const REPORT_REL = 'docs/copy-inventory.md';
-
-// The surfaces this tool knows how to read. `id` is the contract-shaped surface
-// name; `at` is where it REALLY lives. Adding a surface is a data edit — the point.
-const SURFACES = [
-  { id: 'builders-hall', kind: 'dir', at: 'modules/hall-ui/public', exts: ['.html', '.js'] },
-  { id: 'status-dashboard', kind: 'dir', at: 'modules/status-ui/public', exts: ['.html', '.js'] },
-  // THE LANDING SURFACE IS modules/public-landing/public/, NOT src/platform-server.js. The first
-  // cut pointed here at the server file, which only fs.readFileSync's these
-  // templates — so its JS patterns matched a handful of incidental literals and the
-  // page's ACTUAL copy (hero, meta/og text, every section) was silently absent
-  // while the registry reported a number. Caught by the grader on task 1003112.
-  { id: 'landing', kind: 'dir', at: 'modules/public-landing/public', exts: ['.html'] },
-];
-
-// Attributes whose value is COPY a person reads (not wiring). The matchers are
-// built ONCE — the first cut re-created all seven per markup literal.
-const COPY_ATTRS = ['title', 'aria-label', 'placeholder', 'alt', 'data-page-title', 'aria-description'];
-// The longest string the registry lists. A page tweak may rewrite a paragraph
-// past the old 400, and the applier then could not find its own words in the
-// registry it regenerates (task 1004768, the privacy page's round).
-const MAX_COPY_LEN = 2000;
-const COPY_ATTR_RES = COPY_ATTRS.map((attr) => ({ attr, re: new RegExp(`\\b${attr}\\s*=\\s*"([^"]{4,${MAX_COPY_LEN}})"`, 'gi') }));
-
-// What this tool knowingly does not see. Printed in the report — an inventory that
-// implies completeness it does not have is worse than a short one.
-const BLIND_SPOTS = [
-  'Landing-page transforms: `modules/public-landing/public/*.html` is scanned as authored, but the server rewrites it before a visitor sees it — `{{token}}` placeholders are filled from the branding pack, and `<!--apex-only:start--> … <!--apex-only:end-->` sections are STRIPPED on a child instance (src/platform-server.js `landingPage()`). So a row here may be copy that this instance never renders, and a rendered sentence may differ from its authored form.',
-  'Server-side messages: route failures (`res.fail` reasons), validation text and API error copy live in server JS and are not walked here. A person reads them, so widening to them is a deliberate later step, not an oversight to quietly fix.',
-  'Skill and playbook prose: `.claude/skills/**/SKILL.md` is read by agents and by builders and is arguably the largest body of project voice. Out of scope on purpose — it is not UI, and mixing it in would drown the UI signal.',
-  'Discord copy: outbound broadcast text is composed in `modules/discord/*.js` at send time. User-facing, but not part of any UI surface.',
-  'JS literals with no render path: a string is listed only when it can be tied to one — markup built in a script, a toast/alert/confirm argument, or a textContent/innerText/title assignment. Copy reaching the DOM by any other route (a helper that takes a message parameter, a string held in a config object) is invisible here, deliberately: the alternative is a queue where most rows are code.',
-  'Template literals containing a nested backtick: the literal scanner stops at the first closing backtick, so a nested template inside `${...}` truncates that one literal. Rare in this tree and cheap to spot (a row that ends mid-sentence); a real JS parser is the fix if it ever matters.',
-  'Runtime-composed strings: anything assembled from fragments or interpolated at render time is captured only as its literal parts. A sentence that exists only once the browser runs cannot be inventoried by reading the tree.',
-  'Generated pages: `docs/api-reference.md` and the OpenAPI surface are generated from route prose; that copy belongs to its generator, not to a designer.',
-  'The design-contract surface layout: `modules/ui-design/docs/design-contract.md` expects `src/ui/<surface>/`, which this tree does not use (there is no `src/ui/`; the adapters live in `modules/ui-design/adapters/`). Surface ids here are a MAPPING onto real paths, not evidence the contract layout exists.',
-];
-
-// A stable id survives the string MOVING: it hashes surface + normalized text,
-// never file or line. That is what lets a flag (R02) stay attached across
-// refactors — and two identical strings in one surface share an id, which is a
-// feature: they are one piece of copy shown twice.
-function stableId(surfaceId, text) {
-  const norm = text.replace(/\s+/g, ' ').trim();
-  return crypto.createHash('sha256').update(`${surfaceId} ${norm}`).digest('hex').slice(0, 12);
-}
-
-// Locale-independent string order — see the note on the entries sort below.
-function cmp(a, b) {
-  if (a === b) return 0;
-  return a < b ? -1 : 1;
-}
-
-// Line lookup without rescanning. The first cut counted newlines from offset 0 for
-// EVERY extracted string — O(n x matches) on the extractor's hottest loop (bounded
-// at ~62 files / ~1096 matches today, but needlessly quadratic-shaped; the grader
-// was right to flag it). One offset table per source, then a binary search.
-function lineIndex(source) {
-  const starts = [0];
-  for (let i = 0; i < source.length; i += 1) if (source[i] === '\n') starts.push(i + 1);
-  return starts;
-}
-
-function lineAt(starts, index) {
-  let lo = 0;
-  let hi = starts.length - 1;
-  while (lo < hi) {
-    const mid = (lo + hi + 1) >> 1;
-    if (starts[mid] <= index) lo = mid; else hi = mid - 1;
-  }
-  return lo + 1;
-}
-
-// Does this look like prose a person reads, rather than code that happens to be a
-// string? Conservative on purpose — a false positive costs an artist's attention.
-//
-// Measured with CRLF folded to LF: the length cap must give a multi-line run the
-// same verdict on a Windows checkout as on CI's, or the committed registry differs
-// by platform (task 1004545 — a 396-char run was 403 under CRLF and vanished).
-function looksLikeCopy(raw) {
-  const s = String(raw).replace(/\r\n/g, '\n').trim();
-  if (s.length < 4 || s.length > MAX_COPY_LEN) return false;
-  if (!/[A-Za-z]{2}/.test(s)) return false;               // needs actual letters
-  if (!/\s/.test(s) && !/[.!?]$/.test(s)) return false;   // one bare word is a token
-  if (/^[/.#]/.test(s)) return false;                     // paths, selectors
-  if (/^https?:/i.test(s)) return false;                  // urls
-  if (/^[a-z0-9-]+$/.test(s)) return false;               // css class / slug
-  if (/^[A-Z0-9_]+$/.test(s)) return false;               // CONSTANT_NAME
-  if (/=>|\$\{|function\s*\(/.test(s)) return false;      // code fragments
-  if (/^[\s\d.,:%$-]+$/.test(s)) return false;            // numbers and units
-  return true;
-}
-
-// THE SPAN: where a row's text physically SITS in the file, as [start, end)
-// character offsets. Every extractor below records one alongside the text.
-//
-// It is deliberately NOT part of the committed registry — buildRegistry drops it
-// (see the note there). A committed offset would go stale on the next edit to an
-// unrelated line of the same file, and the registry's whole point is an id that
-// survives movement. The span is a LIVE fact, recomputed from the tree by whoever
-// needs it: today that is scripts/gds/copy-apply.js (R03 of goal 1000074), which
-// re-runs this extractor against the working tree and uses the span to replace
-// exactly the characters a string occupies and nothing else. Deriving it here,
-// beside the regex that captured the text, is what keeps the applier from owning
-// a second, drifting copy of these matching rules.
-//
-// The span covers the TRIMMED text — a row's `text` is whitespace-collapsed and
-// trimmed, so the indentation around a multi-line literal belongs to the file's
-// formatting, not to the copy, and an applier must leave it alone.
-function trimmedSpan(group, groupStart) {
-  const lead = group.length - group.replace(/^\s+/, '').length;
-  const trail = group.length - group.replace(/\s+$/, '').length;
-  return { start: groupStart + lead, end: groupStart + group.length - trail };
-}
-
-// Strip HTML comments and <script>/<style> bodies so their contents are not read
-// as page text. Replaced with spaces of equal length so every line number — and
-// every span copy-apply.js writes through — stays truthful.
-//
-// Comments are author notes, never something a visitor reads (task 1004545: a
-// header comment's literal `<a>` opened a fake text node). ONE alternation, not
-// three passes, so whichever construct opens first wins, as in a browser: a
-// `<style>` named inside a comment cannot swallow the page up to the real
-// `</style>`, and a `<!--` inside a script string cannot eat past `</script>`.
-//
-// A comment keeps its `<` and `>` and blanks only its inside: marker comments
-// (`<!--apex-only:start-->`, `<!--brand-if:…-->`) split a sentence into segments
-// the server shows or drops independently, so each segment must stay its own row
-// with its own stable id — blanking the whole comment would fuse them.
-function stripEmbedded(html) {
-  return html.replace(/<!--[\s\S]*?-->|<script\b[\s\S]*?<\/script>|<style\b[\s\S]*?<\/style>/gi, (m) => {
-    const blank = m.replace(/[^\r\n]/g, ' ');
-    return m.startsWith('<!--') ? `<${blank.slice(1, -1)}>` : blank;
-  });
-}
-
-function fromHtml({ source, rel }) {
-  const out = [];
-  const cleaned = stripEmbedded(source);
-  // stripEmbedded preserves every newline, so one offset table serves both strings.
-  const starts = lineIndex(cleaned);
-  let m;
-
-  // 1. text nodes: everything between a '>' and the next '<'.
-  const textRe = />([^<>]+)</g;
-  while ((m = textRe.exec(cleaned)) !== null) {
-    if (!looksLikeCopy(m[1])) continue;
-    // The captured group opens one character past the '>' that anchored the match.
-    out.push({ text: m[1].replace(/\s+/g, ' ').trim(), file: rel, line: lineAt(starts, m.index), origin: 'html-text', confidence: 'certain', ...trimmedSpan(m[1], m.index + 1) });
-  }
-
-  // 2. copy-bearing attributes.
-  for (const { attr, re } of COPY_ATTR_RES) {
-    re.lastIndex = 0;
-    while ((m = re.exec(cleaned)) !== null) {
-      if (!looksLikeCopy(m[1])) continue;
-      // Every COPY_ATTR_RE ends with the closing quote, so the group's last
-      // character sits exactly one before the match's end. DERIVED, never
-      // searched for — indexOf would land on an earlier copy of the same text.
-      const attrStart = m.index + m[0].length - 1 - m[1].length;
-      out.push({ text: m[1].replace(/\s+/g, ' ').trim(), file: rel, line: lineAt(starts, m.index), origin: `html-attr:${attr}`, confidence: 'certain', ...trimmedSpan(m[1], attrStart) });
-    }
-  }
-
-  // 3. <title> is the page's own name — always copy.
-  const titleRe = /<title>([^<]{2,200})<\/title>/gi;
-  while ((m = titleRe.exec(cleaned)) !== null) {
-    const titleStart = m.index + '<title>'.length;
-    out.push({ text: m[1].replace(/\s+/g, ' ').trim(), file: rel, line: lineAt(starts, m.index), origin: 'html-title', confidence: 'certain', ...trimmedSpan(m[1], titleStart) });
-  }
-  return out;
-}
-
-// JS copy is found by FOLLOWING RENDER PATHS, not by guessing at prose. The first
-// cut of this file filtered "literals that look like sentences" and produced 2144
-// rows of which most were code: `use strict` 34 times, CSS values, and fragments of
-// template literals sliced at their quotes. Precision beats recall for a queue an
-// artist actually reads, so this extractor only claims a string when it can name
-// HOW a person sees it:
-//
-//   • markup built in JS — any literal containing tags is parsed as HTML, so the
-//     TEXT inside it is captured (not the tags). Template interpolations become a
-//     `{…}` placeholder, which keeps a sentence readable while marking the hole.
-//   • toast() / alert() / confirm() arguments — shown verbatim to a person.
-//   • .textContent / .innerText / .title assignments — same.
-//
-// Everything else is skipped, and the report says so. A literal this tool cannot
-// tie to a render path is not evidence of copy.
-const PLACEHOLDER = '{…}';
-
-// Template literals + quoted strings. Template bodies may contain ${...}; the
-// no-nested-backtick limitation is real and recorded in BLIND_SPOTS.
-const JS_LITERALS = /`([^`]*)`|'((?:[^'\\\n]|\\.)*)'|"((?:[^"\\\n]|\\.)*)"/g;
-const UI_CALL = /\b(?:toast|alert|confirm)\s*\(\s*(?:`([^`]*)`|'((?:[^'\\\n]|\\.)*)'|"((?:[^"\\\n]|\\.)*)")/g;
-const TEXT_ASSIGN = /\.(?:textContent|innerText|title)\s*=\s*(?:`([^`]*)`|'((?:[^'\\\n]|\\.)*)'|"((?:[^"\\\n]|\\.)*)")/g;
-
-function unescapeLiteral(raw) {
-  return String(raw).replace(/\\(['"`\\])/g, '$1');
-}
-
-// Can offsets into this match's BODY be read as offsets into the file?
-//
-// A template literal (group 1) is used raw, so yes. A quoted literal is
-// `unescapeLiteral`d first, and that SHIFTS every character after a backslash —
-// so yes only when the unescape changed nothing. The alternative, an
-// escape-aware index map, would buy spans for a handful of quoted-markup rows
-// and add a second place for the escaping rules to be wrong. A row with no span
-// is refused BY NAME in copy-apply.js instead, which is the honest trade.
-function literalIsUnshifted(m) {
-  if (m[1] !== undefined) return true;
-  const raw = m[2] ?? m[3];
-  return raw === undefined ? false : unescapeLiteral(raw) === raw;
-}
-
-// Interpolations are replaced by a fixed-width PLACEHOLDER before matching, so a
-// position in the holed string is NOT a position in the source. This records the
-// literal runs between the holes so one can be converted back to the other —
-// which is what lets a markup row carry a source span (see `trimmedSpan`).
-//
-// The conversion is only ever asked for at a capture BOUNDARY, and every boundary
-// sits on a real character: a text node's group opens just past a '>' and closes
-// just before a '<', and neither can appear inside `{…}`. A boundary that lands
-// where a hole meets the next run resolves to the character after the closing
-// '}' of the interpolation, which is the right place to cut.
-function holeMap(body) {
-  const re = /\$\{[^{}]*\}/g;
-  const runs = [];
-  let withHoles = '';
-  let last = 0;
-  let m;
-  while ((m = re.exec(body)) !== null) {
-    const literal = body.slice(last, m.index);
-    runs.push({ holed: withHoles.length, raw: last, length: literal.length });
-    withHoles += literal + PLACEHOLDER;
-    last = m.index + m[0].length;
-  }
-  const tail = body.slice(last);
-  runs.push({ holed: withHoles.length, raw: last, length: tail.length });
-  return { withHoles: withHoles + tail, runs };
-}
-
-function holedToRaw(runs, at) {
-  for (const run of runs) {
-    if (at >= run.holed && at <= run.holed + run.length) return run.raw + (at - run.holed);
-  }
-  return null; // only reachable for a position strictly inside a placeholder
-}
-
-// A literal that carries markup: extract what a person reads out of it, each row
-// carrying [start, end) offsets into the RAW body it was found in.
-function copyFromMarkupLiteral(body) {
-  const { withHoles, runs } = holeMap(body);
-  const out = [];
-  const emit = (group, groupStart) => {
-    const t = group.replace(/\s+/g, ' ').trim();
-    if (t === PLACEHOLDER || !looksLikeCopy(t.replace(/\{…\}/g, 'x'))) return;
-    const span = trimmedSpan(group, groupStart);
-    const start = holedToRaw(runs, span.start);
-    const end = holedToRaw(runs, span.end);
-    // A span that cannot be mapped back is reported as text with no span rather
-    // than as a guess; the applier refuses such a row by name.
-    out.push(start === null || end === null ? { text: t } : { text: t, start, end });
-  };
-  let m;
-  const textRe = />([^<>]+)</g;
-  while ((m = textRe.exec(withHoles)) !== null) emit(m[1], m.index + 1);
-  for (const { re } of COPY_ATTR_RES) {
-    re.lastIndex = 0;
-    while ((m = re.exec(withHoles)) !== null) emit(m[1], m.index + m[0].length - 1 - m[1].length);
-  }
-  return out;
-}
-
-function fromJs({ source, rel }) {
-  const out = [];
-  const starts = lineIndex(source);
-  const seen = new Set(); // (text, line) — one row per string per site
-  const push = (text, index, origin, span = null) => {
-    const line = lineAt(starts, index);
-    const key = `${text}\u0000${line}\u0000${origin}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    out.push({ text, file: rel, line, origin, confidence: 'certain', ...(span || {}) });
-  };
-
-  let m;
-  // 1. markup built in JS.
-  JS_LITERALS.lastIndex = 0;
-  while ((m = JS_LITERALS.exec(source)) !== null) {
-    const body = m[1] ?? unescapeLiteral(m[2] ?? m[3] ?? '');
-    if (!body || !/<[a-zA-Z/]/.test(body) || !/>/.test(body)) continue;
-    // Each alternative opens with exactly one delimiter, so the body starts one
-    // character past the match.
-    const mapped = literalIsUnshifted(m);
-    for (const f of copyFromMarkupLiteral(body)) {
-      const span = mapped && f.start !== undefined
-        ? { start: m.index + 1 + f.start, end: m.index + 1 + f.end }
-        : null;
-      push(f.text, m.index, 'js-markup', span);
-    }
-  }
-  // 2. strings shown directly to a person. Both of these normalize the WHOLE
-  // literal into the row's text, so the span is the whole body: the delimiter
-  // closes the match, so the body ends one character before the match does.
-  const wholeLiteral = (re, origin) => {
-    re.lastIndex = 0;
-    while ((m = re.exec(source)) !== null) {
-      const rawBody = m[1] ?? m[2] ?? m[3] ?? '';
-      const body = (m[1] ?? unescapeLiteral(m[2] ?? m[3] ?? '')).replace(/\$\{[^{}]*\}/g, PLACEHOLDER).replace(/\s+/g, ' ').trim();
-      if (!body || !looksLikeCopy(body.replace(/\{…\}/g, 'x'))) continue;
-      const bodyStart = m.index + m[0].length - 1 - rawBody.length;
-      push(body, m.index, origin, literalIsUnshifted(m) ? trimmedSpan(rawBody, bodyStart) : null);
-    }
-  };
-  wholeLiteral(UI_CALL, 'js-notice');
-  wholeLiteral(TEXT_ASSIGN, 'js-text-assign');
-  return out;
-}
-
-function filesFor(surface, { fsImpl = fs } = {}) {
-  const abs = path.join(REPO_ROOT, surface.at);
-  if (surface.kind === 'file') return fsImpl.existsSync(abs) ? [surface.at] : [];
-  if (!fsImpl.existsSync(abs)) return [];
-  return fsImpl.readdirSync(abs)
-    .filter((n) => surface.exts.includes(path.extname(n)))
-    .sort()
-    .map((n) => `${surface.at}/${n}`);
-}
-
-function buildRegistry() {
-  const entries = [];
-  const surfaces = {};
-  for (const surface of SURFACES) {
-    const rels = filesFor(surface);
-    let count = 0;
-    for (const rel of rels) {
-      const source = fs.readFileSync(path.join(REPO_ROOT, rel), 'utf8');
-      const found = path.extname(rel) === '.html'
-        ? fromHtml({ source, rel })
-        : fromJs({ source, rel });
-      for (const f of found) {
-        // THE SPAN IS DROPPED HERE, DELIBERATELY. Every extractor records where a
-        // string physically sits (see `trimmedSpan`), and none of it is committed:
-        // an offset goes stale the moment anything above it in the file changes,
-        // so a registry carrying one would be wrong far more often than the id —
-        // which is designed to survive exactly that movement — ever is. The span
-        // is recomputed from the tree by the applier, at the moment it edits.
-        const { start, end, ...row } = f;
-        entries.push({ id: stableId(surface.id, f.text), surface: surface.id, ...row });
-        count += 1;
-      }
-    }
-    surfaces[surface.id] = { at: surface.at, files: rels.length, strings: count };
-  }
-
-  // Deterministic order, independent of walk order: surface, text, file, line.
-  // BYTE ORDER, NOT localeCompare: these artifacts are committed, and
-  // localeCompare's collation depends on the runtime's ICU data — a Node built with
-  // small-icu would reshuffle the file and every unrelated commit would carry the
-  // churn. `cmp` is boring on purpose.
-  entries.sort((a, b) => cmp(a.surface, b.surface)
-    || cmp(a.text, b.text)
-    || cmp(a.file, b.file)
-    || a.line - b.line);
-
-  // Duplicate copy is the cheapest of the three signals R02 wants, and needs no
-  // judgement: the same normalized text in one surface, shown in more than one place.
-  const byId = new Map();
-  for (const e of entries) {
-    if (!byId.has(e.id)) byId.set(e.id, []);
-    byId.get(e.id).push(e);
-  }
-  const duplicates = [...byId.entries()]
-    .filter(([, list]) => list.length > 1)
-    .map(([id, list]) => ({
-      id, surface: list[0].surface, text: list[0].text,
-      occurrences: list.length, at: list.map((e) => `${e.file}:${e.line}`),
-    }))
-    .sort((a, b) => b.occurrences - a.occurrences || cmp(a.text, b.text));
-
-  return {
-    schema: 1,
-    generator: 'scripts/gds/copy-inventory.js',
-    goal: 1000074,
-    counts: {
-      strings: entries.length,
-      unique_ids: byId.size,
-      certain: entries.filter((e) => e.confidence === 'certain').length,
-      heuristic: entries.filter((e) => e.confidence === 'heuristic').length,
-      duplicate_ids: duplicates.length,
-    },
-    surfaces,
-    blind_spots: BLIND_SPOTS,
-    duplicates,
-    entries,
-  };
-}
-
-function renderReport(reg) {
-  const L = [];
-  const esc = (s) => s.replace(/\|/g, '\\|');
-  L.push('# Copy inventory — every string the product shows a person');
-  L.push('');
-  L.push('> **Generated** by `node scripts/gds/copy-inventory.js` (R01 of goal 1000074, the artist\'s loop).');
-  L.push('> Deterministic on a given tree — regenerate and commit rather than hand-editing.');
-  L.push('> Machine-readable twin: [`copy-registry.json`](copy-registry.json).');
-  L.push('');
-  L.push(`**${reg.counts.strings} strings** across ${Object.keys(reg.surfaces).length} surfaces · `
-    + `${reg.counts.unique_ids} distinct pieces of copy · ${reg.counts.certain} certain, ${reg.counts.heuristic} heuristic · `
-    + `${reg.counts.duplicate_ids} shown in more than one place.`);
-  L.push('');
-  L.push('## Surfaces');
-  L.push('');
-  L.push('| surface | lives at | files | strings |');
-  L.push('|---|---|---|---|');
-  for (const [id, s] of Object.entries(reg.surfaces)) {
-    L.push(`| \`${id}\` | \`${s.at}\` | ${s.files} | ${s.strings} |`);
-  }
-  L.push('');
-  L.push('## Confidence, and why it is on every row');
-  L.push('');
-  L.push('`certain` copy comes from markup only a person reads: an HTML text node, a `<title>`, or a copy-bearing attribute. `heuristic` copy is a JavaScript string literal that passed a prose filter — this tool does not parse JS, so a filtered literal is evidence, not proof. Treat a heuristic row as a candidate an artist confirms, and do not quote the total as "the number of strings in the product".');
-  L.push('');
-  L.push('## What this cannot see');
-  L.push('');
-  for (const b of reg.blind_spots) L.push(`- ${b}`);
-  L.push('');
-  if (reg.duplicates.length) {
-    L.push('## The same words, shown twice');
-    L.push('');
-    L.push('Identical copy within one surface. Sometimes right (a repeated button), sometimes two screens that should share one string.');
-    L.push('');
-    L.push('| id | shown | text | where |');
-    L.push('|---|---|---|---|');
-    for (const d of reg.duplicates.slice(0, 40)) {
-      L.push(`| \`${d.id}\` | ${d.occurrences}x | ${esc(d.text).slice(0, 90)} | ${d.at.slice(0, 3).join(', ')} |`);
-    }
-    if (reg.duplicates.length > 40) L.push(`| … | | _${reg.duplicates.length - 40} more in the JSON registry_ | |`);
-    L.push('');
-  }
-  for (const [surfaceId] of Object.entries(reg.surfaces)) {
-    const rows = reg.entries.filter((e) => e.surface === surfaceId);
-    if (!rows.length) continue;
-    L.push(`## \`${surfaceId}\` — ${rows.length} strings`);
-    L.push('');
-    L.push('| id | conf | text | where |');
-    L.push('|---|---|---|---|');
-    for (const e of rows) {
-      L.push(`| \`${e.id}\` | ${e.confidence === 'certain' ? 'certain' : 'heur'} | ${esc(e.text).slice(0, 110)} | \`${e.file}:${e.line}\` |`);
-    }
-    L.push('');
-  }
-  L.push('---');
-  L.push('');
-  L.push('Ids are stable across moves: a string keeps its id when it changes file or line, and loses it when its TEXT changes — which is exactly when a flag against it should be re-examined.');
-  L.push('');
-  return L.join('\n');
-}
-
-// Is the artifact on disk still what the generator would write? Freshness is a
-// question about CONTENT, so CRLF-vs-LF is not a difference — the eol-blind compare
-// is gen-freshness.sameContent, shared with the other six generators, and its header
-// carries the full why (task 1003619 hit it here: a Windows checkout reads back the
-// CRLF git wrote, so a byte compare reported STALE forever on content that was
-// byte-identical in the index — a permanently red gate teaches builders to wave past
-// the one check that catches a REAL stale artifact). Only \r\n is folded, NOT a lone
-// \r, so a genuinely corrupt file cannot read as fresh.
-//
-// The one thing that is local, and the reason this wrapper exists rather than a bare
-// sameContent() at the call site: a MISSING file is stale by definition. sameContent
-// would coerce a null `have` to '' and call it fresh against an empty `want`.
-// Not used on the write path — generated files are still written with LF endings.
-// Pure + exported so the decision is unit-testable without writing to the committed
-// artifacts (same shape as shouldRefuseSessionClaim in modules/lifecycle/routes/claims.js).
-function matchesGenerated(have, want) {
-  if (have === null || have === undefined) return false;
-  return sameContent(have, want);
-}
-
-function write({ check = false } = {}) {
-  const reg = buildRegistry();
-  const json = `${JSON.stringify(reg, null, 2)}\n`;
-  const md = renderReport(reg);
-  const jsonPath = path.join(REPO_ROOT, REGISTRY_REL);
-  const mdPath = path.join(REPO_ROOT, REPORT_REL);
-  if (check) {
-    const stale = [];
-    for (const [p, want] of [[jsonPath, json], [mdPath, md]]) {
-      const have = fs.existsSync(p) ? fs.readFileSync(p, 'utf8') : null;
-      if (!matchesGenerated(have, want)) stale.push(path.relative(REPO_ROOT, p));
-    }
-    return { reg, stale };
-  }
-  fs.writeFileSync(jsonPath, json);
-  fs.writeFileSync(mdPath, md);
-  return { reg, written: [REGISTRY_REL, REPORT_REL] };
-}
-
-if (require.main === module) {
-  const args = process.argv.slice(2);
-  if (args.includes('--json')) {
-    process.stdout.write(`${JSON.stringify(buildRegistry(), null, 2)}\n`);
-  } else if (args.includes('--check')) {
-    const { stale } = write({ check: true });
-    if (stale.length) {
-      console.error(`copy-inventory: STALE — ${stale.join(', ')} do not match the tree. Run: node scripts/gds/copy-inventory.js`);
-      process.exit(1);
-    }
-    console.log('copy-inventory: artifacts match the tree.');
-  } else {
-    const { reg, written } = write();
-    console.log(`copy-inventory: ${reg.counts.strings} strings (${reg.counts.certain} certain, ${reg.counts.heuristic} heuristic), `
-      + `${reg.counts.duplicate_ids} duplicated -> wrote ${written.join(', ')}`);
-  }
-}
-
-module.exports = {
-  SURFACES, COPY_ATTRS, BLIND_SPOTS, MAX_COPY_LEN, REGISTRY_REL, REPORT_REL,
-  cmp, stableId, looksLikeCopy, lineIndex, lineAt, stripEmbedded, fromHtml, fromJs, filesFor,
-  buildRegistry, renderReport, write, matchesGenerated,
-};
+require('../bongos/forwarder.js').forward(module, 'copy-inventory.js');