@bongos/core 1.21.176 → 1.21.177

package/scripts/bongos/artifact-staleness.js

@@ -1,267 +0,0 @@
-#!/usr/bin/env node
-// scripts/bongos/artifact-staleness.js — are the gitignored generated artifacts on
-// THIS machine actually current with the commit it has checked out? (task 1001930,
-// ADR 0110 pt.5)
-//
-// WHY THIS EXISTS. ADR 0110 moved `docs/repo-map.md` and `docs/session-log-index.md`
-// off the git graph: they are 100%-generated, two parallel branches collided on them
-// constantly, so they became untracked files regenerated at deploy. That trade was
-// deliberate, and the ADR names the debt it took on in its own Consequences:
-//
-//   "A generator that breaks at deploy leaves a stale/absent file with no blocking
-//    backstop; the LOUD ::ERROR:: line is the alarm (mandatory, not optional)."
-//
-// That alarm is a line in the droplet's journald. Nobody reads journald. The per-PR
-// freshness gate cannot help either — the files are gitignored, so they never appear
-// in a diff for CI to check (`--check-whole`'s own comment says it plainly: "used by
-// nothing hard; deploy owns it"). So if the deploy regen step silently stops running,
-// every agent keeps reading a symbol map of a codebase that has moved on, and nothing
-// anywhere says so. This check is the backstop that posture depends on.
-//
-// WHAT IT COMPARES. For each registered artifact, its own generator's `--check-whole`
-// answers "would regenerating this file change it?" — run against the checkout that is
-// actually serving. A difference means the deploy generator did not run, or ran and
-// broke. Asking the generator rather than reimplementing the comparison is the point:
-// there is exactly one definition of "fresh" per artifact and it lives with the thing
-// that writes it, so this check cannot drift away from what deploy produces.
-//
-// ABSENT AND STALE ARE REPORTED SEPARATELY, and the split is operational, not cosmetic:
-// absent means the regen step never ran here at all (a deploy line was dropped, or a
-// fresh clone was never generated into), stale means it ran once and has not since.
-// Those send someone to two different places, so the report must not blur them.
-//
-// ── WHERE THIS MAY RUN — read before scheduling it anywhere new ───────────────
-//
-// ONLY where the artifacts are SUPPOSED to already exist: a deployed instance after its
-// source-fetch regen. NEVER in CI. A fresh `git clone` legitimately
-// has no `docs/repo-map.md` — it is gitignored, so it is not in the repository at all
-// — and this check would report it absent on every single run. A monitor that is red
-// every run teaches its reader to ignore it, which is the exact failure ADR 0110's
-// warn-only posture already has. That is why this ships as a scheduled routine on the
-// instance and NOT as a `.github/workflows/` job, unlike its sibling publish-watch.js
-// (which reads git and the registry, and so is true anywhere).
-//
-// THE MAIN GUARD. "Fresh" here means "matches what THIS commit generates". On a
-// deployed instance that commit is main, because deploy does `git reset --hard
-// origin/main` — so the question the caller actually wants ("does the served artifact
-// lag main's HEAD?") and the question `--check-whole` answers are the same question.
-// In a feature worktree they are NOT: the artifact would be compared against that
-// branch, and a pass or a fail would both be meaningless. So a checkout that is not at
-// origin/main is INCONCLUSIVE (exit 2), never a finding — a monitor that cannot tell
-// which question it just answered must say so rather than guess.
-'use strict';
-
-const { spawnSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..');
-const GIT_TIMEOUT_MS = 15000;
-const CHECK_TIMEOUT_MS = 120000;
-
-// The gitignored, whole-file generated artifacts this check covers.
-//
-// MEMBERSHIP RULE — an artifact belongs here when all three hold: it is gitignored (so
-// no PR gate can see it), it is written by a deploy-time generator (so it can silently
-// stop being written), and its generator exposes `--check-whole` (so freshness has one
-// definition, owned by the writer). tests/artifact_staleness.mjs pins this list against
-// .gitignore and against the generators' real flags, so an artifact that gains a
-// `--check-whole` and is left out of here fails that test rather than going unwatched.
-//
-// DELIBERATELY NOT HERE, and each for a reason that is not "we forgot":
-//   • modules/hall-ui/public/atlas.json (gen-atlas.js, ADR 0094) — gitignored and
-//     deploy-generated, but its payload embeds `generatedAt: new Date()`, so a
-//     regenerate-and-compare differs on every run by construction. Checking it needs a
-//     comparison over `views` only, or a freshness-by-age test against the last deploy
-//     — a different mechanism, not this one. gen-atlas has no --check mode at all today.
-//   • docs/onboarding/diagrams/*.svg|png — rendering them needs a headless Chromium the
-//     droplet does not have (the reason ADR 0110 deferred the diagram half in the first
-//     place), so freshness cannot be evaluated where this runs. Their FACTS are already
-//     backstopped by the diagram-drift routine, which reads assertions.json instead.
-const ARTIFACTS = Object.freeze([
-  Object.freeze({
-    rel: 'docs/repo-map.md',
-    generator: 'gen-repo-map.js',
-    what: 'the symbol skeleton agents navigate the codebase by (ADR 0063)',
-  }),
-  Object.freeze({
-    rel: 'docs/session-log-index.md',
-    generator: 'gen-session-index.js',
-    what: 'the full session-log index the CLAUDE.md §13 snippet links out to (ADR 0062 §8)',
-  }),
-]);
-
-function git(args, run = spawnSync) {
-  const raw = gitRaw(args, run);
-  return raw === null ? null : raw.trim();
-}
-
-// Untrimmed, because `git status --porcelain` is column-significant: a line is
-// `XY<space>PATH` and an unstaged modification's X is a SPACE (" M path"). Trimming the
-// buffer eats that leading space on the FIRST line only, so a slice(3) then swallows the
-// path's first character — which is exactly how this printed "cripts/gds/…" until
-// tests/artifact_staleness.mjs caught it.
-function gitRaw(args, run = spawnSync) {
-  const r = run('git', args, { cwd: REPO_ROOT, encoding: 'utf8', timeout: GIT_TIMEOUT_MS });
-  if (!r || r.error || r.status !== 0) return null;
-  return String(r.stdout || '');
-}
-
-// The paths in a porcelain listing, status columns removed.
-function porcelainPaths(raw) {
-  return raw.split('\n').filter((l) => l.length > 3).map((l) => l.slice(3).trim()).filter(Boolean);
-}
-
-// Is this checkout a fair thing to compare the artifacts against — at origin/main AND
-// clean? Returns { ok } or { ok:false, reason }; git being unable to answer is equally
-// inconclusive.
-//
-// The CLEAN half is not belt-and-braces, and it was found by running this check against
-// its own uncommitted source file: a generator regenerates from the WORKING TREE, so one
-// uncommitted file that moves a symbol makes repo-map.md "stale" against a main it in
-// fact matches. On the droplet the tree is clean by construction (deploy does
-// `git reset --hard`), so requiring it costs a correct run nothing — while without it
-// every hand-run from a working checkout invents a finding, which is precisely how a
-// monitor teaches its reader to ignore it. Gitignored files (the artifacts themselves)
-// never appear in `--porcelain`, so they cannot trip this.
-function atMain(run = spawnSync) {
-  const head = git(['rev-parse', 'HEAD'], run);
-  const main = git(['rev-parse', 'origin/main'], run);
-  if (!head) return { ok: false, reason: 'could not read HEAD (not a git checkout?)' };
-  if (!main) return { ok: false, reason: 'could not read origin/main (no remote ref here?)' };
-  if (head !== main) {
-    const branch = git(['rev-parse', '--abbrev-ref', 'HEAD'], run) || '(detached)';
-    return { ok: false, reason: `checkout is at ${branch} ${head.slice(0, 8)}, not origin/main ${main.slice(0, 8)}` };
-  }
-  const dirty = gitRaw(['status', '--porcelain'], run);
-  if (dirty === null) return { ok: false, reason: 'could not read the working tree state' };
-  const paths = porcelainPaths(dirty);
-  if (paths.length) {
-    const shown = paths.slice(0, 3).join(', ');
-    const more = paths.length > 3 ? `, +${paths.length - 3} more` : '';
-    return { ok: false, reason: `working tree is not clean (${shown}${more}) — the generators would compare against those edits, not main` };
-  }
-  return { ok: true, sha: head };
-}
-
-// Ask ONE artifact's own generator whether it is current.
-//   fresh    exit 0 — regenerating would change nothing
-//   stale    exit 2 — it would (absent counts as stale; `present` says which)
-//   unknown  anything else — the generator itself could not answer, which is not a
-//            finding about the artifact and must never be reported as one.
-function checkArtifact(a, { root = REPO_ROOT, run = spawnSync, exists = fs.existsSync } = {}) {
-  const present = exists(path.join(root, a.rel));
-  const r = run(process.execPath, [path.join(root, 'scripts', 'bongos', a.generator), '--check-whole'],
-    { cwd: root, encoding: 'utf8', timeout: CHECK_TIMEOUT_MS });
-  if (!r || r.error) {
-    return { ...a, state: 'unknown', present, detail: r && r.error ? r.error.message : 'generator did not run' };
-  }
-  if (r.status === 0) return { ...a, state: 'fresh', present };
-  if (r.status === 2) return { ...a, state: present ? 'stale' : 'absent', present };
-  const said = String(r.stderr || r.stdout || '').trim().split('\n').pop() || `exit ${r.status}`;
-  return { ...a, state: 'unknown', present, detail: said };
-}
-
-function check({ root = REPO_ROOT, run = spawnSync, exists = fs.existsSync, artifacts = ARTIFACTS, requireMain = true } = {}) {
-  if (requireMain) {
-    const m = atMain(run);
-    if (!m.ok) { const e = new Error(m.reason); e.inconclusive = true; throw e; }
-  }
-  const results = artifacts.map((a) => checkArtifact(a, { root, run, exists }));
-  return {
-    results,
-    fresh: results.filter((r) => r.state === 'fresh'),
-    stale: results.filter((r) => r.state === 'stale'),
-    absent: results.filter((r) => r.state === 'absent'),
-    unknown: results.filter((r) => r.state === 'unknown'),
-  };
-}
-
-// Plain language: this lands in Discord #ship-news, where the audience is the owner,
-// not whoever wrote the generator.
-function report(r) {
-  const bad = [...r.absent, ...r.stale];
-  if (!bad.length && !r.unknown.length) {
-    return `Generated navigation docs are current — ${r.fresh.length} artifact(s) match this commit.`;
-  }
-  const lines = [];
-  if (bad.length) {
-    lines.push(`⚠ ${bad.length} generated file(s) on this instance no longer match the code being served.`);
-    lines.push('');
-    for (const a of r.absent) lines.push(`  • ${a.rel} — MISSING entirely. Nothing has generated it here. It is ${a.what}.`);
-    for (const a of r.stale) lines.push(`  • ${a.rel} — out of date: it no longer matches what this commit would produce. It is ${a.what}.`);
-    lines.push('');
-    lines.push('These are rebuilt by the deploy step, so this means that step stopped running or broke.');
-    lines.push('Nothing blocks on them, which is why it went unreported until now — anyone reading these');
-    lines.push('files is being given an out-of-date picture. Check the deploy log for its regen lines');
-    lines.push('(they print ::ERROR:: when a generator fails).');
-  }
-  if (r.unknown.length) {
-    if (bad.length) lines.push('');
-    lines.push(`Could not check ${r.unknown.length} artifact(s):`);
-    for (const a of r.unknown) lines.push(`  • ${a.rel} — ${a.detail}`);
-  }
-  return lines.join('\n');
-}
-
-// Deliver the finding here rather than through run-routine.js's `sink: discord`.
-// run-routine treats a non-zero step as a FAILED step and aborts BEFORE it routes
-// stdout, so exiting 1 on a finding would throw that finding away. publish-watch.js
-// and artifact-audit.js carry the same shape for the same reason; their routine steps
-// all stay `sink: none` and the script performs its own side effect.
-async function deliver(text) {
-  const { postWebhook } = require(path.join(__dirname, '..', 'discord', 'lib.js'));
-  await postWebhook('ship_news', text);
-}
-
-async function main() {
-  const argv = process.argv.slice(2);
-  const json = argv.includes('--json');
-
-  let r;
-  try {
-    r = check({ requireMain: !argv.includes('--any-ref') });
-  } catch (err) {
-    // Exit 2 = COULD NOT RUN, kept distinct from 1 (ran, found something) so a
-    // scheduler can go red on the former and merely report the latter.
-    console.error(`artifact-staleness could not complete: ${err && err.message ? err.message : err}`);
-    if (err && err.inconclusive) {
-      console.error('  Freshness is only meaningful against the commit being served. Re-run on the');
-      console.error('  deployed instance, or pass --any-ref to compare against whatever is checked out.');
-    }
-    process.exit(2);
-  }
-
-  const text = report(r);
-  const found = r.stale.length + r.absent.length;
-
-  if (json) { console.log(JSON.stringify(r, null, 2)); process.exit(found ? 1 : 0); }
-
-  // A healthy run is deliberately quiet — it tells a person who ran it by hand
-  // (stderr) and posts nothing. A daily "all fine" is how a channel becomes wallpaper.
-  if (!found) {
-    console.error(text);
-    // An artifact we could not check is not a finding, but it must not be silent
-    // either: a permanently-unknown artifact is unwatched without anyone deciding so.
-    process.exit(r.unknown.length ? 2 : 0);
-  }
-
-  console.log(text);
-  if (argv.includes('--no-post')) process.exit(1);
-
-  try {
-    await deliver(text);
-    console.error('posted the finding to Discord #ship-news.');
-    process.exit(1);
-  } catch (err) {
-    // Found something and could not say it — the original defect one layer down, so
-    // it is the LOUDEST outcome: exit 3 is >= 2, which turns the scheduled run red.
-    console.error(`\nFOUND STALE ARTIFACTS AND COULD NOT DELIVER THE FINDING: ${err && err.message ? err.message : err}`);
-    console.error('The finding is above. Set DISCORD_SHIP_NEWS_WEBHOOK so this reaches #ship-news.');
-    process.exit(3);
-  }
-}
-
-if (require.main === module) main();
-
-module.exports = { ARTIFACTS, atMain, checkArtifact, check, report };

package/scripts/bongos/classify-discipline.js

@@ -1,153 +0,0 @@
-#!/usr/bin/env node
-// classify-discipline — bulk-classify tasks.discipline via the heuristic
-// classifier in src/bongos/task-classifier.js.
-//
-// Usage:
-//   node scripts/bongos/classify-discipline.js [--commit] [--all] [--limit N]
-//
-// Default mode: dry-run. Walks every task whose discipline is currently
-// 'unclassified', runs classifyTaskDiscipline() over title + description +
-// touches, and prints a table of proposed classifications. Nothing is
-// written to the DB.
-//
-// With --commit: same walk, but PATCH /tasks/:id for every proposal that
-// came back as engineer, artist, or ideator. Tasks the classifier leaves as
-// 'unclassified' are skipped (left for hand-triage).
-//
-// With --all: include tasks that already have a non-unclassified
-// discipline. Useful for re-running after tweaking the classifier rules;
-// will overwrite existing classifications. NOT the default.
-//
-// Idempotent without --all: re-running after a successful --commit is a
-// no-op because every previously-classified row falls outside the filter.
-
-const { cliClient, requireSession } = require('./cli-lib');
-// task-classifier carved to modules/lifecycle/ (BV1.R86); a CLI may require a
-// module directly (outside the kernel boundary — the grading/economy precedent).
-const { classifyTaskDiscipline } = require('../../modules/lifecycle/task-classifier');
-
-function pad(s, n) {
-  s = String(s);
-  return s.length >= n ? s.slice(0, n) : s + ' '.repeat(n - s.length);
-}
-
-function emoji(d) {
-  if (d === 'artist') return '🎨';
-  if (d === 'ideator') return '💡';
-  if (d === 'engineer') return '🔧';
-  return '· ';
-}
-
-(async () => {
-  await requireSession();
-  const args = process.argv.slice(2);
-  const commit = args.includes('--commit');
-  const all = args.includes('--all');
-  const limitIdx = args.indexOf('--limit');
-  const limit = limitIdx >= 0 ? Number(args[limitIdx + 1]) : Infinity;
-
-  // Fetch tasks. Without --all we ask the API for only unclassified rows
-  // so we don't have to pull every shipped task to triage them later.
-  const api = await cliClient();
-  const r = await api.tasks.getTasks(all ? {} : { query: { discipline: 'unclassified' } });
-  if (!r.ok) {
-    console.error(`failed (${r.status}):`, r.data);
-    process.exit(1);
-  }
-  const rawTasks = (r.data?.tasks || []).slice(0, limit);
-  // Skip __smoke__ test debris — these aren't real work, classifying them
-  // would just pollute the discipline filter. Mig 005 already filters them
-  // from claimable_tasks / version_progress on the public side.
-  const smokeFiltered = rawTasks.filter((t) => /^__smoke__/.test(t.title || ''));
-  const tasks = rawTasks.filter((t) => !/^__smoke__/.test(t.title || ''));
-  if (tasks.length === 0) {
-    console.log('nothing to classify — every task already has a discipline.');
-    if (smokeFiltered.length) {
-      console.log(`(skipped ${smokeFiltered.length} __smoke__ debris rows)`);
-    }
-    return;
-  }
-
-  // Run classifier locally — no API round-trip per task.
-  const proposals = tasks.map((t) => {
-    const result = classifyTaskDiscipline(t.title, t.description, t.touches);
-    return { task: t, ...result };
-  });
-
-  // Print summary table grouped by discipline.
-  const buckets = {
-    engineer: proposals.filter((p) => p.discipline === 'engineer'),
-    artist: proposals.filter((p) => p.discipline === 'artist'),
-    ideator: proposals.filter((p) => p.discipline === 'ideator'),
-    unclassified: proposals.filter((p) => p.discipline === 'unclassified'),
-  };
-
-  console.log('');
-  console.log(`Proposed classifications across ${proposals.length} tasks:`);
-  console.log(`  ${emoji('engineer')} engineer      ${buckets.engineer.length}`);
-  console.log(`  ${emoji('artist')} artist        ${buckets.artist.length}`);
-  console.log(`  ${emoji('ideator')} ideator       ${buckets.ideator.length}`);
-  console.log(`  ${emoji('unclassified')} unclassified  ${buckets.unclassified.length} (will be skipped)`);
-  if (smokeFiltered.length) {
-    console.log(`  🧪 __smoke__     ${smokeFiltered.length} (filtered as test debris, not classified)`);
-  }
-  console.log('');
-
-  // Detail by bucket. Within each bucket: highest-confidence first so
-  // the strong signals are at the top — easy to spot the weakest.
-  for (const bucket of ['engineer', 'artist', 'ideator']) {
-    if (!buckets[bucket].length) continue;
-    console.log(`--- ${bucket} ---`);
-    const sorted = buckets[bucket].slice().sort((a, b) => b.confidence - a.confidence);
-    for (const p of sorted) {
-      const { task: t } = p;
-      const version = pad(`[${t.version_id || '?'}]`, 10);
-      const conf = `(${p.confidence.toFixed(2)})`;
-      const title = (t.title || '').slice(0, 80);
-      console.log(`  #${pad(t.id, 4)} ${conf}  ${version} ${title}`);
-    }
-    console.log('');
-  }
-
-  if (buckets.unclassified.length) {
-    console.log('--- unclassified (signals too weak / balanced) ---');
-    for (const p of buckets.unclassified.slice(0, 20)) {
-      const { task: t } = p;
-      const version = pad(`[${t.version_id || '?'}]`, 10);
-      const title = (t.title || '').slice(0, 80);
-      console.log(`  #${pad(t.id, 4)}         ${version} ${title}`);
-    }
-    if (buckets.unclassified.length > 20) {
-      console.log(`  ... ${buckets.unclassified.length - 20} more`);
-    }
-    console.log('');
-  }
-
-  if (!commit) {
-    console.log('Dry-run only. Re-run with --commit to write classifications via PATCH.');
-    return;
-  }
-
-  // Commit: PATCH each non-unclassified proposal.
-  const toWrite = [...buckets.engineer, ...buckets.artist, ...buckets.ideator];
-  console.log(`Committing ${toWrite.length} classifications...`);
-  let ok = 0;
-  let failed = 0;
-  for (const p of toWrite) {
-    const res = await api.tasks.patchTasksId({
-      id: p.task.id,
-      body: { discipline: p.discipline },
-    });
-    if (res.ok) {
-      ok++;
-    } else {
-      failed++;
-      console.error(`  PATCH #${p.task.id} failed (${res.status}):`, res.data?.error || res.data);
-    }
-  }
-  console.log('');
-  console.log(`Done. ${ok} updated, ${failed} failed.`);
-})().catch((err) => {
-  console.error('fatal:', err);
-  process.exit(1);
-});

package/scripts/bongos/codemod-rename-src-gds.js

@@ -1,145 +0,0 @@
-#!/usr/bin/env node
-// scripts/gds/codemod-rename-src-gds.js
-//
-// One-shot, auditable codemod for task 2004 (BV1.R124): rename the core source
-// directory src/gds/ -> src/bongos/ and rewrite EVERY in-repo reference to it.
-// Committed so the approach is reproducible and reviewable (task done-when).
-//
-// Deterministic by construction:
-//   1. `git mv src/gds src/bongos`  (idempotent -- skipped if already moved).
-//   2. Over every TRACKED text file, rewrite the literal path token `src/gds`
-//      -> `src/bongos`, guarded by a TRAILING boundary so look-alike tokens are
-//      never clobbered:
-//         src/gds/...     -> src/bongos/...     (directory refs)
-//         "src/gds"       -> "src/bongos"       (bare, at a boundary)
-//         src/gds-client  -> src/gds-client     (UNCHANGED: a look-alike file name)
-//         src/gdsx        -> src/gdsx           (UNCHANGED here: prefix-edge fixture)
-//
-//   Regex: /src\/gds(?![A-Za-z0-9_-])/g  -- trailing guard only. No LEADING guard:
-//   `scripts/gds` contains no `src/gds` substring, and the two real leading-glue
-//   sites (`keyed-to-src/gds` in an audit, `\tsrc/gds/auth.js` in a mirror-export
-//   fixture) are genuine directory refs we DO want rewritten.
-//
-// Excluded from the sweep (see EXCLUDE):
-//   - this script (its own source contains the search literal),
-//   - tests/path_match.mjs + tests/touches_overlap.mjs -- they assert the
-//     "src/gdsx must NOT match src/gds/" boundary edge; a mechanical half-rewrite
-//     (which leaves `src/gdsx` but changes `src/gds/`) would silently gut the
-//     test. Those two are hand-edited to src/bongos / src/bongosx so the edge
-//     stays meaningful.
-//
-// git ls-files is the file source, so gitignored generated docs
-// (docs/repo-map.md, docs/session-log-index.md) are excluded -- they regenerate.
-// Binary files are skipped via a NUL-byte sniff.
-//
-// Idempotent: a second run moves nothing and rewrites nothing (0 replacements).
-
-const { execSync } = require('node:child_process');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const REPO_ROOT = execSync('git rev-parse --show-toplevel').toString().trim();
-
-// (a) The slash form: `src/gds`, `src/gds/routes`, `"src/gds"` ... Trailing guard
-// only (see header) so `src/gds-client` and `src/gdsx` are left alone.
-const NEEDLE = /src\/gds(?![A-Za-z0-9_-])/g;
-const REPLACEMENT = 'src/bongos';
-
-// (b) The SPLIT-SEGMENT form: `path.join(root, 'src', 'gds', ...)` -- the segments
-// are separate string args, so there is no literal `src/gds` substring for (a) to
-// catch. Anchored on a PRECEDING quoted `'src'` segment so it rewrites only the
-// `'gds'` that follows `'src'` -- NEVER `'scripts', 'gds'` (scripts/gds is not
-// renamed). \s between segments tolerates a newline-split path.join. The `gds`
-// quote must close immediately, so `'gdsx'` / `'gds-client'` never match.
-const SEG = /(['"])src\1(\s*,\s*)(['"])gds\3/g;
-const segReplace = (s) => s.replace(SEG, (_m, q1, sep, q2) => `${q1}src${q1}${sep}${q2}bongos${q2}`);
-
-// (c) RELATIVE requires into the moved dir. A file DIRECTLY under src/ addresses
-// its former sibling as `require('./gds/x')` -- no `src/` prefix, so (a) misses it,
-// and after the move it dangles. `./gds` resolves to src/gds ONLY from a src-top-
-// level file; a `./gds` in scripts/* means scripts/gds (NOT renamed) and a deeper
-// src/**/* file resolves elsewhere -- so this pass is gated to `src/<file>` and
-// never fires elsewhere. (Verified: the only matches are src/module-api.js +
-// src/platform-server.js; no `../gds` relative forms exist.) `(?=\/|['"])` keeps
-// `./gds-client` / `./gdsx` safe.
-const isSrcTopLevel = (rel) => /^src\/[^/]+\.(?:js|mjs|cjs)$/.test(rel);
-const REL = /(\.\/)gds(?=\/|['"])/g;
-
-// (d) REGEX-ESCAPED slash form: `src\/gds` (backslash-slash) as written inside a
-// RegExp literal -- e.g. route-rank-check.js's ROUTE_FILE_RE and the tests that
-// match against it. `\/` is not the plain `/` (a) scans for, so (a) misses it.
-const ESC = /src\\\/gds(?![A-Za-z0-9_-])/g;
-
-// (e) WINDOWS double-backslash form: `src\\gds` in JS source (one backslash on
-// disk-per-escape, two chars) -- Windows-path fixtures the matchers normalize
-// (permission_path / publish_manifest). Trailing guard keeps `src\\gdsx` safe.
-const WIN = /src\\\\gds(?![A-Za-z0-9_-])/g;
-
-const EXCLUDE = new Set([
-  'scripts/gds/codemod-rename-src-gds.js',
-  'tests/path_match.mjs',
-  'tests/touches_overlap.mjs',
-]);
-
-function gitMv() {
-  const oldDir = path.join(REPO_ROOT, 'src', 'gds');
-  const newDir = path.join(REPO_ROOT, 'src', 'bongos');
-  if (fs.existsSync(newDir)) {
-    console.log('git mv: src/bongos already exists -- skipping move (idempotent).');
-    return;
-  }
-  if (!fs.existsSync(oldDir)) {
-    console.log('git mv: neither src/gds nor src/bongos present -- nothing to move.');
-    return;
-  }
-  execSync('git mv src/gds src/bongos', { cwd: REPO_ROOT, stdio: 'inherit' });
-  console.log('git mv: src/gds -> src/bongos');
-}
-
-function isBinary(buf) {
-  const n = Math.min(buf.length, 8192);
-  for (let i = 0; i < n; i++) if (buf[i] === 0) return true;
-  return false;
-}
-
-function main() {
-  gitMv();
-
-  const tracked = execSync('git ls-files', { cwd: REPO_ROOT, maxBuffer: 128 * 1024 * 1024 })
-    .toString().split('\n').filter(Boolean);
-
-  let filesChanged = 0;
-  let totalReplacements = 0;
-  const changed = [];
-
-  for (const rel of tracked) {
-    if (EXCLUDE.has(rel)) continue;
-    const abs = path.join(REPO_ROOT, rel);
-    let buf;
-    try { buf = fs.readFileSync(abs); } catch { continue; } // e.g. deleted-in-index
-    if (isBinary(buf)) continue;
-    const before = buf.toString('utf8');
-    const slashN = (before.match(NEEDLE) || []).length;
-    const segN = (before.match(SEG) || []).length;
-    const escN = (before.match(ESC) || []).length;
-    const winN = (before.match(WIN) || []).length;
-    const relN = isSrcTopLevel(rel) ? (before.match(REL) || []).length : 0;
-    if (slashN === 0 && segN === 0 && escN === 0 && winN === 0 && relN === 0) continue;
-    let after = segReplace(before.replace(NEEDLE, REPLACEMENT));
-    after = after.replace(ESC, 'src\\/bongos').replace(WIN, 'src\\\\bongos');
-    if (relN > 0) after = after.replace(REL, '$1bongos');
-    if (after === before) continue;
-    fs.writeFileSync(abs, after);
-    filesChanged++;
-    const n = slashN + segN + escN + winN + relN;
-    totalReplacements += n;
-    changed.push({ rel, n });
-  }
-
-  changed.sort((a, b) => b.n - a.n);
-  console.log(`\ncodemod: rewrote ${totalReplacements} reference(s) across ${filesChanged} file(s).`);
-  for (const c of changed) console.log(`  ${String(c.n).padStart(4)}  ${c.rel}`);
-  console.log('\nExcluded (hand-edited or self): ' + [...EXCLUDE].join(', '));
-}
-
-main();