@bongos/core 1.21.174 → 1.21.176

package/tests/ship_land_ci_not_started.mjs

@@ -16,10 +16,10 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 import {
   jobNeverStarted, landPendingLines, localMergeDriver, notStartedLines, pollCiDeploy, redBlocksMerge, redPrLine, redPrLines,
-} from '../scripts/gds/ship-land.js';
+} from '../scripts/bongos/ship-land.js';
 
 const require = createRequire(import.meta.url);
-const { CARDS, cardFor } = require('../scripts/gds/plain-cards.js');
+const { CARDS, cardFor } = require('../scripts/bongos/plain-cards.js');
 
 let passed = 0;
 let failed = 0;
@@ -127,7 +127,7 @@ await test('the closing banner for a never-started CI is neither "NOT a failure"
   const out = landPendingLines(42, { notStarted: true }).join('\n');
   assert.match(out, /CI never started/);
   assert.match(out, /Nothing in the work needs to change/);
-  assert.match(out, /node scripts\/gds\/ship\.js 42/);
+  assert.match(out, /node scripts\/(?:gds|bongos)\/ship\.js 42/);
   assert.doesNotMatch(out, /NOT a failure/);
   assert.doesNotMatch(out, /Do what the lines above say/);
 });

package/tests/ship_land_conflict.mjs

@@ -18,8 +18,8 @@ import { createRequire } from 'node:module';
 process.env.BONGOS_SURFACE = 'agent'; // the plain cards print on the agent surface only
 
 const require = createRequire(import.meta.url);
-const land = require('../scripts/gds/ship-land.js');
-const { CARDS } = require('../scripts/gds/plain-cards.js');
+const land = require('../scripts/bongos/ship-land.js');
+const { CARDS } = require('../scripts/bongos/plain-cards.js');
 
 let passed = 0;
 let failed = 0;
@@ -75,7 +75,7 @@ await test('the conflict lines name the fix — merge main in, then re-run this
   assert.ok(text.includes(CONFLICT_LINE), text);
   assert.ok(text.includes('git merge origin/main'), 'merge, never rebase: the branch is already published (strand-fix case C)');
   assert.ok(!/rebase/.test(text), 'a rebase makes every later push non-fast-forward');
-  assert.ok(text.includes('node scripts/gds/ship.js 4242'), 'the resume names THIS task');
+  assert.ok(text.includes('node scripts/bongos/ship.js 4242'), 'the resume names THIS task');
   assert.ok(text.includes(CARDS.merge_conflict.happened), 'the plain-words card for merge_conflict follows');
 });
 

package/tests/ship_land_proof.mjs

@@ -36,7 +36,7 @@ const require = createRequire(import.meta.url);
 // The stub MUST be in place before ship-land.js is first required — it destructures
 // cliClient at module load.
 let nextAttest = null;
-const cliLibPath = require.resolve('../scripts/gds/cli-lib');
+const cliLibPath = require.resolve('../scripts/bongos/cli-lib');
 require.cache[cliLibPath] = {
   id: cliLibPath,
   filename: cliLibPath,
@@ -54,7 +54,7 @@ require.cache[cliLibPath] = {
   },
 };
 
-const { attestGateTrust, landProofRecorded, landProofWarningLines } = require('../scripts/gds/ship-land.js');
+const { attestGateTrust, landProofRecorded, landProofWarningLines } = require('../scripts/bongos/ship-land.js');
 
 let passed = 0;
 let failed = 0;
@@ -195,7 +195,7 @@ await t('the reason is surfaced, and a missing sha degrades to a placeholder', (
 // is the other half of the bug (deleting the branch first destroys the only evidence
 // a later sweep could have used).
 
-const mergeSrc = fs.readFileSync(fileURLToPath(new URL('../scripts/gds/ship-merge.js', import.meta.url)), 'utf8');
+const mergeSrc = fs.readFileSync(fileURLToPath(new URL('../scripts/bongos/ship-merge.js', import.meta.url)), 'utf8');
 
 await t('ship-merge.js records the merge commit as this task\'s land proof', () => {
   assert.match(mergeSrc, /attestGateTrust\(taskId, mergeSha\)/,

package/tests/ship_land_red_pr.mjs

@@ -17,11 +17,11 @@ import { createRequire } from 'node:module';
 import {
   FRESHNESS_TESTS, failingTestNames, landPendingLines, localMergeDriver, mergeTrapLines,
   pollCiDeploy, pollServerPublish, redBlocksMerge, redPrLines, unitReportFor,
-} from '../scripts/gds/ship-land.js';
+} from '../scripts/bongos/ship-land.js';
 
 const require = createRequire(import.meta.url);
 const githubPush = require('../modules/lifecycle/github-push.js');
-const { CARDS } = require('../scripts/gds/plain-cards.js');
+const { CARDS } = require('../scripts/bongos/plain-cards.js');
 
 let passed = 0;
 let failed = 0;
@@ -139,7 +139,7 @@ await test('a failing freshness gate gets its healing command, per push path', a
   const local = mergeTrapLines(md, { taskId: 42, via: 'local' }).join('\n');
   assert.match(local, /`fitness` is a freshness gate/);
   assert.match(local, /stale in the MERGED tree/);
-  assert.match(local, /node scripts\/gds\/ship\.js 42/, 'names the re-ship for THIS task');
+  assert.match(local, /node scripts\/(?:gds|bongos)\/ship\.js 42/, 'names the re-ship for THIS task');
   assert.match(local, /ship-check\.js/);
   const server = mergeTrapLines(md, { taskId: 42, via: 'server' }).join('\n');
   assert.match(server, /The server regenerates stale generated files/);
@@ -168,7 +168,7 @@ await test('landPendingLines: a RED PR never gets "NOT a failure"; a green-but-s
   const red = landPendingLines(42, { red: true }).join('\n');
   assert.ok(!/NOT a failure/.test(red), 'a failing required check does not pass by waiting');
   assert.match(red, /RED/);
-  assert.match(red, /node scripts\/gds\/ship\.js 42/);
+  assert.match(red, /node scripts\/(?:gds|bongos)\/ship\.js 42/);
   assert.match(landPendingLines(42).join('\n'), /This is NOT a failure/);
 });
 
@@ -188,7 +188,7 @@ await test('pollCiDeploy (laptop): a red PR is named once, the trap and heal are
   assert.equal(out.split('the PR is RED — 1 failed: fitness').length - 1, 1, 'named once, not thirty times');
   assert.match(out, /MERGED with the current main/);
   assert.match(out, /`fitness` is a freshness gate/);
-  assert.match(out, /node scripts\/gds\/ship\.js 42/);
+  assert.match(out, /node scripts\/(?:gds|bongos)\/ship\.js 42/);
   assert.ok(!/This is NOT a failure/.test(out), 'the closing banner must not contradict the red line');
   assert.ok(!out.includes(CARDS.land_pending.happened), 'nor the "nothing to do" card');
 });

package/tests/ship_merge_gate.mjs

@@ -25,7 +25,7 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const gate = require(path.join(ROOT, 'scripts', 'gds', 'ship-merge-gate.js'));
+const gate = require(path.join(ROOT, 'scripts', 'bongos', 'ship-merge-gate.js'));
 
 test('a clean merge result is waved through, and the base is never consulted', () => {
   assert.deepEqual(gate.mergeGateVerdict({ mergeClean: true, baseClean: null }), { block: false, reason: 'clean' });
@@ -75,7 +75,7 @@ test('probeBaseClean cannot answer without a base commit', () => {
 });
 
 test('WIRING: ship-merge.js runs the gate BEFORE the push that makes it main', () => {
-  const src = fs.readFileSync(path.join(ROOT, 'scripts', 'gds', 'ship-merge.js'), 'utf8');
+  const src = fs.readFileSync(path.join(ROOT, 'scripts', 'bongos', 'ship-merge.js'), 'utf8');
   const gateAt = src.indexOf('gateMergeResult({');
   const pushAt = src.indexOf('push-main.js');
   assert.notEqual(gateAt, -1, 'ship-merge.js must call the gate');
@@ -88,7 +88,7 @@ test('WIRING: ship-merge.js runs the gate BEFORE the push that makes it main', (
 });
 
 test('the gate measures the PRE-MERGE base, captured before the branch lands', () => {
-  const src = fs.readFileSync(path.join(ROOT, 'scripts', 'gds', 'ship-merge.js'), 'utf8');
+  const src = fs.readFileSync(path.join(ROOT, 'scripts', 'bongos', 'ship-merge.js'), 'utf8');
   const baseAt = src.indexOf('const baseSha =');
   const mergeAt = src.indexOf('buildMergeArgv(branch, valueSummary)');
   assert.notEqual(baseAt, -1, 'the base sha must be captured');
@@ -104,9 +104,9 @@ test('the gate measures the PRE-MERGE base, captured before the branch lands', (
 // true and this reds.
 function fakeTree(exitCode) {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'merge-gate-fixture-'));
-  fs.mkdirSync(path.join(dir, 'scripts', 'gds'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'scripts', 'bongos'), { recursive: true });
   const body = exitCode === 0 ? 'process.exit(0);\n' : `process.exit(${exitCode});\n`;
-  fs.writeFileSync(path.join(dir, 'scripts', 'gds', 'fitness.js'), body);
+  fs.writeFileSync(path.join(dir, 'scripts', 'bongos', 'fitness.js'), body);
   return dir;
 }
 
@@ -138,7 +138,7 @@ test('a tree with no fitness.js cannot be certified', () => {
 // flakiness is not a control.
 test('a crashed run is UNMEASURABLE, not a finding', () => {
   const crashed = fs.mkdtempSync(path.join(os.tmpdir(), 'merge-gate-crash-'));
-  fs.mkdirSync(path.join(crashed, 'scripts', 'gds'), { recursive: true });
+  fs.mkdirSync(path.join(crashed, 'scripts', 'bongos'), { recursive: true });
   // A tree whose gate cannot even be parsed: node exits non-zero, so this one
   // still reads as a finding — that is deliberate, it IS a broken committed
   // gate. The infra case is the one below it: no gate in the tree at all.
@@ -154,8 +154,8 @@ test('the tri-state keeps clean and failing apart', () => {
   const green = fs.mkdtempSync(path.join(os.tmpdir(), 'merge-gate-green-'));
   const red = fs.mkdtempSync(path.join(os.tmpdir(), 'merge-gate-red-'));
   for (const [dir, code] of [[green, 0], [red, 1]]) {
-    fs.mkdirSync(path.join(dir, 'scripts', 'gds'), { recursive: true });
-    fs.writeFileSync(path.join(dir, 'scripts', 'gds', 'fitness.js'), `process.exit(${code});\n`);
+    fs.mkdirSync(path.join(dir, 'scripts', 'bongos'), { recursive: true });
+    fs.writeFileSync(path.join(dir, 'scripts', 'bongos', 'fitness.js'), `process.exit(${code});\n`);
   }
   try {
     assert.equal(gate.fitnessOutcome(green), 'clean');
@@ -174,7 +174,7 @@ test('an unmeasurable base blocks rather than waving the ship through', () => {
 
 // ---- gateApplies (task 1004584) ----
 // A VENDORED instance (core under node_modules/@bongos/core) carries no
-// scripts/gds/fitness.js of its own, so both sides read 'unmeasurable' and every
+// scripts/bongos/fitness.js of its own, so both sides read 'unmeasurable' and every
 // vendored land was blocked. The gate stands down ONLY when the base lacked the
 // file too — a branch that deletes fitness.js from the core is still measured.
 function gitRepo(withFitness) {
@@ -185,8 +185,8 @@ function gitRepo(withFitness) {
   run('git config user.name t');
   fs.writeFileSync(path.join(dir, 'README.md'), 'x\n');
   if (withFitness) {
-    fs.mkdirSync(path.join(dir, 'scripts', 'gds'), { recursive: true });
-    fs.writeFileSync(path.join(dir, 'scripts', 'gds', 'fitness.js'), 'process.exit(0);\n');
+    fs.mkdirSync(path.join(dir, 'scripts', 'bongos'), { recursive: true });
+    fs.writeFileSync(path.join(dir, 'scripts', 'bongos', 'fitness.js'), 'process.exit(0);\n');
   }
   run('git add -A');
   run('git commit -q -m base');
@@ -222,8 +222,8 @@ test('gateApplies: a vendored instance (no fitness.js on either side) stands the
 test('gateApplies: an UNTRACKED fitness.js on disk (the vendored scripts link) does not gate the repo', () => {
   const { dir, baseSha } = gitRepo(false);
   try {
-    fs.mkdirSync(path.join(dir, 'scripts', 'gds'), { recursive: true });
-    fs.writeFileSync(path.join(dir, 'scripts', 'gds', 'fitness.js'), 'process.exit(1);\n');
+    fs.mkdirSync(path.join(dir, 'scripts', 'bongos'), { recursive: true });
+    fs.writeFileSync(path.join(dir, 'scripts', 'bongos', 'fitness.js'), 'process.exit(1);\n');
     fs.appendFileSync(path.join(dir, '.git', 'info', 'exclude'), '/scripts\n');
     assert.equal(gate.gateApplies(dir, baseSha), false);
     const verdict = gate.gateMergeResult({ repoRoot: dir, baseSha, log: () => {} });
@@ -236,7 +236,7 @@ test('gateApplies: an UNTRACKED fitness.js on disk (the vendored scripts link) d
 test('gateApplies: a merge that DELETES fitness.js from a gated base is still measured (and blocked)', () => {
   const { dir, baseSha } = gitRepo(true);
   try {
-    fs.rmSync(path.join(dir, 'scripts', 'gds', 'fitness.js'));
+    fs.rmSync(path.join(dir, 'scripts', 'bongos', 'fitness.js'));
     execSync('git commit -q -am "drop the gate"', { cwd: dir, stdio: 'ignore' });
     assert.equal(gate.gateApplies(dir, baseSha), true, 'the base had the gate, so its removal must not wave the merge through');
   } finally {

package/tests/ship_mode.mjs

@@ -164,7 +164,7 @@ test('bongos ship-mode is a registered verb wired to shipping-mode.js', () => {
 });
 
 test('the CLI text names the mode and how to switch it', () => {
-  const { describe } = require(path.join(ROOT, 'scripts', 'gds', 'shipping-mode.js'));
+  const { describe } = require(path.join(ROOT, 'scripts', 'bongos', 'shipping-mode.js'));
   const auto = describe({ mode: 'auto', chosen: false, sentence: 'Auto: …' });
   assert.match(auto, /Ship mode: auto \(default — not chosen yet\)/);
   assert.match(auto, /shipping-mode\.js manual/);

package/tests/ship_mode_first_ship.mjs

@@ -26,7 +26,7 @@ const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 
 const {
   ASK_EXIT, ASK_MARKER, unattended, shipModeFlag, shipModeAskVerdict, askLines, runFirstShipAsk,
-} = require('../scripts/gds/ship-mode-ask.js');
+} = require('../scripts/bongos/ship-mode-ask.js');
 
 const unchosen = { mode: 'auto', chosen: false, source: 'default', can_change: true };
 const chosen = { mode: 'manual', chosen: true, source: 'project_settings', can_change: true };
@@ -103,7 +103,7 @@ test('an unchosen project stops the ship with exit 5 and asks Auto first', async
   const text = r.lines.join('\n');
   assert.ok(r.lines[0].startsWith(ASK_MARKER));
   assert.match(text, /Auto \(recommended\)[\s\S]*Manual/, 'Auto is offered first and named as recommended');
-  assert.match(text, /node scripts\/gds\/ship\.js 1004630 --notes-file notes\.md --summary "two words" --ship-mode auto\|manual/);
+  assert.match(text, /node scripts\/(?:gds|bongos)\/ship\.js 1004630 --notes-file notes\.md --summary "two words" --ship-mode auto\|manual/);
   assert.match(text, /claim is still active/);
   assert.deepEqual(h.saves, [], 'asking saves nothing');
 });
@@ -160,7 +160,7 @@ test('the ask falls back to its own wording when the server sends no choices', (
 // ---- 4. the wiring ---------------------------------------------------------
 
 test('shipMain asks after finding the claim and before the budget cap and grader', () => {
-  const src = fs.readFileSync(path.join(ROOT, 'scripts', 'gds', 'ship-flow.js'), 'utf8');
+  const src = fs.readFileSync(path.join(ROOT, 'scripts', 'bongos', 'ship-flow.js'), 'utf8');
   const main = src.slice(src.indexOf('async function shipMain'));
   const claimFound = main.indexOf("const ac = claims.find(");
   const ask = main.indexOf('runFirstShipAsk(');
@@ -171,7 +171,7 @@ test('shipMain asks after finding the claim and before the budget cap and grader
 });
 
 test('the --ship-mode flag is documented in the ship usage banner', () => {
-  const src = fs.readFileSync(path.join(ROOT, 'scripts', 'gds', 'ship.js'), 'utf8');
+  const src = fs.readFileSync(path.join(ROOT, 'scripts', 'bongos', 'ship.js'), 'utf8');
   assert.match(src, /--ship-mode auto\|manual/);
 });
 

package/tests/ship_mode_hands_off.mjs

@@ -23,11 +23,11 @@ import { fileURLToPath } from 'node:url';
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 
-const { npmSpawnOpts, listAvailableVersions } = require('../scripts/gds/update-channel.js');
-const { STARTER_ALLOW } = require('../scripts/gds/claude-materialize.js');
+const { npmSpawnOpts, listAvailableVersions } = require('../scripts/bongos/update-channel.js');
+const { STARTER_ALLOW } = require('../scripts/bongos/claude-materialize.js');
 const {
   MANUAL_ASK_EXIT, MANUAL_ASK_MARKER, APPROVED_FLAG, manualShipVerdict, manualAskLines,
-} = require('../scripts/gds/ship-mode-manual.js');
+} = require('../scripts/bongos/ship-mode-manual.js');
 
 // ---- 1. npm on Windows -----------------------------------------------------
 
@@ -45,7 +45,7 @@ test('the registry read passes the platform spawn options to npm', () => {
 });
 
 test('the upgrade\'s npm install uses the same spawn options', () => {
-  const src = fs.readFileSync(path.join(ROOT, 'scripts', 'gds', 'upgrade.js'), 'utf8');
+  const src = fs.readFileSync(path.join(ROOT, 'scripts', 'bongos', 'upgrade.js'), 'utf8');
   const fn = src.slice(src.indexOf('function npmInstall'), src.indexOf('async function runMigrate'));
   assert.match(fn, /npmSpawnOpts\(\)/);
 });
@@ -67,7 +67,7 @@ test('the starter never pre-allows WRITING the ship mode', () => {
 // ---- 3. the instance CLAUDE.md ---------------------------------------------
 
 test('a new project\'s CLAUDE.md tells the AI to follow the ship mode and never hand over commands', () => {
-  const tpl = require('../scripts/gds/claude-md-template.js');
+  const tpl = require('../scripts/bongos/claude-md-template.js');
   const render = Object.values(tpl).find((v) => typeof v === 'function');
   const text = render({});
   assert.match(text, /npx bongos ship-mode/);
@@ -100,14 +100,14 @@ test('the ask names the task, both answers, the exact re-run, and forbids a yes
   const text = lines.join('\n');
   assert.ok(lines[0].startsWith(MANUAL_ASK_MARKER));
   assert.match(text, /ship task 7 now[\s\S]*Ship it, or Not yet/);
-  assert.match(text, /node scripts\/gds\/ship\.js 7 --summary "two words" --person-approved/);
+  assert.match(text, /node scripts\/(?:gds|bongos)\/ship\.js 7 --summary "two words" --person-approved/);
   assert.match(text, /Never add the flag without their yes/);
   assert.equal(MANUAL_ASK_EXIT, 5);
 });
 
 // ---- 5. the wiring ---------------------------------------------------------
 
-const flowSrc = () => fs.readFileSync(path.join(ROOT, 'scripts', 'gds', 'ship-flow.js'), 'utf8');
+const flowSrc = () => fs.readFileSync(path.join(ROOT, 'scripts', 'bongos', 'ship-flow.js'), 'utf8');
 
 test('the Manual check stops with cliExit and returns, never a hard exit after a request', () => {
   const src = flowSrc();
@@ -142,5 +142,5 @@ test('a re-grade asks before it can pass into finishShip (direct --regrade and t
 });
 
 test('--person-approved is documented in the ship usage banner', () => {
-  assert.match(fs.readFileSync(path.join(ROOT, 'scripts', 'gds', 'ship.js'), 'utf8'), /--person-approved/);
+  assert.match(fs.readFileSync(path.join(ROOT, 'scripts', 'bongos', 'ship.js'), 'utf8'), /--person-approved/);
 });

package/tests/ship_post_land_verify.mjs

@@ -27,7 +27,7 @@
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const ship = require('../scripts/gds/ship.js');
+const ship = require('../scripts/bongos/ship.js');
 const { normalizeApiError, postLandShipOutcome } = ship;
 
 let passed = 0;

package/tests/ship_preflight.mjs

@@ -17,7 +17,7 @@ const {
   untrackedPaths, untrackedLeftBehind, untrackedWarningLines,
 } = require('../modules/lifecycle/ship-preflight.js');
 // task 1001436: the preflight step itself + the ship-input resolver it is handed.
-const { preflight, shipInputPaths, staleToolingFiles, TOOLING_PATHSPECS } = require('../scripts/gds/ship-preflight-steps.js');
+const { preflight, shipInputPaths, staleToolingFiles, TOOLING_PATHSPECS } = require('../scripts/bongos/ship-preflight-steps.js');
 
 const tests = [];
 const test = (name, fn) => tests.push({ name, fn });
@@ -69,11 +69,11 @@ test('trackedDirty: modified tracked file blocks', () => {
 });
 
 test('trackedDirty: staged + index-and-worktree changes block', () => {
-  const out = 'M  scripts/gds/ship.js\nMM src/bongos/routes/tasks.js\nA  migrations/099_x.sql\nD  old/gone.js\n';
+  const out = 'M  scripts/bongos/ship.js\nMM src/bongos/routes/tasks.js\nA  migrations/099_x.sql\nD  old/gone.js\n';
   assert.deepEqual(trackedDirty(out).sort(), [
     'migrations/099_x.sql',
     'old/gone.js',
-    'scripts/gds/ship.js',
+    'scripts/bongos/ship.js',
     'src/bongos/routes/tasks.js',
   ]);
 });
@@ -129,7 +129,7 @@ test('classifyEmptyShip: --allow-empty does NOT override a dirty/untracked tree'
 });
 
 test('classifyEmptyShip: tracked-dirty + empty diff → REFUSE (uncommitted-work)', () => {
-  const v = classifyEmptyShip(' M scripts/gds/ship.js\n', { allowEmpty: false });
+  const v = classifyEmptyShip(' M scripts/bongos/ship.js\n', { allowEmpty: false });
   assert.equal(v.refuse, true);
   assert.equal(v.reason, 'uncommitted-work');
 });
@@ -389,10 +389,10 @@ test('closeoutPlan: untracked-only scratch counts as leftover (preflight lets it
 });
 
 test('closeoutPlan: tracked + untracked mix → all paths, clean:false', () => {
-  const out = ' M scripts/gds/ship.js\n?? scratch.txt\nR  a.js -> b.js\n';
+  const out = ' M scripts/bongos/ship.js\n?? scratch.txt\nR  a.js -> b.js\n';
   const plan = closeoutPlan(out);
   assert.equal(plan.clean, false);
-  assert.deepEqual(plan.leftover, ['scripts/gds/ship.js', 'scratch.txt', 'b.js']);
+  assert.deepEqual(plan.leftover, ['scripts/bongos/ship.js', 'scratch.txt', 'b.js']);
 });
 
 // task 1004254: the close-out REPORTS leftovers and leaves them in place. The
@@ -400,7 +400,7 @@ test('closeoutPlan: tracked + untracked mix → all paths, clean:false', () => {
 // builder's scratch (and an owner's review renders) where another agent's pop
 // could apply it to the wrong branch. Run the real close-out in a throwaway repo.
 test('postShipCloseout: lists leftovers, leaves them in place, never touches the stash', () => {
-  const { postShipCloseout } = require('../scripts/gds/ship-finish.js');
+  const { postShipCloseout } = require('../scripts/bongos/ship-finish.js');
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'closeout-'));
   const prevCwd = process.cwd();
   const origLog = console.log;
@@ -435,7 +435,7 @@ test('postShipCloseout: lists leftovers, leaves them in place, never touches the
 });
 
 test('postShipCloseout: a clean tree reports archive-ready', () => {
-  const { postShipCloseout } = require('../scripts/gds/ship-finish.js');
+  const { postShipCloseout } = require('../scripts/bongos/ship-finish.js');
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'closeout-'));
   const prevCwd = process.cwd();
   const origLog = console.log;
@@ -617,10 +617,10 @@ test('stale-tooling guard: every tracked ship*.js and grader file is covered by
   const ls = (...spec) => execSync(`git ls-files -z -- ${spec.map((s) => `'${s}'`).join(' ')}`, { cwd: root, encoding: 'utf8' })
     .split('\0').filter(Boolean);
   // Chosen by an independent rule (the filename), then asked of git's own pathspec matcher.
-  const shipTooling = ls('scripts/gds', 'modules/grading').filter((f) =>
-    /^scripts\/gds\/ship[^/]*\.js$/.test(f) || /^modules\/grading\/(?:grader|grade-engine)/.test(f));
+  const shipTooling = ls('scripts/bongos', 'modules/grading').filter((f) =>
+    /^scripts\/(?:gds|bongos)\/ship[^/]*\.js$/.test(f) || /^modules\/grading\/(?:grader|grade-engine)/.test(f));
   assert.ok(shipTooling.length >= 25, `only ${shipTooling.length} ship/grader file(s) found — the scan is reading the wrong tree`);
-  assert.ok(shipTooling.includes('scripts/gds/ship-land.js') && shipTooling.includes('modules/grading/grader-score.js'));
+  assert.ok(shipTooling.includes('scripts/bongos/ship-land.js') && shipTooling.includes('modules/grading/grader-score.js'));
   const covered = new Set(ls(...TOOLING_PATHSPECS));
   const missed = shipTooling.filter((f) => !covered.has(f));
   assert.deepEqual(missed, [], `ship/grade tooling the stale-tooling guard would not refuse: ${missed.join(', ')}`);
@@ -631,9 +631,9 @@ const publishMain = (run) => run(['git', 'push', '-q', 'origin', 'main'].join('
 
 test('preflight (real git): main moved a carved ship-*.js and added a new grader file → refused stale-tooling', () => {
   withPreflightRepo(({ work, run }) => {
-    fs.mkdirSync(path.join(work, 'scripts', 'gds'), { recursive: true });
+    fs.mkdirSync(path.join(work, 'scripts', 'bongos'), { recursive: true });
     fs.mkdirSync(path.join(work, 'modules', 'grading'), { recursive: true });
-    fs.writeFileSync(path.join(work, 'scripts', 'gds', 'ship-land.js'), '// v1\n');
+    fs.writeFileSync(path.join(work, 'scripts', 'bongos', 'ship-land.js'), '// v1\n');
     fs.writeFileSync(path.join(work, 'modules', 'grading', 'grader-score.js'), '// v1\n');
     run('git add -A && git commit -q -m tooling');
     publishMain(run);
@@ -642,7 +642,7 @@ test('preflight (real git): main moved a carved ship-*.js and added a new grader
     run('git add -A && git commit -q -m work');
     // main moves: one carved file changes, one file appears that this checkout never had.
     run('git checkout -q main');
-    fs.writeFileSync(path.join(work, 'scripts', 'gds', 'ship-land.js'), '// v2\n');
+    fs.writeFileSync(path.join(work, 'scripts', 'bongos', 'ship-land.js'), '// v2\n');
     fs.writeFileSync(path.join(work, 'modules', 'grading', 'grader-new.js'), '// new carve\n');
     run('git add -A && git commit -q -m "main moves the tooling"');
     publishMain(run);
@@ -652,20 +652,20 @@ test('preflight (real git): main moved a carved ship-*.js and added a new grader
     const { result, out } = capturePreflight({ task_id: 4244, head_sha: null }, {});
     assert.equal(result.ok, false);
     assert.equal(result.reason, 'stale-tooling');
-    assert.match(out, /- scripts\/gds\/ship-land\.js/, 'a carved ship-*.js is tooling');
+    assert.match(out, /- scripts\/(?:gds|bongos)\/ship-land\.js/, 'a carved ship-*.js is tooling');
     assert.match(out, /- modules\/grading\/grader-new\.js/, 'a file only main has is still matched');
-    assert.deepEqual(staleToolingFiles({ cwd: work }).sort(), ['modules/grading/grader-new.js', 'scripts/gds/ship-land.js']);
+    assert.deepEqual(staleToolingFiles({ cwd: work }).sort(), ['modules/grading/grader-new.js', 'scripts/bongos/ship-land.js']);
   });
 });
 
 test('preflight (real git): the branch\'s OWN edit to a ship-*.js is not stale tooling', () => {
   withPreflightRepo(({ work, run }) => {
-    fs.mkdirSync(path.join(work, 'scripts', 'gds'), { recursive: true });
-    fs.writeFileSync(path.join(work, 'scripts', 'gds', 'ship-land.js'), '// v1\n');
+    fs.mkdirSync(path.join(work, 'scripts', 'bongos'), { recursive: true });
+    fs.writeFileSync(path.join(work, 'scripts', 'bongos', 'ship-land.js'), '// v1\n');
     run('git add -A && git commit -q -m tooling');
     publishMain(run);
     run('git checkout -q -b feature');
-    fs.writeFileSync(path.join(work, 'scripts', 'gds', 'ship-land.js'), '// the fix this task ships\n');
+    fs.writeFileSync(path.join(work, 'scripts', 'bongos', 'ship-land.js'), '// the fix this task ships\n');
     run('git add -A && git commit -q -m "fix the land"');
     const { result } = capturePreflight({ task_id: 4245, head_sha: null }, {});
     assert.equal(result.ok, true);

package/tests/ship_premerge.mjs

@@ -12,7 +12,7 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const ship = require('../scripts/gds/ship.js');
+const ship = require('../scripts/bongos/ship.js');
 
 let passed = 0, failed = 0;
 function t(name, fn) {

package/tests/ship_publish_error.mjs

@@ -1,6 +1,6 @@
 // tests/ship_publish_error.mjs
 //
-// Unit tests for formatPublishFailure (scripts/gds/ship.js, task 1001916) — the
+// Unit tests for formatPublishFailure (scripts/bongos/ship.js, task 1001916) — the
 // display string ciLandServer prints when POST /tasks/:id/publish-branch fails.
 //
 // Why this exists: the server has carried { step, reason } (the credential-
@@ -21,7 +21,7 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const ship = require('../scripts/gds/ship.js');
+const ship = require('../scripts/bongos/ship.js');
 
 let passed = 0;
 let failed = 0;

package/tests/ship_push_diagnosis.mjs

@@ -21,7 +21,7 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const { pushDiagnosis, PUSH_DIAGNOSES } = require(path.join(ROOT, 'scripts', 'gds', 'ship-land.js'));
+const { pushDiagnosis, PUSH_DIAGNOSES } = require(path.join(ROOT, 'scripts', 'bongos', 'ship-land.js'));
 
 test('THE case that stranded two tasks: the workflow scope rejection', () => {
   // GitHub's real wording, verbatim from the run that stranded task 1003283.

package/tests/ship_regen_copy_inventory.mjs

@@ -28,7 +28,7 @@ const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..
 const read = (rel) => readFileSync(path.join(REPO_ROOT, rel), 'utf8');
 
 test('ship-regen exports regenerateCopyInventory beside its siblings', () => {
-  const regen = require('../scripts/gds/ship-regen.js');
+  const regen = require('../scripts/bongos/ship-regen.js');
   assert.equal(typeof regen.regenerateCopyInventory, 'function');
   // The siblings it must sit beside — if one of these disappears the convention moved
   // and this file should move with it, rather than silently guarding nothing.
@@ -38,7 +38,7 @@ test('ship-regen exports regenerateCopyInventory beside its siblings', () => {
 });
 
 test('the merge path CALLS it — the whole bug was that nobody did', () => {
-  const src = read('scripts/gds/ship-merge.js');
+  const src = read('scripts/bongos/ship-merge.js');
   assert.match(src, /regenerateCopyInventory\(\)/,
     'ship-merge must invoke it, not merely import it');
   // Called on the same beat as the other generated artifacts, not somewhere that runs
@@ -50,7 +50,7 @@ test('the merge path CALLS it — the whole bug was that nobody did', () => {
 });
 
 test('fitness gates the pair, so a local run says so before CI does', () => {
-  const src = read('scripts/gds/fitness.js');
+  const src = read('scripts/bongos/fitness.js');
   assert.match(src, /copy-inventory\.js.*--check|'--check'\]/s);
   assert.ok(src.includes("'copy-inventory.js'"),
     'the freshness check must run copy-inventory --check');

package/tests/ship_resume.mjs

@@ -1,7 +1,7 @@
 // tests/ship_resume.mjs
 //
 // Unit tests for task 941 (V4.R03 — idempotent ship re-drive): a CLAIM-LESS
-// `node scripts/gds/ship.js <id>` re-run resumes from the leg it stalled on
+// `node scripts/bongos/ship.js <id>` re-run resumes from the leg it stalled on
 // instead of dead-ending at "you don't have an active claim".
 //
 // The claim is consumed at the resolve step, so a ship that fails AFTER it
@@ -20,7 +20,7 @@ import { createRequire } from 'node:module';
 import { shipCliSource } from './helpers.mjs';
 
 const require = createRequire(import.meta.url);
-const ship = require('../scripts/gds/ship.js');
+const ship = require('../scripts/bongos/ship.js');
 const { evaluateResumeAction, shouldConfirmWithoutGrade } = ship;
 
 let passed = 0;
@@ -173,7 +173,7 @@ test('an UNTRACKED deliverable is refused even under --allow-empty (task 1363)',
 
 test('a tracked-but-uncommitted edit is refused under --allow-empty too', () => {
   const v = shouldConfirmWithoutGrade({
-    committedFileCount: 0, porcelain: ' M scripts/gds/ship.js', args: ['1003146', '--allow-empty'],
+    committedFileCount: 0, porcelain: ' M scripts/bongos/ship.js', args: ['1003146', '--allow-empty'],
   });
   assert.equal(v.confirm, false);
   assert.equal(v.reason, 'uncommitted-work');
@@ -207,7 +207,7 @@ test('the re-grade decision and the FIRST-ship decision agree on the same tree',
   // same rule: for every tree, the re-grade verdict must equal what classifyEmptyShip
   // — the function the first ship calls — says about it. A re-divergence reds here.
   const { classifyEmptyShip } = require('../modules/lifecycle/ship-preflight');
-  for (const porcelain of ['', '?? docs/new.md', ' M scripts/gds/ship.js', '!! node_modules/x', 'A  a.js\n?? b.js']) {
+  for (const porcelain of ['', '?? docs/new.md', ' M scripts/bongos/ship.js', '!! node_modules/x', 'A  a.js\n?? b.js']) {
     for (const args of [['--allow-empty'], []]) {
       const first = classifyEmptyShip(porcelain, { allowEmpty: args.includes('--allow-empty') });
       const resume = shouldConfirmWithoutGrade({ committedFileCount: 0, porcelain, args });

package/tests/ship_smoke_gate.mjs

@@ -14,7 +14,7 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const { smokeGateMessages } = require('../scripts/gds/ship-honesty.js');
+const { smokeGateMessages } = require('../scripts/bongos/ship-honesty.js');
 
 let passed = 0;
 let failed = 0;

package/tests/ship_upload_skip.mjs

@@ -15,7 +15,7 @@ import os from 'node:os';
 import path from 'node:path';
 
 const require = createRequire(import.meta.url);
-const ship = require('../scripts/gds/ship.js');
+const ship = require('../scripts/bongos/ship.js');
 
 let passed = 0;
 let failed = 0;

package/tests/ship_upstream_deletion.mjs

@@ -16,7 +16,7 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const { parseDeletedUpstreamPaths } = require('../scripts/gds/ship.js');
+const { parseDeletedUpstreamPaths } = require('../scripts/bongos/ship.js');
 
 let passed = 0;
 let failed = 0;