@bongos/core 1.21.175 → 1.21.176

package/tests/module_store_listing.mjs

@@ -34,6 +34,13 @@ const pool = {
           .map((v) => ({ ...v, version_id: v.id, title: state.modules[v.module_key].title })),
       };
     }
+    if (/FROM store_modules WHERE module_key = \$1/.test(sql)) {
+      const m = state.modules[params[0]];
+      return { rows: m ? [{ module_key: params[0], title: m.title, status: m.status, author_id: m.author_id ?? null }] : [] };
+    }
+    if (/FROM store_module_versions WHERE module_key = \$1/.test(sql)) {
+      return { rows: state.versions.filter((v) => v.module_key === params[0]).map((v) => ({ ...v, version_id: v.id })) };
+    }
     if (/FROM module_assessment_scores/.test(sql)) {
       const ids = params[0].map(String);
       const newest = new Map();
@@ -62,7 +69,7 @@ const poolPath = require.resolve('../src/bongos/pool.js');
 require.cache[poolPath] = { id: poolPath, filename: poolPath, loaded: true, exports: { pool: { connect: async () => ({ ...pool, release() {} }), query: pool.query } } };
 
 const buildModulesRouter = require('../src/bongos/routes/modules.js');
-const { QUALITY_FLOOR, SORT_PARTS, RANKING, placeVersion, sortByPart, priceOf, withinMaxPrice, rankListed } = require('../src/bongos/module-listing.js');
+const { QUALITY_FLOOR, SORT_PARTS, RANKING, placeVersion, sortByPart, priceOf, withinMaxPrice, rankListed, explainPlacement } = require('../src/bongos/module-listing.js');
 
 function handlerFor(router, method, p) {
   const layer = router.stack.find((l) => l.route && l.route.path === p && l.route.methods[method]);
@@ -80,7 +87,7 @@ async function invoke(handle, req) {
     fail(code, opts) { this.statusCode = opts.status; this.body = { error: code, ...opts }; return this; },
   };
   let nextErr = null;
-  await handle(req, res, (err) => { nextErr = err; });
+  await handle({ builder: { id: 0 }, ...req }, res, (err) => { nextErr = err; });
   if (nextErr) throw nextErr;
   return res;
 }
@@ -407,3 +414,133 @@ test('GET /store/modules: a maximum price that is not a whole number of 0 or mor
     assert.match(res.body.message, /maximum price/);
   }
 });
+
+// ---------------------------------------------------------------------------
+// why a module is or is not listed (task 1003810)
+// ---------------------------------------------------------------------------
+
+test('explainPlacement: every reason says why in a sentence and what would change it', () => {
+  const failedSec = { security: { outcome: 'failed', reason: 'a dependency has a known vulnerability' } };
+  for (const [placed, ctx] of [
+    [{ placement: 'excluded', reason: 'not_assessed' }, {}],
+    [{ placement: 'excluded', reason: 'security_not_passed' }, failedSec],
+    [{ placement: 'excluded', reason: 'security_not_passed' }, {}],
+    [{ placement: 'excluded', reason: 'no_score' }, {}],
+    [{ placement: 'excluded', reason: 'below_floor' }, { overall: 41 }],
+    [{ placement: 'excluded', reason: 'delisted' }, {}],
+    [{ placement: 'excluded', reason: 'no_version' }, {}],
+    [{ placement: 'new', reason: 'new' }, {}],
+  ]) {
+    const e = explainPlacement(placed, ctx);
+    assert.equal(e.reason, placed.reason);
+    assert.ok(e.why && e.next_step, `${placed.reason} needs a why and a next step`);
+    assert.equal(e.listed, placed.placement !== 'excluded');
+  }
+  const failed = explainPlacement({ placement: 'excluded', reason: 'security_not_passed' }, failedSec);
+  assert.match(failed.why, /failed the Security gate: a dependency has a known vulnerability/);
+  const pending = explainPlacement({ placement: 'excluded', reason: 'security_not_passed' }, {});
+  assert.match(pending.why, /has not finished/, 'not run yet is not the same as failed');
+  const listed = explainPlacement({ placement: 'listed', reason: 'at_or_above_floor' }, { overall: 70 });
+  assert.equal(listed.listed, true);
+  assert.equal(listed.next_step, null);
+});
+
+test('explainPlacement: below the floor names the score, the floor and the weakest parts', () => {
+  const e = explainPlacement({ placement: 'excluded', reason: 'below_floor' }, {
+    overall: 41, floor: 50,
+    weaknesses: [{ title: 'Tests', score: 10 }, { title: 'How-to', score: 30 }],
+  });
+  assert.match(e.why, /scored 41 out of 100/);
+  assert.match(e.why, /at least 50/);
+  assert.match(e.why, /weakest parts: Tests \(10\), How-to \(30\)/);
+});
+
+test('GET /store/modules/:key/listing: any signed-in builder, no extra permission', () => {
+  const { names } = handlerFor(buildModulesRouter(), 'get', '/store/modules/:key/listing');
+  assert.equal(names.length, 2, `expected requireBuilder + handler, got ${names.join(', ')}`);
+});
+
+test('GET /store/modules/:key/listing: below the floor says why, with the parts, judging the newest version', async () => {
+  state.modules = { low: { status: 'listed', title: 'Low' } };
+  state.versions = [
+    { id: 1, module_key: 'low', version: '1.0.0', published_at: 't1' },
+    { id: 2, module_key: 'low', version: '1.1.0', published_at: 't2' },
+  ];
+  state.scores = [
+    { id: 1, version_id: 1, computed_at: 1, ...score({ overall: 90 }) },
+    { id: 2, version_id: 2, computed_at: 1, ...score({ overall: 42 }) },
+  ];
+  state.signals = [
+    { id: 1, version_id: 2, part: 'security', outcome: 'passed', score: null, sample_size: null, measured_at: 1 },
+    { id: 2, version_id: 2, part: 'tests', outcome: 'scored', score: 20, sample_size: 4, measured_at: 1 },
+    { id: 3, version_id: 2, part: 'docs', outcome: 'scored', score: 85, sample_size: null, measured_at: 1 },
+  ];
+  const { handle } = handlerFor(buildModulesRouter(), 'get', '/store/modules/:key/listing');
+  const res = await invoke(handle, { params: { key: 'low' } });
+  assert.equal(res.statusCode, 200);
+  assert.equal(res.headers['Cache-Control'], 'no-store');
+  assert.equal(res.body.version, '1.1.0', 'the newest version is the one judged');
+  assert.equal(res.body.listed, false);
+  assert.equal(res.body.reason, 'below_floor');
+  assert.equal(res.body.overall, 42);
+  assert.match(res.body.why, /Tests \(20\)/);
+  assert.deepEqual(res.body.weaknesses.map((w) => w.part), ['tests']);
+  assert.deepEqual(res.body.strengths.map((w) => w.part), ['docs']);
+  assert.ok(res.body.unmeasured.some((u) => u.part === 'install'));
+  assert.deepEqual(res.body.security, { outcome: 'passed', reason: null });
+  state.signals = [];
+});
+
+test('GET /store/modules/:key/listing: a failed Security gate, a delisted module and an unknown key', async () => {
+  state.modules = { unsafe: { status: 'listed', title: 'Unsafe', author_id: 11 }, gone: { status: 'delisted', title: 'Gone' } };
+  state.versions = [
+    { id: 5, module_key: 'unsafe', version: '1.0.0', published_at: 't5' },
+    { id: 7, module_key: 'gone', version: '1.0.0', published_at: 't7' },
+  ];
+  state.scores = [
+    { id: 5, version_id: 5, computed_at: 1, ...score({ overall: 95, security_passed: false }) },
+    { id: 7, version_id: 7, computed_at: 1, ...score({ overall: 99 }) },
+  ];
+  state.signals = [{ id: 9, version_id: 5, part: 'security', outcome: 'failed', score: null, sample_size: null, reason: 'install script runs network code', measured_at: 1 }];
+  const { handle } = handlerFor(buildModulesRouter(), 'get', '/store/modules/:key/listing');
+
+  const author = await invoke(handle, { params: { key: 'unsafe' }, builder: { id: 11 } });
+  assert.equal(author.body.reason, 'security_not_passed');
+  assert.match(author.body.why, /install script runs network code/, 'the author is told what the gate found');
+
+  const stranger = await invoke(handle, { params: { key: 'unsafe' }, builder: { id: 12 } });
+  assert.equal(stranger.body.reason, 'security_not_passed');
+  assert.match(stranger.body.why, /failed the Security gate\./);
+  assert.ok(!JSON.stringify(stranger.body).includes('network code'), 'what the gate found is the author\'s alone');
+
+  const gone = await invoke(handle, { params: { key: 'gone' } });
+  assert.equal(gone.body.reason, 'delisted');
+  assert.equal(gone.body.listed, false);
+
+  const missing = await invoke(handle, { params: { key: 'nope' } });
+  assert.equal(missing.statusCode, 404);
+  const bad = await invoke(handle, { params: { key: 'Not_A_Key' } });
+  assert.equal(bad.statusCode, 400);
+  state.signals = [];
+});
+
+test('the listing read and the catalog agree on every module', async () => {
+  state.modules = { a: { status: 'listed', title: 'A' }, b: { status: 'listed', title: 'B' }, c: { status: 'listed', title: 'C' } };
+  state.versions = [
+    { id: 1, module_key: 'a', version: '1.0.0', published_at: 't' },
+    { id: 2, module_key: 'b', version: '1.0.0', published_at: 't' },
+    { id: 3, module_key: 'c', version: '1.0.0', published_at: 't' },
+  ];
+  state.scores = [
+    { id: 1, version_id: 1, computed_at: 1, ...score({ overall: 75 }) },
+    { id: 2, version_id: 2, computed_at: 1, ...score({ is_new: true, overall: null }) },
+    { id: 3, version_id: 3, computed_at: 1, ...score({ overall: 30 }) },
+  ];
+  const catalog = (await invoke(handlerFor(buildModulesRouter(), 'get', '/store/modules').handle, { query: {} })).body;
+  const shown = new Set([...catalog.listed, ...catalog.new].map((m) => m.key));
+  const { handle } = handlerFor(buildModulesRouter(), 'get', '/store/modules/:key/listing');
+  for (const key of ['a', 'b', 'c']) {
+    const r = await invoke(handle, { params: { key } });
+    assert.equal(r.body.listed, shown.has(key), key);
+  }
+});

package/tests/module_store_publish.mjs

@@ -1,6 +1,6 @@
 // tests/module_store_publish.mjs — `bongos module publish` end to end without a
 // network or a database (task 1004271, ADR 0338 D1): the pack/verify pair in
-// scripts/gds/module-artifact.js, the store's stage/commit + registry transaction in
+// scripts/bongos/module-artifact.js, the store's stage/commit + registry transaction in
 // src/bongos/module-store.js (against a fake pg client), and cmdPublish's refusals.
 //
 // Run:  node tests/module_store_publish.mjs
@@ -13,10 +13,10 @@ import os from 'node:os';
 import path from 'node:path';
 
 const require = createRequire(import.meta.url);
-const artifact = require('../scripts/gds/module-artifact.js');
-const format = require('../scripts/gds/artifact-format.js');
+const artifact = require('../scripts/bongos/module-artifact.js');
+const format = require('../scripts/bongos/artifact-format.js');
 const store = require('../src/bongos/module-store.js');
-const moduleCli = require('../scripts/gds/module.js');
+const moduleCli = require('../scripts/bongos/module.js');
 
 const NOW = () => new Date('2026-09-28T00:00:00Z');
 

package/tests/module_store_publish_route.mjs

@@ -44,7 +44,7 @@ const poolPath = require.resolve('../src/bongos/pool.js');
 require.cache[poolPath] = { id: poolPath, filename: poolPath, loaded: true, exports: { pool: { connect: async () => client, query: client.query } } };
 
 const buildModulesRouter = require('../src/bongos/routes/modules.js');
-const artifact = require('../scripts/gds/module-artifact.js');
+const artifact = require('../scripts/bongos/module-artifact.js');
 
 function handlerFor(router, method, p) {
   const layer = router.stack.find((l) => l.route && l.route.path === p && l.route.methods[method]);

package/tests/module_store_reassess.mjs

@@ -31,7 +31,7 @@ const query = async (sql, params = []) => {
 const poolPath = require.resolve('../src/bongos/pool.js');
 require.cache[poolPath] = { id: poolPath, filename: poolPath, loaded: true, exports: { pool: { connect: async () => ({ query, release() {} }), query } } };
 
-const moduleAssessVersion = require('../scripts/gds/module-assess-version.js');
+const moduleAssessVersion = require('../scripts/bongos/module-assess-version.js');
 const queued = [];
 let queueAccepts = true;
 moduleAssessVersion.queueAssessment = (id) => { queued.push(id); return queueAccepts; };

package/tests/module_store_registry_migration.mjs

@@ -65,6 +65,6 @@ test('the store surface models no payment, balance or payout (area 8 owns those)
 });
 
 test('the migration is forward-safe under the lint gate', () => {
-  const lint = require('../scripts/gds/lint-migrations.js');
+  const lint = require('../scripts/bongos/lint-migrations.js');
   assert.deepEqual(lint.scanMigrationSql(SQL).unsafe || [], []);
 });

package/tests/module_test_runner.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 runner = require('../scripts/gds/module-test-runner.js');
+const runner = require('../scripts/bongos/module-test-runner.js');
 const { runnerConfig, archiveCore, maybeDispatch, collectResults, sweepTick, readZipEntry, validateSignal, runName, artifactName } = runner;
 
 const CFG = { repo: 'owner/module-tests', token: 't0ken' };
@@ -303,7 +303,7 @@ test('nothing pending: collect does not call GitHub', async () => {
 test('--tarball keeps the gate: outside the testing environment it refuses before reading anything', () => {
   let out;
   try {
-    execFileSync(process.execPath, ['scripts/gds/module-assess-tests.js', '--tarball', 'does-not-exist.tgz', '--key', 'weather', '--json'],
+    execFileSync(process.execPath, ['scripts/bongos/module-assess-tests.js', '--tarball', 'does-not-exist.tgz', '--key', 'weather', '--json'],
       { cwd: ROOT, env: { PATH: process.env.PATH, SystemRoot: process.env.SystemRoot }, encoding: 'utf8', stdio: 'pipe' });
   } catch (e) { out = e; }
   assert.ok(out, 'it exits non-zero');
@@ -311,7 +311,7 @@ test('--tarball keeps the gate: outside the testing environment it refuses befor
 });
 
 test('the workflow template: no permissions for the job that runs module code, nonce in the run-name, no inputs in shell', () => {
-  const yml = fs.readFileSync(path.join(ROOT, 'scripts/gds/module-test-runner/module-tests.yml'), 'utf8');
+  const yml = fs.readFileSync(path.join(ROOT, 'scripts/bongos/module-test-runner/module-tests.yml'), 'utf8');
   assert.match(yml, /^permissions: \{\}$/m);
   assert.match(yml, /^run-name: module-tests \$\{\{ inputs\.version_id \}\} \$\{\{ inputs\.nonce \}\}$/m);
   assert.equal(runName(7, 'n'), 'module-tests 7 n', 'collect matches the template\'s run-name');

package/tests/module_update.mjs

@@ -19,9 +19,9 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const { packModule, verifyModuleArtifact } = require('../scripts/gds/module-artifact.js');
-const { readTar, buildTar } = require('../scripts/gds/artifact-format.js');
-const { cmdUpdate, cmdInstall } = require('../scripts/gds/module.js');
+const { packModule, verifyModuleArtifact } = require('../scripts/bongos/module-artifact.js');
+const { readTar, buildTar } = require('../scripts/bongos/artifact-format.js');
+const { cmdUpdate, cmdInstall } = require('../scripts/bongos/module.js');
 
 const NOW = () => new Date('2026-09-29T00:00:00Z');
 
@@ -202,7 +202,7 @@ function codeOf(src, fnName) {
 }
 
 test('the shared acquisition path, install and update carry no price-conditional code', () => {
-  const src = fs.readFileSync(path.join(ROOT, 'scripts/gds/module.js'), 'utf8');
+  const src = fs.readFileSync(path.join(ROOT, 'scripts/bongos/module.js'), 'utf8');
   for (const fn of ['fetchVerified', 'recordPlaced', 'cmdInstall', 'cmdUpdate', 'replaceModule', 'placeModule']) {
     assert.doesNotMatch(codeOf(src, fn), /\b(price|priced|paid|cents|credits|free|purchase|source)\b/i, `${fn} must not read how the module was obtained`);
   }

package/tests/module_upgrade_updates.mjs

@@ -34,7 +34,7 @@ const poolPath = require.resolve('../src/bongos/pool.js');
 require.cache[poolPath] = { id: poolPath, filename: poolPath, loaded: true, exports: { pool: { connect: async () => ({ ...pool, release() {} }), query: pool.query } } };
 
 const buildModulesRouter = require('../src/bongos/routes/modules.js');
-const mod = require('../scripts/gds/module.js');
+const mod = require('../scripts/bongos/module.js');
 
 function handlerFor(router, method, p) {
   const layer = router.stack.find((l) => l.route && l.route.path === p && l.route.methods[method]);

package/tests/move_escalation.mjs

@@ -14,8 +14,8 @@ import { createRequire } from 'node:module';
 
 process.env.PROVISION_APP_USER = process.env.PROVISION_APP_USER || 'lars'; // appUser() refuses a Windows account name
 const require = createRequire(import.meta.url);
-const E = require('../scripts/gds/move-escalation.js');
-const P = require('../scripts/gds/provision.js');
+const E = require('../scripts/bongos/move-escalation.js');
+const P = require('../scripts/bongos/provision.js');
 
 let passed = 0;
 let failed = 0;

package/tests/nav_permission_atoms.mjs

@@ -91,8 +91,9 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // then the reads it shares with the governor pages (window.__hallReads); task 1004713:
 // the seats read from /me's server-resolved positions block; task 1004730: the banner
 // says a held core version was tried and rolled back; task 1004731: the one-time
-// "Upgraded to core X" notice after a move.
-const SHELL_SHA = 'eb9e85b9c1784f01';
+// "Upgraded to core X" notice after a move; task 1004826: Standing is Accomplishments;
+// task 1004846: the new logo (its bump landed late, in task 1004852).
+const SHELL_SHA = 'bf052d6fabeb1953';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);

package/tests/needs_rebase.mjs

@@ -48,9 +48,11 @@ 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,'nr','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,'nr','building','internal') ON CONFLICT (id) DO NOTHING`, [VER]);
   await q(`INSERT INTO builders (id,github_id,github_login,display_name,rank) VALUES ($1,'nr-w','nr-worker','NR Worker','thetes')`, [WORKER]);
-  await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind,shipped_by) VALUES ($1,$2,'nr fixture','confirmed',10,'feature',$3)`, [TASK, VER, WORKER]);
+  await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind,shipped_by,discipline) VALUES ($1,$2,'nr fixture','confirmed',10,'feature',$3,'engineer')`, [TASK, VER, WORKER]);
   await q(`INSERT INTO claims (task_id,builder_id,claimed_at) VALUES ($1,$2,now())`, [TASK, WORKER]);
 
   // 1) flag a CONFIRMED task → flagged, reason + at set, returns true.
@@ -70,7 +72,9 @@ try {
   ok(String(t.needs_rebase_at.getTime?.() ?? t.needs_rebase_at) === String(atWas.getTime?.() ?? atWas), 'needs_rebase_at unchanged on re-flag');
 
   // 3) shipping the task CLEARS the flag (the land completed).
-  await db.shipTask({ taskId: String(TASK), builderId: String(WORKER) });
+  // shipTask is fail-closed on a land assurance since task 1002483 (ADR 0184); the test
+  // stands in for the land proof the real ship path supplies.
+  await db.shipTask({ taskId: String(TASK), builderId: String(WORKER), landAssurance: { kind: 'proof', reason: 'test fixture: land proven' } });
   t = await taskRow();
   ok(t.status === 'shipped', 'task shipped');
   ok(t.needs_rebase === false, 'needs_rebase cleared on ship');

package/tests/newcomer_floor.mjs

@@ -14,4 +14,4 @@ import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
 // Executing the co-located test runs every assertion; it process.exit(1)s on the
 // first failure and prints a success line otherwise — exactly the gate contract.
-require('../scripts/gds/newcomer-floor.test.js');
+require('../scripts/bongos/newcomer-floor.test.js');

package/tests/newcomer_generator.mjs

@@ -0,0 +1,48 @@
+// tests/newcomer_generator.mjs — the daily newcomer-generator routine runs to the end.
+//
+// task 1004860: the routine's artist lane read a curated prompt library from
+// modules/art-pipeline/template/, a module this core no longer carries. The read
+// threw ENOENT, so every run exited 1 straight after the engineer lane. The lane is
+// gone; this drives a whole run through an injected API and checks it finishes.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { main } = require('../.claude/scheduled-tasks/newcomer-generator/generate.js');
+
+function fakeApi() {
+  const calls = [];
+  const api = async (method, p, body) => {
+    calls.push({ method, p, body });
+    if (method === 'GET' && p.startsWith('/api/bongos/tasks')) return { ok: true, data: { tasks: [] } };
+    if (method === 'GET' && p.startsWith('/api/bongos/inbox')) {
+      return { ok: true, data: { ideas: [{ id: 7, title: 'Tidy a helper', kind: 'cleanup', priority: 5, body_md: 'x' }] } };
+    }
+    if (method === 'POST') return { ok: true, data: { task: { id: 99, title: body.title } } };
+    if (method === 'PATCH') return { ok: true, data: {} };
+    return { ok: false, status: 404, data: {} };
+  };
+  return { api, calls };
+}
+
+test('a below-target run tops up the engineer lane and finishes without reading a prompt library', async () => {
+  // Arrange
+  const { api, calls } = fakeApi();
+  const log = console.log;
+  console.log = () => {};
+
+  // Act
+  try {
+    await main({ apiCall: api });
+  } finally {
+    console.log = log;
+  }
+
+  // Assert
+  const created = calls.filter((c) => c.method === 'POST');
+  assert.equal(created.length, 1, 'exactly one task is created');
+  assert.equal(created[0].body.discipline, 'engineer');
+  assert.ok(calls.some((c) => c.method === 'PATCH' && c.p === '/api/bongos/inbox/7'), 'the idea is marked promoted');
+});

package/tests/next_number.mjs

@@ -16,7 +16,7 @@ import path from 'node:path';
 
 const require = createRequire(import.meta.url);
 const { parseNumbers, nextFree, computeNextNumbers, nextNumbers, padAdr, padMig } =
-  require('../scripts/gds/next-number.js');
+  require('../scripts/bongos/next-number.js');
 
 let passed = 0;
 let failed = 0;

package/tests/no_artifact_escalation.mjs

@@ -29,7 +29,7 @@ import { createRequire } from 'node:module';
 import { shipCliSource } from './helpers.mjs';
 
 const require = createRequire(import.meta.url);
-const esc = require('../scripts/gds/ship-escalation.js');
+const esc = require('../scripts/bongos/ship-escalation.js');
 const {
   escalationSourceRef, escalationTitle, escalationBody,
   noArtifactRefusalLines, fileNoArtifactEscalation, NO_ARTIFACT_SOURCE,
@@ -67,9 +67,9 @@ await test('the refusal never tells the builder to run a command that returns th
     undefined,
   ]) {
     const out = text({ taskId: 1003822, floor: 'archon', escalation });
-    assert.ok(!/node scripts\/gds\/ship\.js\s+\d+\s+--regrade/.test(out),
+    assert.ok(!/node scripts\/(?:gds|bongos)\/ship\.js\s+\d+\s+--regrade/.test(out),
       'a runnable --regrade command is the exact advice that loops');
-    assert.ok(!/node scripts\/gds\/ship\.js\s+\d+\s+--allow-empty/.test(out),
+    assert.ok(!/node scripts\/(?:gds|bongos)\/ship\.js\s+\d+\s+--allow-empty/.test(out),
       'and re-running --allow-empty lands on this same refusal');
     // The refusal deliberately contains "Do NOT re-run with --regrade". Drop that
     // negated sentence, then assert nothing REMAINING recommends it. A blanket

package/tests/npm_release_where.mjs

@@ -289,7 +289,7 @@ test('the module declares the task page section and ships its widget; the seam g
   assert.deepEqual(manifest.contributes.uiSections, ['task-where']);
   assert.ok(manifest.contributes.routes.includes('task-where'));
   assert.ok(fs.existsSync(path.join(ROOT, 'modules/npm-release/public/task-widget.js')));
-  const guard = fs.readFileSync(path.join(ROOT, 'scripts/gds/seam-wiring-guard.js'), 'utf8');
+  const guard = fs.readFileSync(path.join(ROOT, 'scripts/bongos/seam-wiring-guard.js'), 'utf8');
   assert.match(guard, /alternates: \(dir\) => \[path\.join\(dir, 'public', 'task-widget\.js'\)\]/);
 });
 

package/tests/oauth_secret.mjs

@@ -1,10 +1,10 @@
 // tests/oauth_secret.mjs — DB-free unit tests for the verified OAuth-secret
-// placement helper (scripts/gds/oauth-secret.js, BONGOS-V1 goal 35 / task 1979).
+// placement helper (scripts/bongos/oauth-secret.js, BONGOS-V1 goal 35 / task 1979).
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
-const oauth = require('../scripts/gds/oauth-secret.js');
+const oauth = require('../scripts/bongos/oauth-secret.js');
 
 test('validateClientSecret rejects empty / placeholder / truncated; accepts a real 40-char secret', () => {
   assert.equal(oauth.validateClientSecret('').ok, false);

package/tests/onboard.mjs

@@ -1,11 +1,11 @@
 // tests/onboard.mjs — DB-free unit tests for the `bongos onboard` CLI pure core
-// (scripts/gds/onboard.js, BONGOS-V1 goal 35 / task 1982). The interactive shell is
+// (scripts/bongos/onboard.js, BONGOS-V1 goal 35 / task 1982). The interactive shell is
 // exercised by hand; the sequence + the human-step values are pinned here.
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);
-const ob = require('../scripts/gds/onboard.js');
+const ob = require('../scripts/bongos/onboard.js');
 
 test('onboardPlan is the canonical sequence: name+address first, the builders hall last, four legs automated around the human steps', () => {
   const plan = ob.onboardPlan();
@@ -77,7 +77,7 @@ test('every form OFFERS the optional step and names what skipping costs — skil
   assert.match(skill, /dark matter/i, 'and states what skipping costs');
 
   // the CLI form
-  const cli = read('scripts/gds/onboard.js');
+  const cli = read('scripts/bongos/onboard.js');
   assert.match(cli, /Press Enter to skip/, 'the terminal form offers the skip in the prompt itself');
   assert.match(cli, /off the public map/, 'and says what a missing description means');
 
@@ -190,7 +190,7 @@ test('every render surface carries the terminal hall step (task 1002703)', () =>
   const { readFileSync } = require('node:fs');
   const path = require('node:path');
   const read = (rel) => readFileSync(path.join(import.meta.dirname, '..', rel), 'utf8');
-  const cli = read('scripts/gds/onboard.js');
+  const cli = read('scripts/bongos/onboard.js');
   assert.match(cli, /builders hall/i, 'the CLI walkthrough ends at the hall');
   assert.match(cli, /bongos dev/, 'the CLI offers the local-hall one-liner when no domain');
   // the one page (task 1004683): the hall is entered through the Enter Genesis door, the
@@ -285,7 +285,7 @@ test('onboardPlan is the SAME function the provisioning module owns (single sour
   // that is the whole point of task 2085. A re-declared duplicate would pass every other
   // test yet silently drift; identity of the function reference proves there is one source.
   const canonical = require('../modules/provisioning/onboard-plan.js').onboardPlan;
-  assert.equal(ob.onboardPlan, canonical, 'scripts/gds/onboard.js must re-export the module’s onboardPlan');
+  assert.equal(ob.onboardPlan, canonical, 'scripts/bongos/onboard.js must re-export the module’s onboardPlan');
 });
 
 test('the web form (?view=new) declares EXACTLY the canonical human steps — drift guard', () => {
@@ -325,6 +325,6 @@ test('the one-click GitHub-App manifest path surfaces the CLI-only Enable-Device
   // (`bongos onboard` is the only manifest surface since the hall wizard's removal, task 1002675.)
   const { readFileSync } = require('node:fs');
   const path = require('node:path');
-  const onboardSrc = readFileSync(path.join(import.meta.dirname, '..', 'scripts/gds/onboard.js'), 'utf8');
+  const onboardSrc = readFileSync(path.join(import.meta.dirname, '..', 'scripts/bongos/onboard.js'), 'utf8');
   assert.match(onboardSrc, /cannot enable Device Flow via the manifest/i, 'bongos onboard one-click caveat missing');
 });

package/tests/onboarding_gate.mjs

@@ -202,10 +202,10 @@ t('requireStageCleared: throws at construction time for unknown stage', () => {
 });
 
 // ---------- printOnboardingNudge (CLI helper) ----------
-// Lives in scripts/gds/cli-lib.js. Quick sanity that it doesn't print for
+// Lives in scripts/bongos/cli-lib.js. Quick sanity that it doesn't print for
 // graduated builders or those who reached ship_three, and DOES print for
 // newcomers.
-const cliLib = require('../scripts/gds/cli-lib.js');
+const cliLib = require('../scripts/bongos/cli-lib.js');
 
 function captureStdout(fn) {
   const lines = [];

package/tests/opt_in_skill_modules.mjs

@@ -21,9 +21,9 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const materialize = require(path.join(ROOT, 'scripts', 'gds', 'claude-materialize.js'));
-const lint = require(path.join(ROOT, 'scripts', 'gds', 'skill-lint.js'));
-const publish = require(path.join(ROOT, 'scripts', 'gds', 'publish-manifest.js'));
+const materialize = require(path.join(ROOT, 'scripts', 'bongos', 'claude-materialize.js'));
+const lint = require(path.join(ROOT, 'scripts', 'bongos', 'skill-lint.js'));
+const publish = require(path.join(ROOT, 'scripts', 'bongos', 'publish-manifest.js'));
 const readJson = (p) => JSON.parse(fs.readFileSync(p, 'utf8'));
 
 const PIXEL_ART = ['otb-tile-generate', 'otb-design-review', 'otb-character-review', 'otb-feedback-capture', 'otb-figma-sync'];

package/tests/own_scope_guard.mjs

@@ -524,7 +524,7 @@ t('the guard checks a real number of own-scoped routes overall', () => {
 });
 
 t('this guard 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(
     !/own_scope_guard/.test(runner),
     'own_scope_guard is named in run-unit-tests.js — if it landed in INTEGRATION or KNOWN_FAILING it would stop gating anything (task 1002282)'

package/tests/own_session_revoke.mjs

@@ -140,6 +140,9 @@ function predicateFor(sql, params) {
   take(/(?<!_)\b(?:s\.)?id = \$(\d+)/, (v) => (r) => String(r.id) === String(v));
   take(/\bbuilder_id = \$(\d+)/, (v) => (r) => String(r.builder_id) === String(v));
   take(/\brevoked_at IS NULL/, () => (r) => r.revoked_at === null);
+  // ADR 0383: a session idle past the limit is left off the list.
+  take(/\blast_used_at > now\(\) - \(\$(\d+)::bigint \* INTERVAL '1 millisecond'\)/,
+    (v) => (r) => new Date(r.last_used_at).getTime() > Date.now() - Number(v));
 
   for (const m of raw.matchAll(/\$(\d+)/g)) {
     if (!consumed.has(m[1])) {
@@ -337,7 +340,7 @@ await t('a builder_id in the QUERY STRING changes nothing about whose list comes
   assert.equal(r.status, 200);
   assert.deepEqual(r.body.sessions.map((s) => s.id), ['101', '102'], 'still Ada\'s own list');
   const listQuery = calls.filter((c) => /FROM builder_sessions WHERE builder_id/.test(c.sql)).pop();
-  assert.deepEqual(listQuery.params, [1], 'the account queried is the SESSION\'s builder, never the one named in the URL');
+  assert.deepEqual(listQuery.params, [1, 10 * DAY], 'the account queried is the SESSION\'s builder, never the one named in the URL');
 });
 
 await t('guessing a stranger\'s session id revokes nothing and leaks nothing', async () => {