@bongos/core 1.21.175 → 1.21.177

package/tests/blockers_page_ui.mjs

@@ -31,6 +31,8 @@ import { makeRunner, makeEl, walk } from './helpers.mjs';
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const HALL = path.join(ROOT, 'modules/hall-ui/public');
 const HALL_KIT_SRC = fs.readFileSync(path.join(HALL, 'hall-kit.js'), 'utf8');
+// blockers.html loads hall-ask.js before blockers.js; a reviewer row is its card.
+const HALL_ASK_SRC = fs.readFileSync(path.join(HALL, 'hall-ask.js'), 'utf8');
 const BLOCKERS_JS_SRC = fs.readFileSync(path.join(HALL, 'blockers.js'), 'utf8');
 
 const require = createRequire(import.meta.url);
@@ -53,7 +55,11 @@ function fail(status, code, message) { return { status, ok: false, data: { error
 
 async function boot(opts = {}) {
   const {
+    // What GET /me reports for blocker.review (task 1004824 — the page mirrors
+    // the atom, not the rank). `permissions: null` models an unreadable map.
     rank = 'archon',
+    review = true,
+    permissions = undefined,
     rows = DEFAULT_ROWS,
     meDelayMs = 0,
     meFails = false,
@@ -76,7 +82,7 @@ async function boot(opts = {}) {
         if (meDelayMs) await tick(meDelayMs);
         requests.push({ method, path: p, body });
         if (meFails) return fail(401, 'auth_needed', 'sign in');
-        return ok({ builder: { id: 1, rank } });
+        return ok({ builder: { id: 1, rank }, permissions: permissions === undefined ? { 'blocker.review': review } : permissions });
       }
       requests.push({ method, path: p, body });
       if (method === 'POST' && url === '/blockers') {
@@ -133,12 +139,13 @@ async function boot(opts = {}) {
   };
   vm.createContext(sandbox);
   vm.runInContext(HALL_KIT_SRC, sandbox, { filename: 'hall-kit.js' });
+  vm.runInContext(HALL_ASK_SRC, sandbox, { filename: 'hall-ask.js' });
   vm.runInContext(BLOCKERS_JS_SRC, sandbox, { filename: 'blockers.js' });
   await settle();
 
   const body = () => documentObj.getElementById('blockers-body');
   const fileArea = () => documentObj.getElementById('blockers-file-area');
-  const rowsOf = () => body().querySelectorAll('.ov-row');
+  const rowsOf = () => [...body().querySelectorAll('li')].filter((el) => /(^|\s)(ov-row|hask)(\s|$)/.test(el.className || ''));
   const requestsTo = (method, re) => requests.filter((r) => r.method === method && re.test(r.path));
 
   // The FILE form's open/cancel buttons and its own submit carry a DIRECT
@@ -192,7 +199,7 @@ await test('the reverse order (viewer known first) already worked, and still doe
 });
 
 await test('a non-reviewer sees the row with no Resolve/Link controls at all', async () => {
-  const h = await boot({ rank: 'xenos' });
+  const h = await boot({ rank: 'xenos', review: false });
   const row = h.rowsOf()[0];
   assert.equal(row.querySelector('[data-resolve-open]'), null);
   assert.equal(row.querySelector('[data-link-open]'), null);
@@ -210,7 +217,7 @@ await test('a signed-out visitor (GET /me fails) sees the queue with no reviewer
 // ===========================================================================
 
 await test('filing alone (no task #) posts once and toasts the filed id', async () => {
-  const h = await boot({ rank: 'xenos' });
+  const h = await boot({ rank: 'xenos', review: false });
   h.click(h.fileOpenBtn());
   const form = h.fileForm();
   form.querySelector('#bf-title').value = 'Need a decision';
@@ -223,7 +230,7 @@ await test('filing alone (no task #) posts once and toasts the filed id', async
 });
 
 await test('filing WITH a task # does both in the one submit, and toasts success', async () => {
-  const h = await boot({ rank: 'xenos' });
+  const h = await boot({ rank: 'xenos', review: false });
   h.click(h.fileOpenBtn());
   const form = h.fileForm();
   form.querySelector('#bf-title').value = 'Need a decision';
@@ -236,13 +243,13 @@ await test('filing WITH a task # does both in the one submit, and toasts success
 });
 
 await test('a non-reviewer filer who names a task the link 403s on still gets an HONEST message — filing is not a silent no-op', async () => {
-  const h = await boot({ rank: 'xenos', linkResponse: fail(403, 'permission_forbidden', 'nope') });
+  const h = await boot({ rank: 'xenos', review: false, linkResponse: fail(403, 'permission_forbidden', 'nope') });
   h.click(h.fileOpenBtn());
   const form = h.fileForm();
   form.querySelector('#bf-title').value = 'Need a decision';
   form.querySelector('#bf-task-id').value = '5001';
   await h.submit(form);
-  assert.ok(h.toasts.some((t) => t === 'Blocker #900 filed. You need Metic+ access to do that.'),
+  assert.ok(h.toasts.some((t) => t === 'Blocker #900 filed. You can’t resolve or link blockers here.'),
     `expected the honest fallback, got: ${JSON.stringify(h.toasts)}`);
 });
 
@@ -308,7 +315,7 @@ await test('a 403 on resolve renders HONEST copy and leaves the form open — ne
   await h.settle();
   const form = h.body().querySelector('[data-resolve-form]');
   await h.submitRow(form);
-  assert.equal(form.querySelector('[data-err]').textContent, 'You need Metic+ access to do that.');
+  assert.equal(form.querySelector('[data-err]').textContent, 'You can’t resolve or link blockers here.');
 });
 
 await test('resolving through the shared #/blocker/N overlay (otb:blocker-resolved) reloads this page\'s queue too', async () => {
@@ -323,11 +330,48 @@ await test('resolving through the shared #/blocker/N overlay (otb:blocker-resolv
   assert.equal(after, before + 1, 'the queue re-fetched exactly once in response to the event');
 });
 
-await test('the sub-line reason prose has ONE source (blockers.html); JS never carries a copy (task 1003985)', () => {
+await test('no top block: the page head carries only its h1, and the JS writes no sub-line (task 1004824)', () => {
   const html = fs.readFileSync(path.join(HALL, 'blockers.html'), 'utf8');
-  // Wording is the artist's (page tweak, task 1004348); the invariant is the single source.
-  assert.match(html, /Any tasks awaiting the same block will unblock automatically on resolution/, 'the static sub-line keeps the prose');
-  assert.doesNotMatch(BLOCKERS_JS_SRC, /unblock automatically on resolution|gated at the owner level/, 'blockers.js must not duplicate the prose');
+  const head = html.slice(html.indexOf('class="page-head'), html.indexOf('</div>', html.indexOf('class="page-head')));
+  assert.doesNotMatch(head, /page-head__sub|blockers-sub/, 'the hidden head holds no tagline');
+  assert.doesNotMatch(BLOCKERS_JS_SRC, /blockers-sub|baseSub/, 'blockers.js no longer paints a sub-line');
+  assert.match(html, /class="scroll__h">Requires project owner fix</, 'the list is named the way Home names it');
+});
+
+// ===========================================================================
+// The controls follow the PERMISSION the server checks, never the rank (task 1004824)
+// ===========================================================================
+
+await test('an Archon WITHOUT blocker.review sees no Resolve/Link — the page mirrors the atom, not the rank', async () => {
+  const h = await boot({ rank: 'archon', review: false });
+  const row = h.rowsOf()[0];
+  assert.equal(row.querySelector('[data-resolve-open]'), null);
+  assert.equal(row.querySelector('[data-link-open]'), null);
+});
+
+await test('a Xenos the government granted blocker.review DOES get Resolve/Link', async () => {
+  const h = await boot({ rank: 'xenos', review: true });
+  const row = h.rowsOf()[0];
+  assert.ok(row.querySelector('[data-resolve-open]'));
+  assert.ok(row.querySelector('[data-link-open]'));
+});
+
+await test('an unreadable permissions map (null) hides the controls — never assumed held', async () => {
+  const h = await boot({ rank: 'archon', permissions: null });
+  assert.equal(h.rowsOf()[0].querySelector('[data-resolve-open]'), null);
+});
+
+await test('a reviewer row is the ask card with ONE decision; Link a task is a plain control', async () => {
+  const h = await boot({ review: true });
+  const card = h.rowsOf()[0];
+  assert.match(card.className, /(^|\s)hask(\s|$)/, 'the row is the shared ask card');
+  const chips = card.querySelectorAll('.hask__opt');
+  assert.equal(chips.length, 1, 'resolving is the only answer on the card');
+  assert.ok(chips[0].querySelector('[data-resolve-open]') || chips[0].attrs['data-resolve-open'], 'the one answer is Resolve it');
+  const link = card.querySelector('[data-link-open]');
+  assert.ok(link, 'Link a task is still offered to a reviewer');
+  assert.doesNotMatch(link.className, /hask__opt/, 'linking a task stays a plain button, not a card answer');
+  assert.equal(card.querySelectorAll('.hask__where').length, 0, 'the repeated "Waiting on the project owner" eyebrow is gone');
 });
 
 summary();

package/tests/bongos_dispatch.mjs

@@ -2,7 +2,7 @@
 //
 // DB-free unit test: it only inspects the static verb table and spawns the
 // help/unknown/bare paths (which return before touching the network). Picked up
-// automatically by scripts/gds/run-unit-tests.js (the `unit` gate).
+// automatically by scripts/bongos/run-unit-tests.js (the `unit` gate).
 import assert from 'node:assert/strict';
 import { test } from 'node:test';
 import { existsSync } from 'node:fs';
@@ -23,19 +23,19 @@ test('every required verb is registered', () => {
 
 test('every mapped script exists on disk (a typo cannot ship a dead verb)', () => {
   for (const [verb, def] of Object.entries(VERBS)) {
-    if (!def.script) continue; // special verbs (exec) dispatch without a backing scripts/gds/ file
+    if (!def.script) continue; // special verbs (exec) dispatch without a backing scripts/bongos/ file
     const p = path.join(GDS_DIR, def.script);
-    assert.ok(existsSync(p), `verb "${verb}" -> missing script scripts/gds/${def.script}`);
+    assert.ok(existsSync(p), `verb "${verb}" -> missing script scripts/bongos/${def.script}`);
   }
 });
 
 test('`bongos exec` runs a package script and refuses a path escape (ADR 0108 §3 / W3)', () => {
   const { resolveExecTarget } = bongos;
-  assert.ok(resolveExecTarget('scripts/gds/next-number.js'), 'a package-relative script resolves');
+  assert.ok(resolveExecTarget('scripts/bongos/next-number.js'), 'a package-relative script resolves');
   assert.equal(resolveExecTarget('/etc/passwd'), null, 'an absolute path is refused');
   assert.equal(resolveExecTarget('../../../etc/passwd'), null, 'a `..` escape is refused');
   // end-to-end: exec a harmless core script (next-number prints + exits 0)
-  const r = spawnSync(process.execPath, [BIN, 'exec', 'scripts/gds/next-number.js', '--json'], { encoding: 'utf8' });
+  const r = spawnSync(process.execPath, [BIN, 'exec', 'scripts/bongos/next-number.js', '--json'], { encoding: 'utf8' });
   assert.equal(r.status, 0, r.stderr);
   assert.match(r.stdout, /"migration"/, 'exec forwarded to the core script and returned its output');
   // refusal path exits 2 with guidance

package/tests/bongos_login.mjs

@@ -13,8 +13,8 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
-const { normalizeInstanceBase, pollDecision } = require('../scripts/gds/login.js');
-const LOGIN_JS = path.join(path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'), 'scripts', 'gds', 'login.js');
+const { normalizeInstanceBase, pollDecision } = require('../scripts/bongos/login.js');
+const LOGIN_JS = path.join(path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'), 'scripts', 'bongos', 'login.js');
 
 test('normalizeInstanceBase adds https, strips trailing slashes + a pasted /api/bongos', () => {
   assert.equal(normalizeInstanceBase('example.com'), 'https://example.com');

package/tests/bug_attachment_audit.mjs

@@ -21,7 +21,7 @@ import assert from 'node:assert/strict';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const { describedAttachments, auditRows } = require('../scripts/gds/bug-attachment-audit.js');
+const { describedAttachments, auditRows } = require('../scripts/bongos/bug-attachment-audit.js');
 const { attachmentsDir } = require('../modules/discord/bug-attachments.js');
 const path = require('node:path');
 

package/tests/bug_attachment_recover.mjs

@@ -20,7 +20,7 @@ const require = createRequire(import.meta.url);
 const TMP = path.join(os.tmpdir(), `otb-bugrecover-${process.pid}`);
 process.env.BUG_ATTACHMENTS_DIR = TMP;
 const at = require('../modules/discord/bug-attachments.js');
-const rec = require('../scripts/gds/bug-attachment-recover.js');
+const rec = require('../scripts/bongos/bug-attachment-recover.js');
 
 let passed = 0, failed = 0;
 function t(name, fn) {
@@ -115,7 +115,7 @@ await t('recoverMessage: the attachment download keeps the CDN host allowlist',
 });
 
 await t('the audit no longer claims a lost file cannot be re-fetched, and points at this tool', async () => {
-  const src = await fs.readFile(new URL('../scripts/gds/bug-attachment-audit.js', import.meta.url), 'utf8');
+  const src = await fs.readFile(new URL('../scripts/bongos/bug-attachment-audit.js', import.meta.url), 'utf8');
   assert.ok(!/cannot be re-fetched/i.test(src));
   assert.match(src, /bug-attachment-recover\.js --missing/);
   const mod = await fs.readFile(new URL('../modules/discord/bug-attachments.js', import.meta.url), 'utf8');

package/tests/bug_triage.mjs

@@ -26,7 +26,7 @@ const require = createRequire(import.meta.url);
 // { ok, data, status } responses, and record every call for assertion.
 const calls = [];
 let responses = {};
-const cliLib = require('../scripts/gds/cli-lib.js');
+const cliLib = require('../scripts/bongos/cli-lib.js');
 cliLib.cliClient = async () => ({
   tasks: {
     getTasks: async (args) => { calls.push({ method: 'getTasks', args }); return responses.getTasks; },
@@ -35,8 +35,8 @@ cliLib.cliClient = async () => ({
   },
 });
 
-const { clusterRecords } = require('../scripts/gds/triage.js');
-const { listOpenBugTasks, mergeTaskInto, dismissTask, OPEN_STATUSES } = require('../scripts/gds/bug-triage.js');
+const { clusterRecords } = require('../scripts/bongos/triage.js');
+const { listOpenBugTasks, mergeTaskInto, dismissTask, OPEN_STATUSES } = require('../scripts/bongos/bug-triage.js');
 
 const { test, summary } = makeRunner();
 

package/tests/build_info.mjs

@@ -12,7 +12,7 @@ import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
 const { resolveCommit } = require('../src/build-info.js');
-const { deployedCommitStatus } = require('../scripts/gds/ship.js');
+const { deployedCommitStatus } = require('../scripts/bongos/ship.js');
 
 let passed = 0;
 let failed = 0;

package/tests/builder_tester_tag.mjs

@@ -0,0 +1,184 @@
+// tests/builder_tester_tag.mjs
+//
+// Task 1004845 / migration core_278 — the tester tag. An account marked is_tester
+// keeps everything but drops out of the public leaderboard and the any-builder
+// directory; the management reads still see it, so an Archon can untag it.
+//
+// DB-free: the shared pool's query() is replaced with a recorder, so what is pinned
+// is the SQL each read sends and the parameter that flips it, not Postgres.
+//
+// Run:  node tests/builder_tester_tag.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import { makeRunner } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const { pool } = require('../src/bongos/pool');
+const { test, summary } = makeRunner();
+
+const sent = [];
+pool.query = async (sql, params) => { sent.push({ sql: String(sql), params: params || [] }); return { rows: [] }; };
+const last = () => sent[sent.length - 1];
+
+await test('migration: one NOT NULL boolean, false by default, recorded', () => {
+  const sql = fs.readFileSync(new URL('../migrations/core_278_builder_tester_tag.sql', import.meta.url), 'utf8');
+  assert.match(sql, /ALTER TABLE builders ADD COLUMN IF NOT EXISTS is_tester boolean NOT NULL DEFAULT false/);
+  assert.match(sql, /VALUES \('core_278_builder_tester_tag'\)/);
+});
+
+await test('the directory read leaves testers out by default', async () => {
+  const { listActiveBuilders } = require('../src/bongos/db-kernel');
+  await listActiveBuilders();
+  assert.match(last().sql, /is_tester = false OR \$1::boolean/);
+  assert.deepEqual(last().params, [false]);
+});
+
+await test('a management read can ask for testers, and only by saying so', async () => {
+  const { listActiveBuilders } = require('../src/bongos/db-kernel');
+  await listActiveBuilders({ includeTesters: true });
+  assert.deepEqual(last().params, [true]);
+  await listActiveBuilders({});
+  assert.deepEqual(last().params, [false]);
+});
+
+await test('the leaderboard excludes testers', async () => {
+  const { leaderboard } = require('../modules/economy/credits.js');
+  await leaderboard(10);
+  assert.match(last().sql, /WHERE is_tester = false/);
+});
+
+await test('the public leaderboard with achievements excludes testers', async () => {
+  const { getLeaderboardWithAchievements } = require('../modules/economy/achievements.js');
+  await getLeaderboardWithAchievements(10);
+  assert.match(last().sql, /WHERE b\.is_tester = false/);
+});
+
+// A pool whose connect() hands out a client that answers each statement from a script.
+function scriptedClient(answers) {
+  const seen = [];
+  const client = {
+    query: async (sql, params) => {
+      const text = String(sql);
+      seen.push({ sql: text, params: params || [] });
+      if (/^(BEGIN|COMMIT|ROLLBACK)/.test(text)) return { rows: [] };
+      return { rows: answers.shift() ?? [] };
+    },
+    release() {},
+  };
+  return { client, seen };
+}
+
+await test('setBuilderTester locks the row, then writes the flag for an ordinary builder', async () => {
+  const db = require('../src/bongos/db');
+  const { client, seen } = scriptedClient([[{ id: 5, system_role: null }], [{ id: 5, is_tester: true }]]);
+  pool.connect = async () => client;
+  const out = await db.setBuilderTester({ builderId: 5, isTester: true });
+  assert.deepEqual(out, { id: 5, is_tester: true });
+  const work = seen.filter((q) => !/^(BEGIN|COMMIT|ROLLBACK)/.test(q.sql));
+  assert.ok(work[0].sql.includes('SELECT id, system_role FROM builders WHERE id = $1 FOR UPDATE'));
+  assert.ok(work[1].sql.includes('UPDATE builders SET is_tester = $2 WHERE id = $1'));
+  assert.deepEqual(work[1].params, [5, true]);
+});
+
+await test('setBuilderTester reports a missing builder as null and writes nothing', async () => {
+  const db = require('../src/bongos/db');
+  const { client, seen } = scriptedClient([[]]);
+  pool.connect = async () => client;
+  assert.equal(await db.setBuilderTester({ builderId: 9, isTester: true }), null);
+  assert.ok(!seen.some((q) => /UPDATE builders/.test(q.sql)), 'no UPDATE for a missing builder');
+});
+
+await test('setBuilderTester refuses a machine principal and never writes it', async () => {
+  const db = require('../src/bongos/db');
+  const { client, seen } = scriptedClient([[{ id: 3, system_role: 'discord_bot' }]]);
+  pool.connect = async () => client;
+  await assert.rejects(() => db.setBuilderTester({ builderId: 3, isTester: true }), (e) => e.code === 'TARGET_IS_SYSTEM_PRINCIPAL');
+  assert.ok(!seen.some((q) => /UPDATE builders/.test(q.sql)), 'no UPDATE for a system account');
+  assert.ok(seen.some((q) => /^ROLLBACK/.test(q.sql)), 'the transaction rolled back');
+});
+
+await test('the roster read carries is_tester so the Archon can untag', () => {
+  const src = fs.readFileSync(new URL('../modules/lifecycle/db-ship.js', import.meta.url), 'utf8');
+  assert.match(src, /b\.status,\s+b\.is_tester,/);
+});
+
+// The REAL route, pulled out of the real router: its last layer is the inline handler
+// (the gate layers sit before it), so the guards are driven exactly as mounted.
+const buildBuildersRouter = require('../src/bongos/routes/builders.js');
+const realDb = require('../src/bongos/db');
+const testerLayer = buildBuildersRouter().stack.find((l) => l.route && l.route.path === '/builders/:id/tester' && l.route.methods.patch);
+assert.ok(testerLayer, 'PATCH /builders/:id/tester is mounted');
+const testerHandler = testerLayer.route.stack[testerLayer.route.stack.length - 1].handle;
+
+// A res that records instead of writing; fail() takes (code, status) or (code, { status }).
+function fakeRes() {
+  const rec = { json: null, fail: null };
+  return {
+    rec,
+    json(body) { rec.json = body; return this; },
+    fail(code, second) {
+      const status = (second && typeof second === 'object') ? second.status : second;
+      rec.fail = { code, status };
+      return this;
+    },
+  };
+}
+async function drive({ viewer = 1, id = '7', body = { is_tester: true }, setBuilderTester } = {}) {
+  const calls = [];
+  const original = realDb.setBuilderTester;
+  realDb.setBuilderTester = async (a) => { calls.push(a); return setBuilderTester ? setBuilderTester(a) : { id: Number(id), is_tester: a.isTester }; };
+  const res = fakeRes();
+  try {
+    await testerHandler({ builder: { id: viewer }, params: { id }, body }, res);
+  } finally {
+    realDb.setBuilderTester = original;
+  }
+  return { res, calls };
+}
+
+await test('the route tags another builder and says so', async () => {
+  const { res, calls } = await drive({ id: '7', body: { is_tester: true } });
+  assert.deepEqual(calls, [{ builderId: 7, isTester: true }]);
+  assert.deepEqual(res.rec.json, { builder: { id: 7, is_tester: true } });
+});
+
+await test('the route refuses your own account with 403 and writes nothing', async () => {
+  const { res, calls } = await drive({ viewer: 7, id: '7' });
+  assert.deepEqual(res.rec.fail, { code: 'cannot_change_own_tester', status: 403 });
+  assert.equal(calls.length, 0);
+});
+
+await test('the route turns a machine principal into target_is_system_principal', async () => {
+  const { res } = await drive({ setBuilderTester: async () => { throw { code: 'TARGET_IS_SYSTEM_PRINCIPAL' }; } });
+  assert.equal(res.rec.fail.code, 'target_is_system_principal');
+  assert.equal(res.rec.fail.status, 403);
+});
+
+await test('the route answers 404 for a missing builder and 500 for a real failure', async () => {
+  assert.equal((await drive({ setBuilderTester: async () => null })).res.rec.fail.status, 404);
+  const boom = await drive({ setBuilderTester: async () => { throw new Error('db down'); } });
+  assert.equal(boom.res.rec.fail.code, 'tester_change_failed');
+  assert.equal(boom.res.rec.fail.status, 500);
+});
+
+await test('the route refuses a body that is not a boolean', async () => {
+  const { res, calls } = await drive({ body: { is_tester: 'yes' } });
+  assert.ok(res.rec.fail, 'refused');
+  assert.equal(calls.length, 0);
+});
+
+await test('the route stays behind the status permission', () => {
+  const src = fs.readFileSync(new URL('../src/bongos/routes/builders.js', import.meta.url), 'utf8');
+  assert.ok(src.includes("router.patch('/builders/:id/tester', auth.requireBuilder, auth.requirePermission('builder.status.set'), async (req, res)"));
+});
+
+await test('both refusal codes are registered as permanent, so neither reads as a retryable fault', () => {
+  const { classify } = require('../src/bongos/api-errors.js');
+  for (const code of ['cannot_change_own_tester', 'target_is_system_principal']) {
+    assert.equal(classify(code), 'forbidden', code);
+  }
+});
+
+summary();

package/tests/bump_version.mjs

@@ -21,7 +21,7 @@ import { shallowCloneReason } from './helpers.mjs';
 const require = createRequire(import.meta.url);
 const ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
 
-const bump = require(path.join(ROOT, 'scripts', 'gds', 'bump-version.js'));
+const bump = require(path.join(ROOT, 'scripts', 'bongos', 'bump-version.js'));
 const { bumpPatch, CONST_RE } = bump;
 // The LIVE test below reads this repo's real release history (task 1003202).
 const { execFileSync } = require('node:child_process');
@@ -111,7 +111,7 @@ test('the REAL src/module-api.js + ledger are bumpable right now (shape not drif
 
 test('the ledger is NOT a .js file — the ratchet that forced the move stays satisfied', () => {
   // ADR 0203: the carrier appends on every release and pushes straight to main.
-  // Inside a .js file that growth trips scripts/gds/fitness-ratchets.js's
+  // Inside a .js file that growth trips scripts/bongos/fitness-ratchets.js's
   // oversized_file_count (it counts `git ls-files '*.js'`) and turns `unit` red
   // for main and every open PR at once. Markdown is the whole fix.
   const rel = 'docs/module-api-changelog.md';
@@ -132,7 +132,7 @@ test('the ledger is NOT a .js file — the ratchet that forced the move stays sa
 // and pin that a HUMAN release commit never matches (skipping one would
 // swallow its publish entirely).
 
-const { isReleaseCommit, RELEASE_COMMIT_RE } = require(path.join(ROOT, 'scripts', 'gds', 'bump-version.js'));
+const { isReleaseCommit, RELEASE_COMMIT_RE } = require(path.join(ROOT, 'scripts', 'bongos', 'bump-version.js'));
 const PUBLISH_YML = fs.readFileSync(path.join(ROOT, '.github', 'workflows', 'publish.yml'), 'utf8');
 
 test('matches the exact -m subject publish.yml writes (extracted, not retyped)', () => {

package/tests/canonical_profile_url.mjs

@@ -484,7 +484,7 @@ test('the resolver is the ONLY place that spells the canonical namespace', () =>
 // ===========================================================================
 
 test('this proof runs in the DB-free lane that executes on every PR', () => {
-  const runner = read('scripts', 'gds', 'run-unit-tests.js');
+  const runner = read('scripts', 'bongos', 'run-unit-tests.js');
   assert.ok(
     !/canonical_profile_url/.test(runner),
     'named in run-unit-tests.js means parked into INTEGRATION or KNOWN_FAILING — where CI has no Postgres, this file would self-skip forever and gate nothing (learning 1000218)',

package/tests/capture_error_format.mjs

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

package/tests/capture_goal_routing.mjs

@@ -17,8 +17,8 @@ import { makeRunner } from './helpers.mjs';
 const require = createRequire(import.meta.url);
 const { test, summary } = makeRunner();
 
-const capture = require('../scripts/gds/capture.js');
-const CAPTURE_SRC = readFileSync(new URL('../scripts/gds/capture.js', import.meta.url), 'utf8');
+const capture = require('../scripts/bongos/capture.js');
+const CAPTURE_SRC = readFileSync(new URL('../scripts/bongos/capture.js', import.meta.url), 'utf8');
 
 // A stub of the generated typed client (triage.js / promote_goal_id.mjs's
 // pattern): records every call, answers from a fixed script. `client` is the

package/tests/category_advisory_guard.mjs

@@ -14,7 +14,7 @@ import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
 const { checkCategoryIsAdvisory, scanGates, scanAnchors, GATE_FILES, FEATURE_ANCHORS, stripComments } =
-  require('../scripts/gds/category-advisory-guard.js');
+  require('../scripts/bongos/category-advisory-guard.js');
 
 let passed = 0;
 let failed = 0;
@@ -57,7 +57,7 @@ test('the plural, the past tense and the raw table name are all caught', () => {
     'if (!goal.categorised) return refuse();',
     "await pool.query('SELECT slug FROM work_categories');",
   ]) {
-    const { violations } = scanGates(['scripts/gds/gating.js'], from({ 'scripts/gds/gating.js': `${line}\n` }));
+    const { violations } = scanGates(['scripts/bongos/gating.js'], from({ 'scripts/bongos/gating.js': `${line}\n` }));
     assert.equal(violations.length, 1, `not caught: ${line}`);
   }
 });
@@ -143,7 +143,7 @@ test('a quoted path to a file whose NAME contains "category" is not a violation'
   const { violations } = scanGates(['src/bongos/module-scope-map.js'], from({
     'src/bongos/module-scope-map.js':
       'const MAP = {\n'
-      + "  devsecops: { globs: ['scripts/gds/category-advisory-guard.js', 'scripts/gds/fitness.js'] },\n"
+      + "  devsecops: { globs: ['scripts/bongos/category-advisory-guard.js', 'scripts/bongos/fitness.js'] },\n"
       + '};\n',
   }));
   assert.deepEqual(violations, [], 'owning the tooling by path is not branching on a category');

package/tests/claim_error_surface.mjs

@@ -16,7 +16,7 @@ import { createRequire } from 'node:module';
 import { readFileSync } from 'node:fs';
 
 const require = createRequire(import.meta.url);
-const { formatClaimFailure, claimErrorInfo, goalMembershipOfferPlan, worktreeDetectionNote } = require('../scripts/gds/claim.js');
+const { formatClaimFailure, claimErrorInfo, goalMembershipOfferPlan, worktreeDetectionNote } = require('../scripts/bongos/claim.js');
 
 let passed = 0;
 let failed = 0;
@@ -232,7 +232,7 @@ t('REBASE_REQUIRED: names the owed tasks and relays the server hint', () => {
 });
 
 t('REBASE_REQUIRED exits with its OWN code, so an unattended caller can tell a queue gate from a task refusal (task 1004396)', () => {
-  const { QUEUE_GATED_EXIT } = require('../scripts/gds/claim.js');
+  const { QUEUE_GATED_EXIT } = require('../scripts/bongos/claim.js');
   assert.equal(formatClaimFailure(envelope('REBASE_REQUIRED', {}), 5).exit, QUEUE_GATED_EXIT);
   assert.notEqual(QUEUE_GATED_EXIT, 1);
   assert.equal(formatClaimFailure(envelope('ALREADY_CLAIMED', {}), 5).exit, 1, 'a per-task refusal keeps exit 1');

package/tests/claim_from_task_and_home.mjs

@@ -123,7 +123,7 @@ await test('builders.js wires the Next-up claim action rather than hand-rolling
 });
 
 await test('the claim wiring landed in the renderer, not back over the 1,500-line ratchet', () => {
-  // Not a second copy of fitness.js's own gate (scripts/gds/fitness-ratchets.js)
+  // Not a second copy of fitness.js's own gate (scripts/bongos/fitness-ratchets.js)
   // — this is the reason wireNextUpClaim moved to hall-render.js in the first
   // place (see its own comment): a regression here explains WHY that file grew,
   // not just THAT some file grew.

package/tests/claim_gate_open_blocker.mjs

@@ -47,14 +47,17 @@ const ok = (cond, msg) => { assert.ok(cond, msg); console.log(`  ok  ${msg}`); p
 
 try {
   await cleanup();
-  await q(`INSERT INTO versions (id,name,status,track) VALUES ($1,'ob','planning','internal') ON CONFLICT (id) DO NOTHING`, [VER]);
+  // 'building', not 'planning': at most one version may plan (versions_one_planning_idx,
+  // core_233) and the seeds already hold that slot, so a 'planning' row here fails setup (task 1004861).
+  await q(`INSERT INTO versions (id,name,status,track) VALUES ($1,'ob','building','internal') ON CONFLICT (id) DO NOTHING`, [VER]);
   // Archon so no rank/newcomer gate interferes; the gate under test is OPEN_BLOCKER.
   await q(`INSERT INTO builders (id,github_id,github_login,display_name,rank) VALUES ($1,'ob-w','ob-worker','OB Worker','archon')`, [WORKER]);
   // TRAP: ready (feed-hidden) with an open blocker linked. CONTROL: ready, clean.
-  await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind) VALUES ($1,$2,'trap','ready',10,'feature')`, [TRAP, VER]);
-  await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind) VALUES ($1,$2,'control','ready',10,'feature')`, [CONTROL, VER]);
+  await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind,discipline) VALUES ($1,$2,'trap','ready',10,'feature','engineer')`, [TRAP, VER]);
+  await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind,discipline) VALUES ($1,$2,'control','ready',10,'feature','engineer')`, [CONTROL, VER]);
   await q(`INSERT INTO blockers (id,title,status) VALUES ($1,'Owner must flip the switch','open')`, [BLOCKER]);
-  await q(`INSERT INTO task_blockers (task_id,blocker_id) VALUES ($1,$2)`, [TRAP, BLOCKER]);
+  // blocker_ref is NOT NULL and part of the key; linkBlockerToTask writes 'blocker:<id>'.
+  await q(`INSERT INTO task_blockers (task_id,blocker_id,blocker_ref) VALUES ($1,$2,$3)`, [TRAP, BLOCKER, `blocker:${BLOCKER}`]);
 
   // 1) Direct claim-by-id is refused with OPEN_BLOCKER, naming the blocker.
   let threw = null;