@bongos/core 1.21.175 → 1.21.177

package/tests/unit_report_status.mjs

@@ -11,8 +11,8 @@
 import { strict as assert } from 'node:assert';
 import fs from 'node:fs';
 import { createRequire } from 'node:module';
-import { describeFailures, STATUS_DESCRIPTION_MAX } from '../scripts/gds/run-unit-tests.js';
-import { redPrLine } from '../scripts/gds/ship-land.js';
+import { describeFailures, STATUS_DESCRIPTION_MAX } from '../scripts/bongos/run-unit-tests.js';
+import { redPrLine } from '../scripts/bongos/ship-land.js';
 
 const require = createRequire(import.meta.url);
 const gh = require('../modules/lifecycle/github-push.js');

package/tests/unit_runner_serial.mjs

@@ -7,7 +7,7 @@
 // global state" and asked, correctly, whether run-unit-tests fans tests out
 // concurrently in one process. It does not: runOne calls execFileSync, which
 // BLOCKS, from plain sequential for-loops. That rules an in-process race out by
-// construction, and scripts/gds/run-unit-tests.js now records the audit that
+// construction, and scripts/bongos/run-unit-tests.js now records the audit that
 // followed from it — including that two of the three suites the report named
 // (fitness, session_index) mutate no global state at all.
 //
@@ -27,7 +27,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const RUNNER = path.join(ROOT, 'scripts', 'gds', 'run-unit-tests.js');
+const RUNNER = path.join(ROOT, 'scripts', 'bongos', 'run-unit-tests.js');
 const src = fs.readFileSync(RUNNER, 'utf8');
 
 let passed = 0;

package/tests/unit_runner_teardown_abort.mjs

@@ -20,7 +20,7 @@
 
 import assert from 'node:assert/strict';
 import { test } from 'node:test';
-import { isCleanTeardownAbort } from '../scripts/gds/run-unit-tests.js';
+import { isCleanTeardownAbort } from '../scripts/bongos/run-unit-tests.js';
 
 // Captured from a real aborted run of tests/provisioning_github_app_routes.mjs.
 const ABORT_76 = 'Assertion failed: !(handle->flags & UV_HANDLE_CLOSING), file src\\win\\async.c, line 76\r\n';

package/tests/update_channel.mjs

@@ -1,6 +1,6 @@
 // tests/update_channel.mjs
 //
-// task 2150 / ADR 0136 — the update-subscription policy core (scripts/gds/update-channel.js).
+// task 2150 / ADR 0136 — the update-subscription policy core (scripts/bongos/update-channel.js).
 // Pins the channel math + manifest loading the `core-update-subscription` routine relies on:
 //   1. semver — parse (incl. prerelease), compare precedence.
 //   2. channelAllows — the pinned/patch/minor blast-radius matrix; majors + prereleases never auto.
@@ -20,7 +20,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
 const require = createRequire(import.meta.url);
-const uc = require('../scripts/gds/update-channel.js');
+const uc = require('../scripts/bongos/update-channel.js');
 
 let passed = 0, failed = 0;
 function t(name, fn) {

package/tests/update_channel_db.mjs

@@ -17,7 +17,7 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const uc = require('../scripts/gds/update-channel.js');
+const uc = require('../scripts/bongos/update-channel.js');
 
 const AVAILABLE = ['1.20.36', '1.20.37', '1.21.0', '2.0.0'];
 const entry = (over = {}) => ({ slug: 'cloudbongos', dir: '/home/lars/cloudbongos', channel: 'patch', env: {}, ...over });
@@ -47,7 +47,7 @@ test('DB pinned: the sweep skips it even when the roster says minor', () => {
   assert.equal(inst.channel, 'pinned');
   assert.equal(targetFor(inst), null);
   // update-sweep.js skips on exactly this value, and decides it AFTER the DB rule is applied.
-  const src = readFileSync(path.join(ROOT, 'scripts/gds/update-sweep.js'), 'utf8');
+  const src = readFileSync(path.join(ROOT, 'scripts/bongos/update-sweep.js'), 'utf8');
   const applied = src.indexOf('channel.applyDbChannels(');
   const skip = src.indexOf("inst.channel === 'pinned'");
   assert.ok(applied > 0 && skip > applied, 'the pinned skip must read the channel after the /deploy rule is applied');
@@ -119,12 +119,12 @@ test('channelLine: the sweep log names the channel and where it came from', () =
     [entry(), entry({ slug: 'charter', channel: 'patch' })], dbOf({ cloudbongos: 'minor' }));
   assert.equal(uc.channelLine(fromDeploy), '  • cloudbongos: channel minor, set on /deploy (roster says patch, ignored)');
   assert.equal(uc.channelLine(fromRoster), '  • charter: channel patch, from the roster — no project row for this slug');
-  const src = readFileSync(path.join(ROOT, 'scripts/gds/update-sweep.js'), 'utf8');
+  const src = readFileSync(path.join(ROOT, 'scripts/bongos/update-sweep.js'), 'utf8');
   assert.match(src, /console\.log\(channel\.channelLine\(inst\)\)/);
 });
 
 test('update-sweep.js reads the DB from its own env, never an entry env (which names that instance\'s DB)', () => {
-  const src = readFileSync(path.join(ROOT, 'scripts/gds/update-sweep.js'), 'utf8');
+  const src = readFileSync(path.join(ROOT, 'scripts/bongos/update-sweep.js'), 'utf8');
   assert.match(src, /channel\.readDbChannels\(\{ env: process\.env \}\)/);
   // A core too old to carry the reader must keep the roster rather than crash the sweep.
   assert.match(src, /typeof channel\.readDbChannels === 'function'/);

package/tests/update_subscription_engine.mjs

@@ -75,9 +75,9 @@ function rosterDir(rows) {
 // ---------------------------------------------------------------------------
 
 test('GO_LIVE_REQUIRED mirrors go-live.js REQUIRED_FIELDS exactly', () => {
-  const src = readFileSync(path.join(ROOT, 'scripts', 'gds', 'go-live.js'), 'utf8');
+  const src = readFileSync(path.join(ROOT, 'scripts', 'bongos', 'go-live.js'), 'utf8');
   const m = src.match(/const REQUIRED_FIELDS = \[([^\]]*)\]/);
-  assert.ok(m, 'could not find REQUIRED_FIELDS in scripts/gds/go-live.js');
+  assert.ok(m, 'could not find REQUIRED_FIELDS in scripts/bongos/go-live.js');
   const required = m[1].split(',').map((x) => x.trim().replace(/^'|'$/g, '')).filter(Boolean);
 
   assert.deepEqual(
@@ -90,9 +90,9 @@ test('GO_LIVE_REQUIRED mirrors go-live.js REQUIRED_FIELDS exactly', () => {
 });
 
 test('go-live.js still accepts the pinMode the lane now sends', () => {
-  const src = readFileSync(path.join(ROOT, 'scripts', 'gds', 'go-live.js'), 'utf8');
+  const src = readFileSync(path.join(ROOT, 'scripts', 'bongos', 'go-live.js'), 'utf8');
   const m = src.match(/const OPTIONAL_FIELDS = \[([^\]]*)\]/);
-  assert.ok(m, 'could not find OPTIONAL_FIELDS in scripts/gds/go-live.js');
+  assert.ok(m, 'could not find OPTIONAL_FIELDS in scripts/bongos/go-live.js');
   // go-live reports UNKNOWN keys as errors rather than ignoring them, so sending a field
   // it does not list is a hard rejection of the whole target, not a no-op.
   assert.ok(m[1].includes("'pinMode'"), 'go-live no longer lists pinMode — the lane would now be sending an unknown field');
@@ -147,20 +147,20 @@ test('needsCoTenantMode: no deployTimer, or any pinMode', () => {
 // ---------------------------------------------------------------------------
 
 const probe = (source, opts) => S.resolveGoLive('/srv/demo', {
-  resolveFrom: () => '/srv/demo/node_modules/@bongos/core/scripts/gds/go-live.js',
+  resolveFrom: () => '/srv/demo/node_modules/@bongos/core/scripts/bongos/go-live.js',
   readFile: () => source,
   ...opts,
 });
 
 test('probe: a co-tenant target refuses a go-live.js without pinMode', () => {
-  assert.equal(probe(GO_LIVE_NEW, { needsCoTenant: true }), '/srv/demo/node_modules/@bongos/core/scripts/gds/go-live.js');
+  assert.equal(probe(GO_LIVE_NEW, { needsCoTenant: true }), '/srv/demo/node_modules/@bongos/core/scripts/bongos/go-live.js');
   assert.equal(probe(GO_LIVE_OLD, { needsCoTenant: true }), null, 'that go-live would reject the target on a validation error instead of falling back');
 });
 
 test('probe: an ORDINARY target still runs on a mid-generation core', () => {
   // The regression to avoid: probing for pinMode unconditionally would strip the
   // go-live path from every instance sitting between the two releases.
-  assert.equal(probe(GO_LIVE_OLD, { needsCoTenant: false }), '/srv/demo/node_modules/@bongos/core/scripts/gds/go-live.js');
+  assert.equal(probe(GO_LIVE_OLD, { needsCoTenant: false }), '/srv/demo/node_modules/@bongos/core/scripts/bongos/go-live.js');
   assert.equal(probe(GO_LIVE_ANCIENT, { needsCoTenant: false }), null, 'no --target-json: the pre-existing local-mode gate still holds');
   assert.equal(probe(GO_LIVE_ANCIENT, { needsCoTenant: true }), null);
 });
@@ -178,7 +178,7 @@ test('probe: an unreadable or unresolvable go-live falls back rather than throwi
 // ---------------------------------------------------------------------------
 
 const engine = (rows, inst, source) => S.goLiveEngineFor(inst, rosterDir(rows), {
-  resolveFrom: () => '/srv/demo/node_modules/@bongos/core/scripts/gds/go-live.js',
+  resolveFrom: () => '/srv/demo/node_modules/@bongos/core/scripts/bongos/go-live.js',
   readFile: () => source,
 });
 
@@ -254,9 +254,9 @@ test('pinModeOf REFUSES an unknown mode instead of defaulting', () => {
 });
 
 test('PIN_MODES mirrors go-live.js PIN_MODES exactly', () => {
-  const src = readFileSync(path.join(ROOT, 'scripts', 'gds', 'go-live.js'), 'utf8');
+  const src = readFileSync(path.join(ROOT, 'scripts', 'bongos', 'go-live.js'), 'utf8');
   const m = src.match(/const PIN_MODES = \[([^\]]*)\]/);
-  assert.ok(m, 'could not find PIN_MODES in scripts/gds/go-live.js');
+  assert.ok(m, 'could not find PIN_MODES in scripts/bongos/go-live.js');
   const theirs = m[1].split(',').map((x) => x.trim().replace(/^'|'$/g, '')).filter(Boolean);
   assert.deepEqual([...S.PIN_MODES].sort(), [...theirs].sort(),
     'the lane validates pinMode against its own copy of go-live\'s enum; they have drifted');
@@ -334,7 +334,7 @@ test('the heal branch is reachable only when the dirty files ARE the pin', () =>
 // ---------------------------------------------------------------------------
 
 test('every commitPin call site in the lane decides about push', () => {
-  const src = readFileSync(path.join(ROOT, 'scripts', 'gds', 'update-sweep.js'), 'utf8');
+  const src = readFileSync(path.join(ROOT, 'scripts', 'bongos', 'update-sweep.js'), 'utf8');
   // Every CALL, excluding the definition (which is `function commitPin({ ... push = true })` —
   // its default is what these sites must not silently inherit).
   const calls = [];
@@ -358,7 +358,7 @@ test('every commitPin call site in the lane decides about push', () => {
 });
 
 test('the direct-upgrade fallback asks pinFlagsFor rather than deciding inline', () => {
-  const src = readFileSync(path.join(ROOT, 'scripts', 'gds', 'update-sweep.js'), 'utf8');
+  const src = readFileSync(path.join(ROOT, 'scripts', 'bongos', 'update-sweep.js'), 'utf8');
   // The fourth version of this assertion. It used to pin the inline `if` verbatim, which froze
   // the bug of task 1004122 in place: the line was correct about NOT pushing a co-tenant pin and
   // wrong about how, and a test that quotes an expression can only ever confirm it is still there.
@@ -404,7 +404,7 @@ test('pinFlagsFor: an old core that lacks --pin-no-push gets NOTHING, never the
 test('pinFlagsFor mirrors go-live.js upgradeCommand() mode for mode', () => {
   // The cross-file contract, pinned at the source in the same way GO_LIVE_REQUIRED is: go-live
   // builds a command STRING on a box, so the two can only be compared through its source.
-  const src = readFileSync(path.join(ROOT, 'scripts', 'gds', 'go-live.js'), 'utf8');
+  const src = readFileSync(path.join(ROOT, 'scripts', 'bongos', 'go-live.js'), 'utf8');
   const body = src.slice(src.indexOf('function upgradeCommand('));
   const commitPinModes = /\.\.\.\(mode === 'leave-dirty' \? \[\] : \['--commit-pin'\]\)/.test(body);
   const noPushModes = /\.\.\.\(mode === 'push' \? \[\] : \['--pin-no-push'\]\)/.test(body);
@@ -503,8 +503,8 @@ test('both commitPin successes report committed:true', () => {
 function fakeCore({ api, willRewrite, upgradeThrows = false, materializeThrows = false, own = () => null } = {}) {
   const seen = [];
   const resolveFrom = (dir, rel) => {
-    if (rel === 'scripts/gds/upgrade.js' && api === null) return null;
-    if (rel === 'scripts/gds/claude-materialize.js' && willRewrite === null) return null;
+    if (rel === 'scripts/bongos/upgrade.js' && api === null) return null;
+    if (rel === 'scripts/bongos/claude-materialize.js' && willRewrite === null) return null;
     return path.join(dir, 'node_modules', '@bongos', 'core', rel);
   };
   const load = (p) => {
@@ -577,7 +577,7 @@ function oldCoreOnDisk(skills) {
 test('laneGeneratedPaths falls back to the sweep\'s own preview when the instance core predates it', () => {
   const dir = oldCoreOnDisk(['ask-for-help', 'blocker-review']);
   // The instance's core resolves claude-materialize.js but exports no materializeWillRewrite.
-  const core = fakeCore({ api: { g: ['docs/api/openapi.json'] }, willRewrite: undefined, own: () => require('../scripts/gds/claude-materialize.js').materializeWillRewrite });
+  const core = fakeCore({ api: { g: ['docs/api/openapi.json'] }, willRewrite: undefined, own: () => require('../scripts/bongos/claude-materialize.js').materializeWillRewrite });
   const got = S.laneGeneratedPaths(dir, core);
   for (const f of ['.claude/skills/ask-for-help/SKILL.md', '.claude/skills/blocker-review/SKILL.md', 'docs/api/openapi.json']) {
     assert.ok(got.includes(f), `${f} is the lane's own output and must be classified so`);
@@ -594,7 +594,7 @@ test('real git: the hoodify-finance wedge clears — old-core skills sort as gen
   writeFileSync(path.join(dir, '.claude', 'skills', 'ask-for-help', 'SKILL.md'), 'old\n');
   writeFileSync(path.join(dir, '.claude', 'skills', 'my-own', 'SKILL.md'), 'mine\n');
   g('init', '-q'); g('add', '-A'); g('-c', 'user.email=t@t', '-c', 'user.name=t', 'commit', '-qm', 'init');
-  const core = fakeCore({ api: {}, willRewrite: undefined, own: () => require('../scripts/gds/claude-materialize.js').materializeWillRewrite });
+  const core = fakeCore({ api: {}, willRewrite: undefined, own: () => require('../scripts/bongos/claude-materialize.js').materializeWillRewrite });
   // The bump rewrote the materialized skill and left it uncommitted.
   writeFileSync(path.join(dir, '.claude', 'skills', 'ask-for-help', 'SKILL.md'), 'new\n');
   let pre = S.pinState(dir, spawnSync, S.laneGeneratedPaths(dir, core));
@@ -611,8 +611,8 @@ test('the core still exports the two things the probe reads', () => {
   // laneGeneratedPaths reads them BY NAME off a module it resolves at runtime, so a rename in the
   // core degrades it silently to the empty set — the pre-fix wedge, back again and invisible.
   // This is the cross-file contract, pinned here the way GO_LIVE_REQUIRED is.
-  const up = require('../scripts/gds/upgrade.js');
-  const mat = require('../scripts/gds/claude-materialize.js');
+  const up = require('../scripts/bongos/upgrade.js');
+  const mat = require('../scripts/bongos/claude-materialize.js');
   assert.equal(typeof up.API_ARTIFACT_FILES, 'object', 'upgrade.js no longer exports API_ARTIFACT_FILES');
   assert.ok(Object.values(up.API_ARTIFACT_FILES).flat().includes('docs/api/openapi.json'));
   assert.equal(typeof mat.materializeWillRewrite, 'function', 'claude-materialize.js no longer exports materializeWillRewrite');
@@ -656,13 +656,13 @@ test('preflightFlagsFor: only leave-dirty gets --force, and it gets nothing else
 });
 
 test('preflightFlagsFor has the precedent it claims — go-live.js really does send --force', () => {
-  const body = readFileSync(path.join(ROOT, 'scripts', 'gds', 'go-live.js'), 'utf8')
+  const body = readFileSync(path.join(ROOT, 'scripts', 'bongos', 'go-live.js'), 'utf8')
     .split('function upgradeCommand(')[1].split('\n}')[0];
   assert.match(body, /'--force'/, 'go-live upgradeCommand() no longer sends --force — re-derive preflightFlagsFor from it');
 });
 
 test('the direct-upgrade fallback asks preflightFlagsFor rather than deciding inline', () => {
-  const src = readFileSync(path.join(ROOT, 'scripts', 'gds', 'update-sweep.js'), 'utf8');
+  const src = readFileSync(path.join(ROOT, 'scripts', 'bongos', 'update-sweep.js'), 'utf8');
   assert.match(src, /upArgs\.push\(\.\.\.preflightFlagsFor\(pinMode\)\)/,
     'the clean-tree policy is a pin-mode decision and must go through the named function');
 });
@@ -670,7 +670,7 @@ test('the direct-upgrade fallback asks preflightFlagsFor rather than deciding in
 test('every commitPin call site in the lane also decides what the upgrade generated', () => {
   // The sibling of the push assertion in section 8, and for the same reason: a site that inherits
   // the `generated = []` default silently reverts to the two-bucket guard that wedged the lane.
-  const src = readFileSync(path.join(ROOT, 'scripts', 'gds', 'update-sweep.js'), 'utf8');
+  const src = readFileSync(path.join(ROOT, 'scripts', 'bongos', 'update-sweep.js'), 'utf8');
   const calls = [];
   const re = /commitPin\(\{/g;
   let m;
@@ -808,7 +808,7 @@ test('the post-upgrade net re-probes, rather than reusing the set from before th
   // A skill the NEW core adds is absent from the pre-upgrade answer, so reusing it would drop that
   // file into `other` and wedge the lane one release later — this defect again, wearing the next
   // version number. The heal, which runs BEFORE the bump, must keep using the pre-bump set.
-  const src = readFileSync(path.join(ROOT, 'scripts', 'gds', 'update-sweep.js'), 'utf8');
+  const src = readFileSync(path.join(ROOT, 'scripts', 'bongos', 'update-sweep.js'), 'utf8');
   const afterSpawn = src.split('const generatedAfter = laneGeneratedPaths(inst.dir);')[1];
   assert.ok(afterSpawn, 'the post-upgrade re-probe is gone');
   assert.equal((afterSpawn.match(/generated: generatedAfter,/g) || []).length, 2,
@@ -825,7 +825,7 @@ test('the post-upgrade net re-probes, rather than reusing the set from before th
 // runs the REAL update-channel.js math; only the registry read is stood in for, the way
 // every other case here injects its externals.
 
-const UC = require('../scripts/gds/update-channel.js');
+const UC = require('../scripts/bongos/update-channel.js');
 const PUBLISHED = ['1.19.1039', '1.19.1040', '1.19.1041', '1.20.0'];
 // The real module, with its dist-tags read answering from `tags` (or failing).
 function channelWith(tags) {
@@ -859,7 +859,7 @@ test('a core that predates the follow keeps the old reading: every published ver
 });
 
 test('the sweep asks followTarget, and says the follow on every line it prints', () => {
-  const src = readFileSync(path.join(ROOT, 'scripts', 'gds', 'update-sweep.js'), 'utf8');
+  const src = readFileSync(path.join(ROOT, 'scripts', 'bongos', 'update-sweep.js'), 'utf8');
   const main = src.slice(src.indexOf('function main('));
   assert.match(main, /followTarget\(\{ inst, installed, channel, versions: listed\.versions/);
   assert.doesNotMatch(main, /resolveChannelTarget\(\{ installed, channel: inst\.channel, available: listed\.versions/, 'the unfiltered list never reaches the target');
@@ -910,7 +910,7 @@ test('recordRefusal writes outside the instance, keeps only live holds, and neve
 });
 
 test('the sweep holds a version only when it did not go in', () => {
-  const src = readFileSync(path.join(ROOT, 'scripts', 'gds', 'update-sweep.js'), 'utf8');
+  const src = readFileSync(path.join(ROOT, 'scripts', 'bongos', 'update-sweep.js'), 'utf8');
   const at = src.indexOf('if (res.status !== 0) {');
   const failBranch = src.slice(at, src.indexOf('failed++; continue;', at));
   assert.match(failBranch, /if \(readInstalledCoreVersion\(inst\.dir\) !== target\) \{\s*const held = recordRefusal\(/);

package/tests/update_sweep_home.mjs

@@ -3,7 +3,7 @@
 //
 // WHY. The sweep used to live only under .claude/scheduled-tasks/, which the core package never
 // ships, so cloudbongos.com's sweep ran a checkout frozen at 2026-08-25 and every later lane fix was
-// inert there. It now lives at scripts/gds/update-sweep.js. These pin the three things that keep it
+// inert there. It now lives at scripts/bongos/update-sweep.js. These pin the three things that keep it
 // runnable from node_modules/@bongos/core: it publishes, it needs nothing the package lacks (the
 // .claude/hooks resolver is topology-excluded), and it reads the roster from where it is told,
 // not from where its own file sits.
@@ -21,12 +21,12 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const SWEEP = path.join(ROOT, 'scripts', 'gds', 'update-sweep.js');
+const SWEEP = path.join(ROOT, 'scripts', 'bongos', 'update-sweep.js');
 const sweep = require(SWEEP);
-const { isPublishable } = require('../scripts/gds/publish-manifest.js');
+const { isPublishable } = require('../scripts/bongos/publish-manifest.js');
 
 test('the sweep and every core file it requires are in the published package', () => {
-  for (const f of ['scripts/gds/update-sweep.js', 'scripts/gds/update-channel.js', 'scripts/gds/upgrade.js', 'src/module-api.js']) {
+  for (const f of ['scripts/bongos/update-sweep.js', 'scripts/bongos/update-channel.js', 'scripts/bongos/upgrade.js', 'src/module-api.js']) {
     assert.equal(isPublishable(f), true, `${f} must publish, or the installed sweep cannot run`);
   }
   // The reason it moved: the old home never ships.
@@ -38,7 +38,7 @@ test('the sweep requires nothing the package lacks (no .claude/ path, no hook re
   const requires = [...src.matchAll(/require\(\s*['"]([^'"]+)['"]\s*\)/g)].map((m) => m[1]);
   for (const r of requires) {
     assert.ok(!r.includes('.claude') && !r.includes('_core-resolve'), `update-sweep.js requires ${r}, which the core package does not ship`);
-    if (r.startsWith('.')) assert.equal(isPublishable(path.posix.join('scripts/gds', r).replace(/\\/g, '/')), true, `${r} must publish`);
+    if (r.startsWith('.')) assert.equal(isPublishable(path.posix.join('scripts/bongos', r).replace(/\\/g, '/')), true, `${r} must publish`);
   }
 });
 
@@ -51,14 +51,14 @@ test('its target-instance resolver searches the same packages, in the same order
 
 test('coreModulePathFrom finds a target instance\'s INSTALLED core, root first', () => {
   const inst = mkdtempSync(path.join(tmpdir(), 'sweep-home-'));
-  const pkg = path.join(inst, 'node_modules', '@bongos', 'core', 'scripts', 'gds');
+  const pkg = path.join(inst, 'node_modules', '@bongos', 'core', 'scripts', 'bongos');
   mkdirSync(pkg, { recursive: true });
   writeFileSync(path.join(pkg, 'upgrade.js'), '');
-  assert.equal(sweep.coreModulePathFrom(inst, 'scripts/gds/upgrade.js'), path.join(pkg, 'upgrade.js'));
-  mkdirSync(path.join(inst, 'scripts', 'gds'), { recursive: true });
-  writeFileSync(path.join(inst, 'scripts', 'gds', 'upgrade.js'), '');
-  assert.equal(sweep.coreModulePathFrom(inst, 'scripts/gds/upgrade.js'), path.join(inst, 'scripts', 'gds', 'upgrade.js'), 'a monolith root wins, as in _core-resolve.js');
-  assert.equal(sweep.coreModulePathFrom(inst, 'scripts/gds/absent.js'), null);
+  assert.equal(sweep.coreModulePathFrom(inst, 'scripts/bongos/upgrade.js'), path.join(pkg, 'upgrade.js'));
+  mkdirSync(path.join(inst, 'scripts', 'bongos'), { recursive: true });
+  writeFileSync(path.join(inst, 'scripts', 'bongos', 'upgrade.js'), '');
+  assert.equal(sweep.coreModulePathFrom(inst, 'scripts/bongos/upgrade.js'), path.join(inst, 'scripts', 'bongos', 'upgrade.js'), 'a monolith root wins, as in _core-resolve.js');
+  assert.equal(sweep.coreModulePathFrom(inst, 'scripts/bongos/absent.js'), null);
 });
 
 test('run from elsewhere, it reads the roster named by --instance and says which core is sweeping', () => {
@@ -86,15 +86,15 @@ test('the subscribe.js shim runs the same body, with its instance root as the de
   const shim = require('../.claude/scheduled-tasks/core-update-subscription/subscribe.js');
   assert.equal(shim, sweep, 'the shim re-exports the core body, so tests and callers see one sweep');
   const src = readFileSync(path.join(ROOT, '.claude', 'scheduled-tasks', 'core-update-subscription', 'subscribe.js'), 'utf8');
-  assert.match(src, /requireCore\('scripts\/gds\/update-sweep\.js'\)/);
+  assert.match(src, /requireCore\('scripts\/(?:gds|bongos)\/update-sweep\.js'\)/);
   assert.match(src, /sweep\.main\(\{ instanceRoot: INSTANCE_ROOT \}\)/);
 });
 
 test('the recipe\'s drop-in names the file that really ships, and the safe database setting', () => {
   const recipe = readFileSync(path.join(ROOT, 'docs', 'recipes', 'upgrading-the-core.md'), 'utf8');
-  const execs = [...recipe.matchAll(/node_modules\/@bongos\/core\/(scripts\/gds\/[\w-]+\.js)/g)].map((m) => m[1]);
+  const execs = [...recipe.matchAll(/node_modules\/@bongos\/core\/(scripts\/(?:gds|bongos)\/[\w-]+\.js)/g)].map((m) => m[1]);
   assert.ok(execs.length >= 2, 'the drop-in and its dry run both name the installed sweep');
-  for (const rel of execs) assert.equal(rel, 'scripts/gds/update-sweep.js');
+  for (const rel of execs) assert.equal(rel, 'scripts/bongos/update-sweep.js');
   assert.match(recipe, /Environment=UPDATE_CHANNEL_DB=/);
   assert.doesNotMatch(recipe, /Environment=PGDATABASE=/, 'a unit-level PGDATABASE leaks into tenant upgrades');
 });

package/tests/upgrade.mjs

@@ -22,8 +22,8 @@ import { tmpdir } from 'node:os';
 import { join, dirname } from 'node:path';
 
 const require = createRequire(import.meta.url);
-const u = require('../scripts/gds/upgrade.js');
-const pc = require('../scripts/gds/package-core.js'); // the packager — reuse its EXACT hash fns to build reference pins
+const u = require('../scripts/bongos/upgrade.js');
+const pc = require('../scripts/bongos/package-core.js'); // the packager — reuse its EXACT hash fns to build reference pins
 
 let passed = 0, failed = 0;
 const pending = [];
@@ -112,10 +112,10 @@ t('vendorTarball: copies the .tgz + side-car manifest under the canonical name',
 // ones ever ran, hiding whether CI could have caught it.
 t('the vendored core pin is POSIX on every platform, and no call site rebuilds it', () => {
   // one place decides the separator, and that place spells it posix
-  const upgradeSrc = readFileSync(new URL('../scripts/gds/upgrade.js', import.meta.url), 'utf8');
+  const upgradeSrc = readFileSync(new URL('../scripts/bongos/upgrade.js', import.meta.url), 'utf8');
   assert.match(upgradeSrc, /function vendorRelFor\([^)]*\)\s*{\s*return path\.posix\.join\(/,
     'vendorRelFor must build the pin with path.posix.join — it is an npm specifier, not a filesystem path');
-  for (const rel of ['scripts/gds/upgrade.js', 'scripts/gds/init.js']) {
+  for (const rel of ['scripts/bongos/upgrade.js', 'scripts/bongos/init.js']) {
     const code = readFileSync(new URL('../' + rel, import.meta.url), 'utf8');
     assert.doesNotMatch(code, /path\.join\(\s*['"]vendor['"]\s*,/,
       `${rel} must build the pin with vendorRelFor(), not path.join('vendor', …)`);
@@ -302,8 +302,8 @@ t('regenerateApiArtifacts: spawns docs then client from the new core, targeting
   assert.deepEqual(res.ran, ['gen-api-docs.js', 'gen-api-client.js']);
   assert.equal(calls.length, 2);
   // docs BEFORE client (the client reads the spec docs produce)
-  assert.ok(calls[0].args[0].endsWith(join('scripts', 'gds', 'gen-api-docs.js')));
-  assert.ok(calls[1].args[0].endsWith(join('scripts', 'gds', 'gen-api-client.js')));
+  assert.ok(calls[0].args[0].endsWith(join('scripts', 'bongos', 'gen-api-docs.js')));
+  assert.ok(calls[1].args[0].endsWith(join('scripts', 'bongos', 'gen-api-client.js')));
   for (const c of calls) {
     assert.equal(c.cmd, process.execPath, 'runs node');
     assert.equal(c.opts.cwd, '/inst', 'cwd is the instance');
@@ -916,7 +916,7 @@ t('regenerateNavDocs: spawns each generator from the CORE against the INSTANCE r
   assert.equal(calls.length, 1);
   assert.equal(calls[0].cwd, '/inst', 'runs with cwd = the instance dir');
   assert.equal(calls[0].env.BONGOS_INSTANCE_ROOT, '/inst', 'sets the instance-root env so the generator writes into the instance');
-  assert.equal(calls[0].arg0, join('/core', 'scripts', 'gds', 'gen-session-index.js'), 'spawns the generator from the CORE package');
+  assert.equal(calls[0].arg0, join('/core', 'scripts', 'bongos', 'gen-session-index.js'), 'spawns the generator from the CORE package');
 });
 
 t('regenerateNavDocs: a MISSING generator is recorded as failed but the others still run (best-effort)', () => {
@@ -951,7 +951,7 @@ t('regenerateNavDocs: a generator that exits nonzero is LOUD-failed (ok:false) w
 function docAssetFs({ atlas = true, sources = ['01-a.mmd', '02-b.mmd'], renders = true } = {}) {
   const present = new Set();
   if (atlas) present.add(join('/core', 'modules', 'hall-ui', 'public', 'atlas.json'));
-  present.add(join('/core', 'scripts', 'gds', 'gen-atlas.js'));
+  present.add(join('/core', 'scripts', 'bongos', 'gen-atlas.js'));
   present.add(join('/core', 'scripts', 'render-diagrams.sh'));
   if (renders) {
     for (const s of sources) {
@@ -995,7 +995,7 @@ t('healDocAssets: the post-upgrade case regenerates BOTH, node for the atlas and
   assert.deepEqual(res.ran, ['atlas', 'diagrams']);
   assert.equal(calls.length, 2);
   assert.equal(calls[0].cmd, process.execPath, 'atlas generator runs under node');
-  assert.equal(calls[0].arg0, join('/core', 'scripts', 'gds', 'gen-atlas.js'));
+  assert.equal(calls[0].arg0, join('/core', 'scripts', 'bongos', 'gen-atlas.js'));
   assert.equal(calls[1].cmd, 'bash', 'the diagram renderer is a shell script');
   assert.equal(calls[1].arg0, join('/core', 'scripts', 'render-diagrams.sh'));
   assert.ok(calls.every((c) => c.cwd === '/core'), 'both run against the CORE root, where the assets live');
@@ -1608,7 +1608,7 @@ t('pinnedDeployKey / remoteGithubRepo: read the ADR 0176 wiring off the checkout
   assert.deepEqual(u.remoteGithubRepo('/srv/bongos/acme', 'origin', at('git@github.com:acme/widgets.git')), acme, 'the ADR 0176 private wiring');
   assert.deepEqual(u.remoteGithubRepo('/srv/bongos/acme', 'origin', at('https://github.com/acme/widgets')), acme);
   assert.deepEqual(u.remoteGithubRepo('/srv/bongos/acme', 'origin', at('https://x-access-token@github.com/acme/widgets.git')), acme);
-  const P = require('../scripts/gds/provision.js');
+  const P = require('../scripts/bongos/provision.js');
   // Pin the alias: since task 1003996 it is the scaffold's default only on a box where it
   // resolves, and this assertion is about the ALIAS branch being recognised as GitHub.
   assert.deepEqual(u.remoteGithubRepo('/srv/bongos/acme', 'origin', at(P.instanceRepoRemote(acme, { sshAlias: 'github-deploy' }))), acme, 'the shared SSH alias the public scaffold wires is GitHub too');
@@ -1951,7 +1951,7 @@ t('a `git status` that could NOT ANSWER is not reported as uncommitted work', as
 });
 
 t('…and that refusal is classified as unknown, so no remedy commits a guess', async () => {
-  const o = require('../scripts/gds/upgrade-outcome.js');
+  const o = require('../scripts/bongos/upgrade-outcome.js');
   const dir = scratchConsumer();
   const res = await u.runUpgrade({ to: '1.15.0', instance: dir }, {
     log: () => {}, err: () => {},

package/tests/upgrade_artist_gate.mjs

@@ -13,10 +13,10 @@ import { mkdtempSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { makeRunner } from './helpers.mjs';
-import { checkArtistGate } from '../scripts/gds/upgrade-artist-gate.js';
+import { checkArtistGate } from '../scripts/bongos/upgrade-artist-gate.js';
 
 const require = createRequire(import.meta.url);
-const u = require('../scripts/gds/upgrade.js');
+const u = require('../scripts/bongos/upgrade.js');
 const { test, summary } = makeRunner();
 
 // A fake instance: answers GET <origin>/api/bongos/artist-gate with `status` + `body`.
@@ -133,11 +133,11 @@ await test('a DOWNGRADE is never held — rolling back must not wait on a review
 });
 
 await test('the gate runs from the pre-flight, before the pin step, and the reader is go-live\'s own', () => {
-  const whole = readFileSync(new URL('../scripts/gds/upgrade.js', import.meta.url), 'utf8');
+  const whole = readFileSync(new URL('../scripts/bongos/upgrade.js', import.meta.url), 'utf8');
   const src = whole.slice(whole.indexOf('async function runUpgrade('));
   const gateAt = src.indexOf('checkArtistGate)(opts, deps)');
   assert.ok(gateAt > 0 && gateAt < src.indexOf('writePin(instanceDir'), 'checked before the pin is written');
-  const gateSrc = readFileSync(new URL('../scripts/gds/upgrade-artist-gate.js', import.meta.url), 'utf8');
+  const gateSrc = readFileSync(new URL('../scripts/bongos/upgrade-artist-gate.js', import.meta.url), 'utf8');
   assert.match(gateSrc, /require\('\.\/go-live'\)/, 'one reader and one judgement for both deploy paths');
 });
 

package/tests/upgrade_commit_identity.mjs

@@ -20,8 +20,8 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
 const require = createRequire(import.meta.url);
-const { persistPin } = require('../scripts/gds/upgrade.js');
-const { commitIdentityEnv } = require('../scripts/gds/upgrade-commit-identity.js');
+const { persistPin } = require('../scripts/bongos/upgrade.js');
+const { commitIdentityEnv } = require('../scripts/bongos/upgrade-commit-identity.js');
 
 // user.useConfigOnly: git on a Mac invents an identity from the hostname, where the box's git
 // refuses; this makes every machine refuse the way the box did.

package/tests/upgrade_migrate.mjs

@@ -25,13 +25,13 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { EventEmitter } from 'node:events';
 // ESM named imports: knip credits a CJS export only when a test imports it this way.
-import { migrateError, migrateFailureDetail, teeSpawn } from '../scripts/gds/upgrade-migrate.js';
+import { migrateError, migrateFailureDetail, teeSpawn } from '../scripts/bongos/upgrade-migrate.js';
 
 const require = createRequire(import.meta.url);
-const { migratePlan, CORE_MIGRATE_SCRIPT } = require('../scripts/gds/upgrade-migrate.js');
-const u = require('../scripts/gds/upgrade.js');
-const init = require('../scripts/gds/init.js');
-const { parsePreflight } = require('../scripts/gds/provision-core-upgrade.js');
+const { migratePlan, CORE_MIGRATE_SCRIPT } = require('../scripts/bongos/upgrade-migrate.js');
+const u = require('../scripts/bongos/upgrade.js');
+const init = require('../scripts/bongos/init.js');
+const { parsePreflight } = require('../scripts/bongos/provision-core-upgrade.js');
 
 const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const fixture = (prefix) => realpathSync(mkdtempSync(path.join(tmpdir(), prefix)));
@@ -249,13 +249,13 @@ test('a full upgrade whose migrate fails reports the migration, the error, and a
   );
   assert.equal(res.ok, false);
   assert.match(res.error, /^migrate failed \(exit 3\) at core_999_x: ERROR: +check constraint "tasks_kind_check"/);
-  const outcome = require('../scripts/gds/upgrade-outcome.js');
+  const outcome = require('../scripts/bongos/upgrade-outcome.js');
   assert.equal(outcome.upgradeReason(res), 'migrate_check_violation');
   assert.equal(outcome.classifyFailure('migrate_check_violation').class, 'unknown', 'existing rows break the new rule: a person decides, never an unattended retry');
 });
 
 test('"must be owner of" in a failed migrate is the known not-owner snag, not an unknown failure (task 1004735)', () => {
-  const outcome = require('../scripts/gds/upgrade-outcome.js');
+  const outcome = require('../scripts/bongos/upgrade-outcome.js');
   const res = { ok: false, rolledBack: true, rollback: {}, error: 'migrate failed (exit 3) at core_274_parked_backlog_stays_parked: ERROR:  must be owner of table tasks' };
   assert.equal(outcome.upgradeReason(res), 'migrate_not_owner');
   assert.deepEqual(outcome.classifyFailure('migrate_not_owner'), { class: 'known_wedge', reason: 'migrate_not_owner' });

package/tests/upgrade_operator.mjs

@@ -16,8 +16,8 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const op = require('../scripts/gds/upgrade-operator.js');
-const upgrade = require('../scripts/gds/upgrade.js');
+const op = require('../scripts/bongos/upgrade-operator.js');
+const upgrade = require('../scripts/bongos/upgrade.js');
 
 const HUB = { kind: 'hub', url: 'https://hub.example.com/deploy?project=mercury', hall: 'https://mercury.example.com/builders' };
 

package/tests/upgrade_outcome.mjs

@@ -14,10 +14,10 @@ import { createRequire } from 'node:module';
 import {
   outcomeLine, parseOutcomeLine, upgradeReason, upgradeStage, classifyFailure, runnerReason,
   describeUpgradeFailure, FAILURE_CLASSES, REASON_CLASS, STAGES, OUTCOME_TAG,
-} from '../scripts/gds/upgrade-outcome.js';
+} from '../scripts/bongos/upgrade-outcome.js';
 
 const require = createRequire(import.meta.url);
-const R = require('../scripts/gds/provision-core-upgrade.js');
+const R = require('../scripts/bongos/provision-core-upgrade.js');
 
 let passed = 0;
 let failed = 0;

package/tests/upgrade_persist_pin.mjs

@@ -25,10 +25,10 @@ import { spawnSync } from 'node:child_process';
 import { mkdtempSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, dirname } from 'node:path';
-import { API_ARTIFACT_FILES } from '../scripts/gds/upgrade.js';
+import { API_ARTIFACT_FILES } from '../scripts/bongos/upgrade.js';
 
 const require = createRequire(import.meta.url);
-const { persistPin, dirtyPinFiles, preflightDbIdentity, gitTreeClean, PIN_FILES } = require('../scripts/gds/upgrade.js');
+const { persistPin, dirtyPinFiles, preflightDbIdentity, gitTreeClean, PIN_FILES } = require('../scripts/bongos/upgrade.js');
 
 // A fake `run` driven by a table of [matcher, result]. Records every invocation.
 function fakeRun(handlers = {}) {
@@ -270,9 +270,9 @@ const statusOf = (changed) => (args) => {
 };
 
 test('API_ARTIFACT_FILES names exactly the files the two generators write', () => {
-  const client = require('../scripts/gds/gen-api-client.js').build();
+  const client = require('../scripts/bongos/gen-api-client.js').build();
   assert.deepEqual(API_ARTIFACT_FILES['gen-api-client.js'], Object.keys(client.files).map((f) => `clients/bongos-client/${f}`));
-  const docsSrc = readFileSync(new URL('../scripts/gds/gen-api-docs.js', import.meta.url), 'utf8');
+  const docsSrc = readFileSync(new URL('../scripts/bongos/gen-api-docs.js', import.meta.url), 'utf8');
   assert.deepEqual(API_ARTIFACT_FILES['gen-api-docs.js'], [...docsSrc.matchAll(/\brel: '([^']+)'/g)].map((m) => m[1]));
 });
 
@@ -365,7 +365,7 @@ test('real git: an owner edit outside the generated files is never swept into th
 // when anything but the pin is dirty, which is simultaneously the `failed=1` on a successful
 // upgrade and the next sweep's permanent halt.
 
-const { materializeClaude, materializeWillRewrite } = require('../scripts/gds/claude-materialize.js');
+const { materializeClaude, materializeWillRewrite } = require('../scripts/bongos/claude-materialize.js');
 
 // A minimal core package: just the .claude/ tree materialize copies out of it.
 function coreAt(dir, version) {

package/tests/upkeep_home.mjs

@@ -146,7 +146,7 @@ test('a named goal is used as-is, even for infra work', async () => {
 // ---- the CLI ------------------------------------------------------------------
 
 test('bongos task new: the refusal tells a builder both ways forward in plain words', () => {
-  const { goalRequiredHelp } = require('../scripts/gds/task.js');
+  const { goalRequiredHelp } = require('../scripts/bongos/task.js');
   const help = goalRequiredHelp({ kind: 'feature', version_id: 'V2' });
   assert.match(help, /--goal <id>/);
   assert.match(help, /--kind infra and no --goal/);

package/tests/version_close.mjs

@@ -1,6 +1,6 @@
 // tests/version_close.mjs
 //
-// Pure-helper coverage for scripts/gds/version-close.js (the `/version-close`
+// Pure-helper coverage for scripts/bongos/version-close.js (the `/version-close`
 // tooling that archives a shipped version + opens the next). The derive*/build*
 // functions are pure string/path transforms with no DB or git dependency, but
 // had no unit test — so a regression in, say, the version-id increment regex
@@ -18,7 +18,7 @@ const {
   deriveNextScopePath,
   deriveShippedPath,
   buildCommitMessage,
-} = require('../scripts/gds/version-close.js');
+} = require('../scripts/bongos/version-close.js');
 
 let passed = 0;
 let failed = 0;