@bongos/core 1.21.174 → 1.21.176

package/tests/status_default_version.mjs

@@ -1,7 +1,7 @@
 // tests/status_default_version.mjs — /status resolves its default version at
 // RUNTIME and never falls back to a sealed one (task 1004071).
 //
-// THE INCIDENT. `scripts/gds/status.js:29` read
+// THE INCIDENT. `scripts/bongos/status.js:29` read
 //   const DEFAULT_VERSION = resolveEnv('STATUS_DEFAULT_VERSION') || 'BONGOS-V1';
 // while the comment three lines above stated the rule it was meant to keep:
 // "the bare /status card should default to the live version, not a sealed one."
@@ -30,7 +30,7 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const status = require(path.join(ROOT, 'scripts', 'gds', 'status.js'));
+const status = require(path.join(ROOT, 'scripts', 'bongos', 'status.js'));
 const { parseArgs, resolveVersion } = status;
 
 // A deps bundle with nothing configured: no env override, nothing building.
@@ -107,7 +107,7 @@ test('THE INCIDENT: when nothing is building we return null, never a sealed gues
 test('a resolved default never returns a SHIPPED version', async () => {
   // Wired through the real selection rule rather than a stub, so this test fails
   // if pickDefaultVersion is ever loosened to fall back to the newest-any-status.
-  const { pickDefaultVersion } = require(path.join(ROOT, 'scripts', 'gds', 'version-select.js'));
+  const { pickDefaultVersion } = require(path.join(ROOT, 'scripts', 'bongos', 'version-select.js'));
   const versions = [
     { id: 'BONGOS-V1', status: 'shipped', started_at: '2026-06-20' },
     { id: 'CB-V1', status: 'shipped', started_at: '2026-06-21' },

package/tests/status_mirror_sync.mjs

@@ -107,7 +107,7 @@ test('brand tokens resolve from the INJECTED brand, not ambient config', () => {
 });
 
 test('the publisher source hardcodes no host identity (the ratchet this slice installs)', () => {
-  // Mirrors scripts/gds/fitness.js stripCommentsForIdentity: block comments, then
+  // Mirrors scripts/bongos/fitness.js stripCommentsForIdentity: block comments, then
   // `://`-safe line comments split on /\r?\n/ — NOT '\n'. On this CRLF checkout a
   // '\n' split leaves a trailing \r that `.*$` can never cross, so no line comment
   // would strip and rationale prose would scan as code (the task 1002428 bug).

package/tests/status_page_no_dead_uptime.mjs

@@ -0,0 +1,80 @@
+// tests/status_page_no_dead_uptime.mjs
+//
+// Task 1004858. The in-process uptime poller (src/bongos/uptime-poller.js) was
+// never started by anything, so GET /public/uptime only ever answered
+// "unknown" with an empty history and the status page drew a panel (and a
+// headline "city's standing" card) that could never say anything. All of it was
+// removed. These checks keep it removed, and keep the page coherent:
+//
+//   - the status page neither fetches the dead feed nor draws its panel/card;
+//   - every sticky-nav section and every headline element status.js looks up
+//     actually exists in index.html (a removed section can't leave a dead chip);
+//   - the server no longer registers the route;
+//   - the core package exports nothing that points at a missing file, and the
+//     cutover codemod maps nothing the package doesn't export.
+//
+// Run: node tests/status_page_no_dead_uptime.mjs
+
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { readFileSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const read = (rel) => readFileSync(join(ROOT, rel), 'utf8');
+
+const STATUS_JS = read('modules/status-ui/public/status.js');
+const INDEX_HTML = read('modules/status-ui/public/index.html');
+
+test('the status page does not fetch the removed uptime feed', () => {
+  assert.ok(!STATUS_JS.includes('/public/uptime'), 'status.js still fetches /public/uptime');
+});
+
+test('the uptime panel and the standing card are gone from the page', () => {
+  for (const id of ['uptime-tablet', 'id="uptime"', 'headline-standing']) {
+    assert.ok(!INDEX_HTML.includes(id), `index.html still carries ${id}`);
+  }
+  assert.ok(!/aggregateStanding|loadUptime/.test(STATUS_JS), 'status.js still carries the uptime renderers');
+});
+
+test('every sticky-nav section names a section that exists on the page', () => {
+  const block = STATUS_JS.match(/const SECTIONS = \[([\s\S]*?)\];/);
+  assert.ok(block, 'SECTIONS constant not found in status.js');
+  const ids = [...block[1].matchAll(/id:\s*'([^']+)'/g)].map((m) => m[1]);
+  assert.ok(ids.length >= 3, 'expected several nav sections');
+  for (const id of ids) {
+    assert.ok(INDEX_HTML.includes(`id="${id}"`), `nav chip "${id}" points at a section index.html does not have`);
+  }
+});
+
+test('every headline element loadHeadline looks up exists in index.html', () => {
+  const body = STATUS_JS.slice(STATUS_JS.indexOf('async function loadHeadline()'));
+  const fn = body.slice(0, body.indexOf('\n}\n'));
+  const ids = [...fn.matchAll(/getElementById\('([^']+)'\)/g)].map((m) => m[1]);
+  assert.ok(ids.length > 0, 'loadHeadline looks nothing up — the test is reading the wrong span');
+  for (const id of ids) assert.ok(INDEX_HTML.includes(`id="${id}"`), `loadHeadline reads #${id}, which index.html lacks`);
+  const cards = (INDEX_HTML.match(/class="stat headline-stat"/g) || []).length;
+  const cols = Number((read('modules/status-ui/public/style.css').match(/\.headline-grid \{[^}]*repeat\((\d+), 1fr\)/) || [])[1]);
+  assert.equal(cols, cards, 'the headline grid has one column per headline card');
+});
+
+test('the server no longer registers GET /public/uptime', () => {
+  assert.ok(!read('src/bongos/routes/public.js').includes("'/public/uptime'"), 'routes/public.js still mounts /public/uptime');
+  assert.ok(!existsSync(join(ROOT, 'src/bongos/uptime-poller.js')), 'the never-started poller is back');
+  assert.ok(!existsSync(join(ROOT, 'scripts/status-probe.mjs')), 'the orphaned prober script is back');
+});
+
+test('the core package exports only files that exist, and the codemod maps only exported subpaths', () => {
+  const { buildPackageJson } = require('../scripts/bongos/package-core.js');
+  const pkg = buildPackageJson({ version: '1.0.0', sourceDeps: { express: '^4.0.0', pg: '^8.0.0', pino: '^9.0.0' } });
+  for (const [sub, target] of Object.entries(pkg.exports)) {
+    assert.ok(existsSync(join(ROOT, target)), `export ${sub} points at missing ${target}`);
+  }
+  const { CORE_INTERNAL_MAP } = require('../scripts/bongos/cutover-codemod.js');
+  for (const [from, to] of Object.entries(CORE_INTERNAL_MAP)) {
+    assert.ok(pkg.exports[`./${to}`], `codemod maps ${from} → ./${to}, which the package does not export`);
+  }
+});

package/tests/stop_refcheck.mjs

@@ -18,7 +18,7 @@ import path from 'node:path';
 const require = createRequire(import.meta.url);
 // The Stop hook lives in .claude/hooks/, which the neutral core does NOT carry:
 // it's instance-materialized and package-excluded (PROTECTED_TOPOLOGY_EXCLUDE in
-// scripts/gds/publish-manifest.js). A clean core checkout therefore has no hook to
+// scripts/bongos/publish-manifest.js). A clean core checkout therefore has no hook to
 // require — an unconditional require() threw MODULE_NOT_FOUND and CRASHED this file
 // at load (uncaught, printing a requireStack), red-Xing the unit gate (task 1002234).
 // Skip cleanly when the hook is absent; the suite still runs in full on an instance

package/tests/strand_watch.mjs

@@ -15,7 +15,7 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const sw = require('../scripts/gds/strand-watch.js');
+const sw = require('../scripts/bongos/strand-watch.js');
 
 let passed = 0, failed = 0;
 // AWAITS fn. The first cut of this harness called fn() synchronously, so the four async

package/tests/stranded_rows.mjs

@@ -14,7 +14,7 @@ import assert from 'node:assert/strict';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const { authoredIds, scanLog, strandedRows, pageOpenRows, SEP } = require('../scripts/gds/stranded-rows.js');
+const { authoredIds, scanLog, strandedRows, pageOpenRows, SEP } = require('../scripts/bongos/stranded-rows.js');
 
 test('a subject naming the task it did IS an authoring claim', () => {
   assert.deepEqual([...authoredIds('fix(docs): self-healing /docs/openapi.json (task 1002200)')], ['1002200']);

package/tests/stuck_detector.mjs

@@ -25,7 +25,7 @@ const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const strikes = requireHostModule(require, '../.claude/hooks/stuck-strikes.js');
 const detector = require('../.claude/hooks/stuck-detector.js');
-const { plainCardLines, CARDS } = require('../scripts/gds/plain-cards.js');
+const { plainCardLines, CARDS } = require('../scripts/bongos/plain-cards.js');
 
 let passed = 0;
 let failed = 0;
@@ -62,18 +62,18 @@ t('a waiting card ("Nothing to do…") is not a wall — polling it is what its
 
 t('the task id is the one the CLI was handed, not any number on the line', () => {
   const id = (cmd) => detector.wallsIn(cmd, card('TASK_NOT_READY')).taskId;
-  assert.equal(id('node scripts/gds/claim.js 1003990 --worktree task-1003990'), '1003990');
-  assert.equal(id('node scripts/gds/claim.js --worktree task-1003990 1003990'), '1003990');
-  assert.equal(id('cd "C:/x y/task-77" && node "C:/x y/scripts/gds/ship.js" --regrade 1003848 --notes "3 of 404 pages"'), '1003848');
+  assert.equal(id('node scripts/bongos/claim.js 1003990 --worktree task-1003990'), '1003990');
+  assert.equal(id('node scripts/bongos/claim.js --worktree task-1003990 1003990'), '1003990');
+  assert.equal(id('cd "C:/x y/task-77" && node "C:/x y/scripts/bongos/ship.js" --regrade 1003848 --notes "3 of 404 pages"'), '1003848');
   assert.equal(id('bongos claim 7'), '7', 'a fresh instance numbers its tasks from 1');
-  assert.equal(id('timeout 120 node scripts/gds/start.js'), '');
+  assert.equal(id('timeout 120 node scripts/bongos/start.js'), '');
 });
 
 t('only a builder CLI run can hit a wall — reading a file that quotes a card cannot', () => {
-  for (const cmd of ['cat docs/session-logs/x.md', 'git diff', 'grep -A5 otb-plain tests/stuck_detector.mjs', 'cat scripts/gds/claim.js | node -e ""']) {
+  for (const cmd of ['cat docs/session-logs/x.md', 'git diff', 'grep -A5 otb-plain tests/stuck_detector.mjs', 'cat scripts/bongos/claim.js | node -e ""']) {
     assert.deepEqual(detector.wallsIn(cmd, card('REBASE_REQUIRED')).walls, [], cmd);
   }
-  assert.equal(detector.wallsIn('node node_modules/@cloudbongos/core/scripts/gds/claim.js 5', card('REBASE_REQUIRED')).walls.length, 1);
+  assert.equal(detector.wallsIn('node node_modules/@cloudbongos/core/scripts/bongos/claim.js 5', card('REBASE_REQUIRED')).walls.length, 1);
 });
 
 t('parallel hook processes cannot wipe each other: the counter is append-only', () => {
@@ -94,7 +94,7 @@ t('recordStrike counts per session and per signature, and never throws', () => {
 // ---- kind 1: the same refused claim ----------------------------------------
 t('the same refused claim: silent twice, one instruction on the third', () => {
   const out = `Claim refused: 409 REBASE_REQUIRED\n${card('REBASE_REQUIRED')}`;
-  const p = bash('s-claim', 'node scripts/gds/claim.js 1003848 --worktree task-1003848', out);
+  const p = bash('s-claim', 'node scripts/bongos/claim.js 1003848 --worktree task-1003848', out);
   for (let i = 0; i < 2; i++) {
     const r = run('stuck-detector', p);
     assert.equal(r.status, 0);
@@ -113,7 +113,7 @@ t('the same refused claim: silent twice, one instruction on the third', () => {
 t('a different task id is a different wall', () => {
   const out = card('ALREADY_CLAIMED');
   for (const id of ['2001', '2002', '2003']) {
-    assert.equal(run('stuck-detector', bash('s-ids', `node scripts/gds/claim.js ${id}`, out)).stdout, '');
+    assert.equal(run('stuck-detector', bash('s-ids', `node scripts/bongos/claim.js ${id}`, out)).stdout, '');
   }
 });
 
@@ -121,7 +121,7 @@ t('a different task id is a different wall', () => {
 t('the same red check: third identical RED names the diagnostic path', () => {
   const red = '  ci-land: the PR is RED — tests/security.mjs failed. Reproduce with `node tests/<name>.mjs`, fix it';
   const out = `${red}\n${card('failing_check')}\n${card('land_pending')}`;
-  const p = bash('s-red', 'node scripts/gds/ship.js 1003848 --notes x --summary y', out);
+  const p = bash('s-red', 'node scripts/bongos/ship.js 1003848 --notes x --summary y', out);
   run('stuck-detector', p); run('stuck-detector', p);
   const ctx = injected(run('stuck-detector', p));
   assert.match(ctx, /same failure 3 times/);
@@ -132,7 +132,7 @@ t('the same red check: third identical RED names the diagnostic path', () => {
 t('a red check that names DIFFERENT failing tests each time is progress, not a wall', () => {
   for (const name of ['a', 'b', 'c']) {
     const out = `  ci-land: the PR is RED — tests/${name}.mjs failed.\n${card('failing_check')}`;
-    assert.equal(run('stuck-detector', bash('s-progress', 'node scripts/gds/ship.js 77001', out)).stdout, '');
+    assert.equal(run('stuck-detector', bash('s-progress', 'node scripts/bongos/ship.js 77001', out)).stdout, '');
   }
 });
 
@@ -146,7 +146,7 @@ t('resultText reads the output from whichever field the harness used', () => {
 // A refusal exits non-zero; whether that routes to PostToolUse or PostToolUseFailure is
 // the harness's business, so the hook is wired on both and answers as whichever fired.
 t('a failed tool call (PostToolUseFailure: error_message, no tool_response) still counts', () => {
-  const p = { session_id: 's-fail', hook_event_name: 'PostToolUseFailure', tool_name: 'PowerShell', tool_input: { command: 'node scripts/gds/claim.js 555' }, error_message: `exit 1\n${card('DEPS_NOT_SHIPPED')}` };
+  const p = { session_id: 's-fail', hook_event_name: 'PostToolUseFailure', tool_name: 'PowerShell', tool_input: { command: 'node scripts/bongos/claim.js 555' }, error_message: `exit 1\n${card('DEPS_NOT_SHIPPED')}` };
   run('stuck-detector', p); run('stuck-detector', p);
   const r = run('stuck-detector', p);
   assert.match(JSON.parse(r.stdout).hookSpecificOutput.hookEventName, /^PostToolUseFailure$/);
@@ -193,7 +193,7 @@ t('worktree-guard: the same wrong-tree file three times appends the instruction
 t('quiet on a clean run: no card → exit 0, no stdout, no stderr, nothing written', () => {
   const before = fs.readdirSync(DIR).length;
   for (const p of [
-    bash('s-quiet', 'node scripts/gds/claim.js 1003990', 'Claimed task 1003990\n[otb-confirm] claimed'),
+    bash('s-quiet', 'node scripts/bongos/claim.js 1003990', 'Claimed task 1003990\n[otb-confirm] claimed'),
     bash('s-quiet', 'npm test', 'FAIL tests/x.mjs'),
     { session_id: 's-quiet', tool_name: 'Read', tool_input: { file_path: 'x' } },
     {},
@@ -212,7 +212,7 @@ t('malformed stdin fails open and silent', () => {
 });
 
 t('kill-switch: BONGOS_STUCK_DETECTOR_OFF=1 silences the detector and the guard nudges', () => {
-  const p = bash('s-off', 'node scripts/gds/claim.js 9', card('TASK_NOT_READY'));
+  const p = bash('s-off', 'node scripts/bongos/claim.js 9', card('TASK_NOT_READY'));
   for (let i = 0; i < 4; i++) assert.equal(run('stuck-detector', p, { BONGOS_STUCK_DETECTOR_OFF: '1' }).stdout, '');
   const g = { session_id: 's-off-git', tool_name: 'Bash', tool_input: { command: 'git branch -D x' } };
   for (let i = 0; i < 4; i++) assert.ok(!run('git-guard', g, { BONGOS_STUCK_DETECTOR_OFF: '1' }).stderr.includes('[otb-stuck]'));

package/tests/sweep_app_account.mjs

@@ -43,8 +43,8 @@ function run(scriptPath, s, env = {}) {
   });
 }
 
-const STRAY = path.join(REPO, 'scripts', 'gds', 'stray-unit-sweep.sh');
-const PARK = path.join(REPO, 'scripts', 'gds', 'address-park-sweep.sh');
+const STRAY = path.join(REPO, 'scripts', 'bongos', 'stray-unit-sweep.sh');
+const PARK = path.join(REPO, 'scripts', 'bongos', 'address-park-sweep.sh');
 
 test('stray-unit-sweep: PROVISION_APP_USER is the account the ledger is read as', { skip }, () => {
   const s = stubs();
@@ -106,7 +106,7 @@ for (const [name, src] of [['address-park-sweep', PARK], ['stray-unit-sweep', ST
   test(`${name}: run from an instance's vendored core, the instance is three levels up and its owner acts`, { skip }, () => {
     const s = stubs();
     const inst = fs.mkdtempSync(path.join(os.tmpdir(), 'sweep-inst-'));
-    const gds = path.join(inst, 'node_modules', '@bongos', 'core', 'scripts', 'gds');
+    const gds = path.join(inst, 'node_modules', '@bongos', 'core', 'scripts', 'bongos');
     fs.mkdirSync(gds, { recursive: true });
     fs.copyFileSync(src, path.join(gds, `${name}.sh`));
     run(path.join(gds, `${name}.sh`), s);

package/tests/task_cli.mjs

@@ -1,7 +1,7 @@
 // tests/task_cli.mjs
 //
 // task 2123 (demo-audit fix C1) — locks the PURE argv→body mapping of the new
-// `bongos task new` command (scripts/gds/task.js). Hermetic: no session/DB/network
+// `bongos task new` command (scripts/bongos/task.js). Hermetic: no session/DB/network
 // (buildTaskBody never touches the API), so the pr-unit-tests gate auto-includes it.
 //
 // Run:  node tests/task_cli.mjs
@@ -10,7 +10,7 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const { buildTaskBody, VALID_KINDS, VALID_DISCIPLINES, csv, hallLink } = require('../scripts/gds/task.js');
+const { buildTaskBody, VALID_KINDS, VALID_DISCIPLINES, csv, hallLink } = require('../scripts/bongos/task.js');
 
 let passed = 0, failed = 0;
 function t(name, fn) {

package/tests/task_detail_ui.mjs

@@ -105,6 +105,9 @@ async function boot(opts = {}) {
     idea = DEFAULT_IDEA,
     blocker = DEFAULT_BLOCKER,
     rank = 'metic',
+    // task 1004824: the blocker panel mirrors the blocker.review ATOM off
+    // /me.permissions; by default it follows the rank's seeded floor.
+    review = undefined,
     versions = DEFAULT_VERSIONS,
     suggestions = DEFAULT_SUGGESTIONS,
     suggestDelayMs = {},
@@ -129,7 +132,7 @@ async function boot(opts = {}) {
       requests.push({ method, path: p, body });
       const url = p.replace('/api/bongos', '');
       const [route, query] = url.split('?');
-      if (method === 'GET' && route === '/me') return ok({ builder: { id: 1, rank } });
+      if (method === 'GET' && route === '/me') return ok({ builder: { id: 1, rank }, permissions: { 'blocker.review': review === undefined ? (rank === 'metic' || rank === 'archon') : review } });
       if (method === 'GET' && route === '/versions') return ok({ versions });
       if (method === 'GET' && route === '/goals/suggestions') {
         const version = new URLSearchParams(query || '').get('version');
@@ -290,6 +293,13 @@ await test('a Xenos gets the blocker card but no resolve panel (the server gate
   assert.equal(h.panel(), null, 'the action is not offered below Metic');
 });
 
+await test('the blocker panel follows the PERMISSION, not the rank (task 1004824)', async () => {
+  const granted = await boot({ kind: 'blocker', rank: 'xenos', review: true });
+  assert.ok(granted.panel(), 'a Xenos the government granted blocker.review gets Resolve');
+  const withheld = await boot({ kind: 'blocker', rank: 'archon', review: false });
+  assert.equal(withheld.panel(), null, 'an Archon without blocker.review does not');
+});
+
 await test('a resolved blocker offers no resolve panel, and says what closed it', async () => {
   const h = await boot({ kind: 'blocker', blocker: { ...DEFAULT_BLOCKER, status: 'resolved', resolution_note: 'raised the budget' } });
   assert.equal(h.panel(), null, 'a settled blocker has nothing left to decide');

package/tests/task_discipline_required.mjs

@@ -141,7 +141,7 @@ test('every direct createTask call site names a discipline or resolves one', ()
     ['modules/onboarding/newcomer-restock.js', /^\s*discipline,\s*$/m],
     ['modules/lifecycle/kickoff-seed.js', /discipline: t\.discipline \|\| 'engineer'/],
     ['modules/lifecycle/cascade.js', /discipline: rule\.discipline/],
-    ['scripts/gds/triage.js', /discipline: resolveWriteDiscipline\(/],
+    ['scripts/bongos/triage.js', /discipline: resolveWriteDiscipline\(/],
   ];
   for (const [rel, re] of sites) {
     const src = fs.readFileSync(path.join(ROOT, rel), 'utf8');
@@ -156,7 +156,7 @@ test('init.js no longer clobbers its own discipline default with undefined', ()
   // Comment lines are stripped first: the fix's own explanation names the old
   // expression, and a scan that cannot tell code from prose would either fail here
   // forever or be "fixed" by deleting the explanation.
-  const src = fs.readFileSync(path.join(ROOT, 'scripts', 'gds', 'init.js'), 'utf8')
+  const src = fs.readFileSync(path.join(ROOT, 'scripts', 'bongos', 'init.js'), 'utf8')
     .split('\n').filter((l) => !/^\s*(\/\/|\*|\/\*)/.test(l)).join('\n');
   assert.ok(!/discipline: undefined/.test(src), 'a later spread must not undo the default');
   assert.match(src, /discipline: t\.discipline \|\| 'engineer'/);

package/tests/task_list_paging.mjs

@@ -29,7 +29,7 @@ const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 
 const { TASK_LIST_MAX_LIMIT, buildTaskPageQuery } = require('../modules/lifecycle/task-list-limits.js');
-const { fetchAllTasks } = require('../scripts/gds/audit-deps.js');
+const { fetchAllTasks } = require('../scripts/bongos/audit-deps.js');
 
 let passed = 0, failed = 0;
 const t = async (n, f) => {

package/tests/task_visual_slots.mjs

@@ -24,7 +24,7 @@ const express = require('express');
 const api = require('../src/module-api.js');
 const visualDb = require('../modules/lifecycle/task-visual-db.js');
 const visuals = require('../modules/lifecycle/task-visuals.js');
-const renders = require('../scripts/gds/tweak-renders.js');
+const renders = require('../scripts/bongos/tweak-renders.js');
 
 const { test, summary } = makeRunner();
 
@@ -127,7 +127,7 @@ await test('shotsFor names one file per slot; a page pinning one mode is shot in
 });
 
 await test('planForPage reads the real inventory: an unknown page is refused, a known one has a url', () => {
-  const reader = require('../scripts/gds/page-reader.js');
+  const reader = require('../scripts/bongos/page-reader.js');
   const inventory = JSON.parse(fs.readFileSync(new URL('../docs/page-inventory.json', import.meta.url), 'utf8'));
   assert.equal(renders.planForPage('nope:nope', { inventory, planRenders: reader.planRenders }).code, 'unknown_page');
   const p = renders.planForPage(inventory.pages[0].id, { inventory, planRenders: reader.planRenders });

package/tests/terms_acceptance.mjs

@@ -963,7 +963,7 @@ for (const { file, fn, why } of TWIN_FED_READS) {
 console.log('\ncoverage:');
 
 t('this proof runs in the DB-free unit lane (it is not parked as integration or known-failing)', () => {
-  const runner = fs.readFileSync(path.join(repo, 'scripts', 'gds', 'run-unit-tests.js'), 'utf8');
+  const runner = fs.readFileSync(path.join(repo, 'scripts', 'bongos', 'run-unit-tests.js'), 'utf8');
   assert.ok(
     !/terms_acceptance/.test(runner),
     'terms_acceptance is named in run-unit-tests.js — parked into INTEGRATION or KNOWN_FAILING it would gate '

package/tests/terms_grandfather_db.mjs

@@ -14,7 +14,7 @@
 // column existing) starts from a genuinely fresh table every run.
 //
 // Real-DB integration test: self-skips without a reachable Postgres; in the
-// INTEGRATION set (scripts/gds/run-unit-tests.js) so the default DB-free lane
+// INTEGRATION set (scripts/bongos/run-unit-tests.js) so the default DB-free lane
 // never runs it.
 //
 // Run:  DATABASE_URL=... node tests/terms_grandfather_db.mjs

package/tests/test_path_guard.mjs

@@ -20,7 +20,7 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const { checkTestsUseFileUrlToPath, scanTests } = require('../scripts/gds/test-path-guard.js');
+const { checkTestsUseFileUrlToPath, scanTests } = require('../scripts/bongos/test-path-guard.js');
 
 let passed = 0;
 let failed = 0;

package/tests/triage_development.mjs

@@ -19,7 +19,7 @@ const {
   clusterIdeas,
   significantWords,
   jaccard,
-} = require('../scripts/gds/triage.js');
+} = require('../scripts/bongos/triage.js');
 
 let passed = 0;
 let failed = 0;

package/tests/tweak_batch_apply.mjs

@@ -22,9 +22,9 @@ import { fileURLToPath } from 'node:url';
 import { makeRunner } from './helpers.mjs';
 
 const require = createRequire(import.meta.url);
-const ci = require('../scripts/gds/copy-inventory.js');
+const ci = require('../scripts/bongos/copy-inventory.js');
 const pages = require('../modules/copy-desk/pages.js');
-const apply = require('../scripts/gds/copy-apply.js');
+const apply = require('../scripts/bongos/copy-apply.js');
 
 const { test, summary } = makeRunner();
 const REPO_ROOT = path.resolve(fileURLToPath(new URL('..', import.meta.url)));

package/tests/tweak_land_heal.mjs

@@ -29,8 +29,8 @@ import { fileURLToPath } from 'node:url';
 import { makeRunner } from './helpers.mjs';
 
 const require = createRequire(import.meta.url);
-const PR = require('../scripts/gds/page-reader.js');
-const regen = require('../scripts/gds/git-merge-regen.js');
+const PR = require('../scripts/bongos/page-reader.js');
+const regen = require('../scripts/bongos/git-merge-regen.js');
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const { test, summary } = makeRunner();
 
@@ -80,7 +80,7 @@ await test('.gitattributes routes docs/page-readings.json through the otb-regen
 });
 
 await test('WHOLE PATH: two rounds from one main both land; the second merges main with no person', () => {
-  const driver = path.join(ROOT, 'scripts/gds/git-merge-regen.js').replace(/\\/g, '/');
+  const driver = path.join(ROOT, 'scripts/bongos/git-merge-regen.js').replace(/\\/g, '/');
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'otb-tweak-land-'));
   const g = (...a) => {
     const r = spawnSync('git', a, { cwd: tmp, encoding: 'utf8' });

package/tests/tweak_unattended.mjs

@@ -30,7 +30,7 @@ const { test, summary } = makeRunner();
 
 // ---- 1. halts ---------------------------------------------------------------
 
-const halt = require('../scripts/gds/tweak-halt.js');
+const halt = require('../scripts/bongos/tweak-halt.js');
 
 await test('each ADR 0371 D8 halt has fixed wording; an unknown code has none', () => {
   for (const code of ['claim_refused', 'nothing_applied', 'ship_check_stale', 'grader_unavailable']) {
@@ -55,14 +55,14 @@ await test('a halt RELEASES the round through release.js, with the fixed note as
   assert.equal(exit, 0);
   assert.equal(calls.length, 1);
   const [script, task, flag, reason] = calls[0];
-  assert.match(script.replace(/\\/g, '/'), /scripts\/gds\/release\.js$/);
+  assert.match(script.replace(/\\/g, '/'), /scripts\/(?:gds|bongos)\/release\.js$/);
   assert.equal(task, '4321');
   assert.equal(flag, '--reason');
   assert.equal(reason, `[tweak-unattended:grader_unavailable] ${halt.HALT_NOTES.grader_unavailable}`);
 });
 
 await test('copy-apply --unattended releases on every non-zero batch exit (wired, not just documented)', () => {
-  const src = fs.readFileSync(path.join(ROOT, 'scripts/gds/copy-apply.js'), 'utf8');
+  const src = fs.readFileSync(path.join(ROOT, 'scripts/bongos/copy-apply.js'), 'utf8');
   const at = src.indexOf("hasFlag('--unattended') && code !== 0");
   assert.ok(at > 0, 'the unattended branch tests every non-zero exit');
   assert.ok(src.slice(at, at + 300).includes('halt.releaseWithNote(taskId, halt.haltForCopyApplyExit(code))'), 'and releases through tweak-halt');

package/tests/ui_design_skills.mjs

@@ -37,7 +37,7 @@ const read = (p) => fs.readFileSync(p, 'utf8').replace(/\r\n/g, '\n');
 const readJson = (p) => JSON.parse(fs.readFileSync(p, 'utf8'));
 const policy = readJson(path.join(SKILLS, 'policy.json'));
 const manifest = readJson(path.join(MODULE, 'module.json'));
-const materialize = require(path.join(ROOT, 'scripts', 'gds', 'claude-materialize.js'));
+const materialize = require(path.join(ROOT, 'scripts', 'bongos', 'claude-materialize.js'));
 
 // Minimal YAML-frontmatter reader: `key: value` lines between the first two `---`
 // fences, plus folded block scalars (`key: >-` then the text indented), which is the
@@ -366,7 +366,7 @@ test('every in-house skill works inside the world: the style library is the pale
 });
 
 test('the preamble copies are policy, not doc-entropy debt: the scanner skips the block and still flags a plain duplicate', () => {
-  const de = require(path.join(ROOT, 'scripts', 'gds', 'docs-entropy.js'));
+  const de = require(path.join(ROOT, 'scripts', 'bongos', 'docs-entropy.js'));
   const carriers = ['modules/design-styles/skills/PREAMBLE.md', ...ownDirs.map((n) => `modules/design-styles/skills/${n}/SKILL.md`)];
   assert.ok(carriers.length >= 2, 'at least one own skill carries the block beside PREAMBLE.md');
   for (const rel of carriers) assert.ok(read(path.join(ROOT, rel)).includes(policy.preamble.begin), `${rel} carries the block`);

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'/);