@bongos/core 1.21.175 → 1.21.177

package/tests/consumer_layout_boot.mjs

@@ -20,7 +20,7 @@
 // ever exercised that shape. This harness closes the blind spot end to end.
 //
 // WHAT IT PROVES (the two-root checks all go RED against the pre-2133 loader):
-//   1. package  — scripts/gds/package-core.js builds an installable .tgz.
+//   1. package  — scripts/bongos/package-core.js builds an installable .tgz.
 //   2. install  — `npm install <tgz>` lands it at node_modules/@bongos/core.
 //   3. roots    — resolveCoreRoot() is UNDER node_modules/@bongos/core while
 //                 resolveInstanceRoot() is the consumer tree: two DIFFERENT dirs, so
@@ -33,7 +33,7 @@
 //                 cannot find consumer-probe → this IS the task-2133 done-when.
 //   6. fitness  — the packaged fitness.js discoveredModuleKeys() spans both roots.
 //   7. gen-file-map — reads the INSTANCE root (lists the consumer's .claude/skills).
-//   8. gen-repo-map — maps CORE code (scripts/gds/fitness.js) from node_modules.
+//   8. gen-repo-map — maps CORE code (scripts/bongos/fitness.js) from node_modules.
 //   9. npm ci   — the lockfile SHIPPED inside the package (package-core prunes it to the
 //                 core's own dependency closure) installs with `npm ci` on its own: in step
 //                 with the package.json it ships beside, and every integrity hash verifies.
@@ -54,7 +54,7 @@
 //                 — the gap the task-1004030 foreign-key break hid in.
 //
 // WHERE IT RUNS. This is an INTEGRATION harness (a package build, two installs, live boots
-// and a Postgres), so it sits in the INTEGRATION set of scripts/gds/run-unit-tests.js — the
+// and a Postgres), so it sits in the INTEGRATION set of scripts/bongos/run-unit-tests.js — the
 // per-PR unit gate never pays for it — and the `integration` job of
 // .github/workflows/integration.yml runs it on every push to main via
 // `run-unit-tests.js --integration`. That job's Postgres service supplies checks 10-12, but
@@ -105,7 +105,7 @@ const NPM_BIN = process.platform === 'win32' ? 'npm.cmd' : 'npm';
 const CORE_VERSION_RANGE = '^1.0.0'; // consumer-probe's coreVersion — satisfied by any 1.x core.
 // The consumer's package.json is scaffolded by the SAME function `bongos init` uses for a
 // greenfield instance, so its `migrate` script is the real one rather than a copy that could drift.
-const { buildInstancePackageJson } = createRequire(import.meta.url)(join(REPO_ROOT, 'scripts', 'gds', 'init.js'));
+const { buildInstancePackageJson } = createRequire(import.meta.url)(join(REPO_ROOT, 'scripts', 'bongos', 'init.js'));
 
 let passed = 0;
 let failed = 0;
@@ -307,10 +307,10 @@ async function main() {
     // job packages exactly the code under review). Reuse a prebuilt one via CORE_TGZ.
     // No database settings reach the packager (header: THE CHILD PROCESSES ...).
     let tgz = process.env.CORE_TGZ || '';
-    check('package: scripts/gds/package-core.js builds an installable .tgz', () => {
+    check('package: scripts/bongos/package-core.js builds an installable .tgz', () => {
       if (tgz) { assert.ok(existsSync(tgz), `CORE_TGZ does not exist: ${tgz}`); return; }
       const outDir = join(workRoot, 'dist');
-      const r = spawnSync(process.execPath, [join(REPO_ROOT, 'scripts/gds/package-core.js'), '--out-dir', outDir],
+      const r = spawnSync(process.execPath, [join(REPO_ROOT, 'scripts/bongos/package-core.js'), '--out-dir', outDir],
         { cwd: REPO_ROOT, env: withoutDbEnv(), encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 });
       assert.equal(r.status, 0, `package-core exited ${r.status}\n${r.stderr}`);
       const pinLine = r.stdout.trim().split('\n').filter(Boolean).pop();
@@ -448,7 +448,7 @@ async function main() {
     // --- 6. fitness spans both roots -----------------------------------------
     check('fitness: discoveredModuleKeys() unions the core + instance module roots', () => {
       const r = runNodeJSON(`
-        const f = require(${A('scripts/gds/fitness.js')});
+        const f = require(${A('scripts/bongos/fitness.js')});
         process.stdout.write(JSON.stringify({ keys: f.discoveredModuleKeys() }));
       `, consumer);
       assert.ok(r.keys.includes('consumer-probe'),
@@ -462,7 +462,7 @@ async function main() {
     // --- 7. gen-file-map reads the INSTANCE root ------------------------------
     check('gen-file-map: buildModel() lists the INSTANCE root .claude/skills (consumer-probe-skill)', () => {
       const model = runNodeJSON(`
-        const g = require(${A('scripts/gds/gen-file-map.js')});
+        const g = require(${A('scripts/bongos/gen-file-map.js')});
         process.stdout.write(JSON.stringify(g.buildModel()));
       `, consumer);
       const skills = model.find((s) => s.id === 'skills');
@@ -473,14 +473,14 @@ async function main() {
     });
 
     // --- 8. gen-repo-map reads the CORE root ----------------------------------
-    check('gen-repo-map: buildModel() maps CORE code (scripts/gds/fitness.js) from node_modules', () => {
+    check('gen-repo-map: buildModel() maps CORE code (scripts/bongos/fitness.js) from node_modules', () => {
       const model = runNodeJSON(`
-        const g = require(${A('scripts/gds/gen-repo-map.js')});
+        const g = require(${A('scripts/bongos/gen-repo-map.js')});
         const m = g.buildModel();
-        process.stdout.write(JSON.stringify({ files: m.files.length, hasFitness: m.byFile.some((f) => f.rel === 'scripts/gds/fitness.js') }));
+        process.stdout.write(JSON.stringify({ files: m.files.length, hasFitness: m.byFile.some((f) => f.rel === 'scripts/bongos/fitness.js') }));
       `, consumer);
       assert.ok(model.files > 50, `core scan found too few files (${model.files}) — core root not resolved to the package?`);
-      assert.equal(model.hasFitness, true, 'gen-repo-map did not map the core file scripts/gds/fitness.js');
+      assert.equal(model.hasFitness, true, 'gen-repo-map did not map the core file scripts/bongos/fitness.js');
     });
 
     // --- 9. npm ci from the SHIPPED, pruned lockfile --------------------------

package/tests/context_pack.mjs

@@ -25,7 +25,7 @@ const {
   formatOs,
   formatContextPack,
   formatContextPackCompact,
-} = require('../scripts/gds/context-pack.js');
+} = require('../scripts/bongos/context-pack.js');
 // The live validators — the pack MUST mirror these, or it would teach builders
 // the wrong enum (the whole point of "generated from the live validators").
 const { VALID_KINDS, VALID_DISCIPLINES, TASK_FIELD_BOUNDS } =
@@ -360,10 +360,10 @@ const url = require('node:url');
 function checkoutWithoutLifecycle() {
   const here = path.dirname(url.fileURLToPath(import.meta.url));
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ctxpack-nolifecycle-'));
-  fs.mkdirSync(path.join(root, 'scripts', 'gds'), { recursive: true });
+  fs.mkdirSync(path.join(root, 'scripts', 'bongos'), { recursive: true });
   fs.mkdirSync(path.join(root, 'src', 'bongos'), { recursive: true });
-  fs.copyFileSync(path.join(here, '..', 'scripts', 'gds', 'context-pack.js'),
-    path.join(root, 'scripts', 'gds', 'context-pack.js'));
+  fs.copyFileSync(path.join(here, '..', 'scripts', 'bongos', 'context-pack.js'),
+    path.join(root, 'scripts', 'bongos', 'context-pack.js'));
   // The ONLY other import. Deliberately copied rather than stubbed: if
   // context-pack grows a second hard dependency, this test fails and that new
   // coupling has to be looked at — which is the point.
@@ -371,7 +371,7 @@ function checkoutWithoutLifecycle() {
     path.join(root, 'src', 'bongos', 'api-prefix.js'));
   // No modules/ — that IS the condition.
   assert.ok(!fs.existsSync(path.join(root, 'modules')), 'the fixture must not carry modules/');
-  return { root, mod: require(path.join(root, 'scripts', 'gds', 'context-pack.js')) };
+  return { root, mod: require(path.join(root, 'scripts', 'bongos', 'context-pack.js')) };
 }
 
 t('a checkout with no modules/lifecycle can still LOAD the pack (the deadlock)', () => {
@@ -414,7 +414,7 @@ t('with the module present the enums are still the LIVE ones, not a local copy',
   const live = require('../modules/lifecycle/task-classifier');
   assert.deepEqual(api.task_kinds, [...live.VALID_KINDS].filter((k) => k !== 'unclassified'));
   assert.deepEqual(api.disciplines, [...live.VALID_DISCIPLINES].filter((d) => d !== 'unclassified'));
-  const src = fs.readFileSync(new URL('../scripts/gds/context-pack.js', import.meta.url), 'utf8');
+  const src = fs.readFileSync(new URL('../scripts/bongos/context-pack.js', import.meta.url), 'utf8');
   assert.doesNotMatch(src, /'(bug|feature|chore|cleanup|verify)'\s*,\s*'/,
     'a literal kind list in this file is the drift the generated design exists to prevent');
 });

package/tests/control_manifest.mjs

@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const cm = require(path.join(ROOT, 'scripts', 'gds', 'control-manifest.js'));
+const cm = require(path.join(ROOT, 'scripts', 'bongos', 'control-manifest.js'));
 
 test('the live tree passes: every goal-1000076 control is present and wired', () => {
   const r = cm.checkControlsExist();
@@ -42,10 +42,10 @@ test('a present-but-UNWIRED control is caught (the settings.json un-hook case)',
 
 test('a missing companion file (baseline/config) is caught even when the main file exists', () => {
   const controls = [{
-    label: 'audit gate', file: 'scripts/gds/audit-gate.js',
+    label: 'audit gate', file: 'scripts/bongos/audit-gate.js',
     alsoExists: ['config/audit-baseline.json'],
   }];
-  const v = cm.evaluate(controls, { exists: (f) => f === 'scripts/gds/audit-gate.js', read: () => '' });
+  const v = cm.evaluate(controls, { exists: (f) => f === 'scripts/bongos/audit-gate.js', read: () => '' });
   assert.equal(v.length, 1);
   assert.match(v[0], /companion file missing/);
 });
@@ -105,7 +105,7 @@ test('a guard UNWIRED from fitness.js is caught — the one-line deletion', () =
 
 test("G04 is wired via ship-flow, not fitness — it is a module, not a check", () => {
   const row = cm.CONTROLS.find((c) => c.label.includes('(G04)'));
-  assert.equal(row.wiredIn.file, 'scripts/gds/ship-flow.js');
+  assert.equal(row.wiredIn.file, 'scripts/bongos/ship-flow.js');
   const out = cm.evaluate([row], { exists: () => true, read: () => 'nothing requires it' });
   assert.equal(out.length, 1, 'an unrequired ship-honesty is caught');
 });

package/tests/copy_desk_page_reads.mjs

@@ -179,7 +179,7 @@ try {
       const { status, body } = await get(p);
       assert.equal(status, 503, p);
       assert.equal(body.error.code, 'page_inventory_missing', p);
-      assert.equal(body.error.details.run, 'node scripts/gds/page-inventory.js', p);
+      assert.equal(body.error.details.run, 'node scripts/bongos/page-inventory.js', p);
     }
     const tally = await get('/copy-desk/tally', F.ALICE.id);
     assert.equal(tally.status, 200);

package/tests/copy_desk_page_release.mjs

@@ -0,0 +1,192 @@
+// tests/copy_desk_page_release.mjs — a page round the reads cannot name can be
+// released, the WHOLE path (task 1004837).
+//
+// The report: the stuck-tweaks digest listed four pages as "needs a look, 0
+// days" and the Studio had nothing that moved them. A round in copy-desk's
+// `unknown` state (an active round nobody holds; a ready round with an applied
+// block and no send-back) is stuck at once, and no route took it anywhere.
+//
+// Driven through the real release route (routes/copy-desk-release.js), the real
+// lifecycle port (releaseStuckTweak) and the real page reads, against the shared
+// stateful fake ledger (tests/fixtures/page-ledger.mjs).
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { makeRunner } from './helpers.mjs';
+import { installPageLedger } from './fixtures/page-ledger.mjs';
+
+process.env.NODE_ENV = 'test';
+const require = createRequire(import.meta.url);
+const F = require('../modules/copy-desk/tests/fixtures/page-tweak.cjs');
+const pages = require('../modules/copy-desk/pages.js');
+const api = require('../src/module-api.js');
+
+const ALICE = '7'; // an artist
+const CARL = '9';  // the applier, Metic
+const { db } = installPageLedger(api, {
+  builders: [
+    { id: ALICE, github_login: 'alice', display_name: 'Alice', preferred_disciplines: ['artist'] },
+    { id: CARL, github_login: 'carl', display_name: 'Carl', preferred_disciplines: ['engineer'] },
+  ],
+});
+
+// The rank wall is the kernel's; here it reads the rank the test sends.
+api.requireBuilder = (req, res, next) => {
+  req.builder = { id: String(req.headers['x-builder'] || CARL), rank: String(req.headers['x-rank'] || 'metic') };
+  next();
+};
+// task.abandon floors at Metic; the stub holds it for Metic and Archon only.
+Object.defineProperty(api, 'requirePermission', {
+  configurable: true,
+  value: (atom) => (req, res, next) => (atom === 'task.abandon' && ['metic', 'archon'].includes(req.builder.rank) ? next() : res.status(403).json({ error: { code: 'forbidden' } })),
+});
+
+const seams = require('../src/module-seams.js');
+const lifecyclePort = require('../modules/lifecycle/lifecycle.js');
+if (!seams.hasProvider('lifecycle')) seams.registerProvider('lifecycle', lifecyclePort);
+
+const pageData = require('../modules/copy-desk/page-data.js');
+const pageStatus = require('../modules/copy-desk/page-status.js');
+const express = require('express');
+const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+const buildRouter = require('../modules/copy-desk/routes/copy-desk.js');
+const buildReleaseRouter = require('../modules/copy-desk/routes/copy-desk-release.js');
+
+const app = express();
+app.use(express.json());
+app.use(attachFail);
+app.use(buildRouter());
+app.use(buildReleaseRouter());
+const server = await new Promise((resolve) => { const s = app.listen(0, '127.0.0.1', () => resolve(s)); });
+const base = `http://127.0.0.1:${server.address().port}`;
+
+async function call(method, p, { rank = 'metic', body = {} } = {}) {
+  const r = await fetch(base + p, { method, headers: { 'content-type': 'application/json', 'x-builder': CARL, 'x-rank': rank }, body: method === 'GET' ? undefined : JSON.stringify(body) });
+  return { status: r.status, body: await r.json() };
+}
+const errCode = (b) => (b && b.error && b.error.code) || null;
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'page-release-'));
+fs.mkdirSync(path.join(tmp, 'docs'), { recursive: true });
+fs.writeFileSync(path.join(tmp, 'docs/page-inventory.json'), JSON.stringify(F.INVENTORY));
+fs.writeFileSync(path.join(tmp, 'docs/page-readings.json'), JSON.stringify(F.READINGS));
+pageData._setRoot(tmp);
+
+// ---- the ledger ------------------------------------------------------------
+
+const lines = [{ key: 'L0002', section: 'hero', before: 'Build here', after: 'Build it here', placement: 'placed', file: 'x.html', line: 1, string_id: 'abc' }];
+const batch = (pageId) => pages.composeBatchBlock({ page_id: pageId, reading_hash: 'h', submitted_at: '2026-09-19T00:00:00Z', lines });
+const applied = (pageId) => pages.composeAppliedBlock({ page_id: pageId, applied_at: '2026-09-21T10:00:00Z', reading_hash_after: 'h2', lines_after: ['Build it here'], refused: [] });
+
+// A READY round, applied, never sent back, never graded: the reads cannot name it.
+db.tasks.push({ id: '7001', status: 'ready', title: 'Tweak: Home', description: [batch('landing:index'), applied('landing:index')].join('\n\n'), source: 'page-tweak', source_ref: pages.roundSourceRef('landing:index', 1), touches: [], version_id: 'V9', goal_id: '77' });
+db.claims.push({ id: String(++db.seq.claim), task_id: '7001', builder_id: ALICE, worktree_name: null, creator_session_id: null, claimed_at: '2026-09-19T00:00:00Z', released_at: '2026-09-19T01:00:00Z', outcome: 'partial' });
+// An ACTIVE round nobody holds: the other way to be unnameable.
+db.tasks.push({ id: '7002', status: 'active', title: 'Tweak: Projects', description: 'Page tweak round 1 for landing:projects.', source: 'page-tweak', source_ref: pages.roundSourceRef('landing:projects', 1), touches: [], version_id: 'V9', goal_id: '77' });
+// A healthy SUBMITTED round: ready, a batch, nothing applied. Not stuck in this way.
+db.tasks.push({ id: '7003', status: 'ready', title: 'Tweak: Explore', description: batch('status:explore'), source: 'page-tweak', source_ref: pages.roundSourceRef('status:explore', 1), touches: [], version_id: 'V9', goal_id: '77' });
+
+const task = (id) => db.tasks.find((t) => String(t.id) === String(id));
+const stateOf = (id) => pageStatus.roundState({
+  ...task(id), holder_id: null, holder_worktree: null, grade_passed: db.grades.has(String(id)) ? db.grades.get(String(id)) : null,
+});
+const RELEASE = (pageId) => `/copy-desk/pages/${pageId}/release`;
+const NOTE = 'Stuck in a state the Studio could not read; released.';
+const { test, summary } = makeRunner();
+
+try {
+  await test('the two rounds read as unknown and stuck, and the healthy one does not', async () => {
+    const r = await call('GET', '/copy-desk/pages');
+    assert.equal(r.status, 200, JSON.stringify(r.body));
+    const flight = Object.fromEntries(r.body.in_flight.map((f) => [f.page_id, f]));
+    assert.deepEqual([flight['landing:index'].state, flight['landing:index'].stuck, flight['landing:index'].task_id], ['unknown', true, '7001']);
+    assert.deepEqual([flight['landing:projects'].state, flight['landing:projects'].stuck], ['unknown', true]);
+    assert.equal(flight['status:explore'].state, 'submitted');
+    assert.equal(flight['status:explore'].stuck, false);
+  });
+
+  await test('the Studio row offers a release only for the unknown state, and names the round it looked at', async () => {
+    const lib = require('../modules/hall-ui/public/studio-lib.js');
+    const rows = lib.inFlightRows((await call('GET', '/copy-desk/pages')).body, new Date());
+    const by = Object.fromEntries(rows.map((r) => [r.page_id, r]));
+    assert.deepEqual([by['landing:index'].release, by['landing:index'].task_id], [true, '7001']);
+    assert.equal(by['status:explore'].release, false);
+  });
+
+  await test('release is the applier\'s call: a rank below Metic is refused and nothing moves', async () => {
+    const r = await call('POST', RELEASE('landing:index'), { rank: 'thetes', body: { note: NOTE } });
+    assert.equal(r.status, 403);
+    assert.equal(task(7001).status, 'ready');
+    assert.equal(pages.parseSentBackBlocks(task(7001).description).length, 0);
+  });
+
+  await test('a short note, an unknown page and a round that is not stuck are refused by name', async () => {
+    assert.equal(errCode((await call('POST', RELEASE('landing:index'), { body: { note: 'no' } })).body), 'note_too_short');
+    const gone = await call('POST', RELEASE('landing:nowhere'), { body: { note: NOTE } });
+    assert.equal(gone.status, 404);
+    const ok = await call('POST', RELEASE('status:explore'), { body: { note: NOTE } });
+    assert.equal(ok.status, 409);
+    assert.equal(errCode(ok.body), 'not_stuck');
+    assert.equal(task(7003).status, 'ready', 'a healthy submitted round is left alone');
+    assert.equal(pages.parseSentBackBlocks(task(7003).description).length, 0);
+  });
+
+  await test('task_id pins the round the viewer looked at', async () => {
+    const r = await call('POST', RELEASE('landing:index'), { body: { note: NOTE, task_id: '9999' } });
+    assert.equal(r.status, 409);
+    assert.equal(errCode(r.body), 'round_moved');
+    assert.equal(pages.parseSentBackBlocks(task(7001).description).length, 0);
+  });
+
+  await test('a round that still holds its batch goes back to the /tweak queue with the note', async () => {
+    const r = await call('POST', RELEASE('landing:index'), { body: { note: NOTE, task_id: '7001' } });
+    assert.equal(r.status, 200, JSON.stringify(r.body));
+    assert.equal(r.body.outcome, 'released');
+    assert.equal(task(7001).status, 'ready');
+    const [back] = pages.parseSentBackBlocks(task(7001).description);
+    assert.equal(back.note, NOTE);
+    assert.equal(back.by, CARL);
+    assert.equal(stateOf(7001), 'submitted', 'the round now reads submitted: the /tweak queue');
+    const flight = (await call('GET', '/copy-desk/pages')).body.in_flight.find((f) => f.page_id === 'landing:index');
+    assert.deepEqual([flight.state, flight.stuck], ['submitted', false]);
+  });
+
+  await test('a round with nothing to keep is closed with the note as its reason, freeing the page', async () => {
+    const r = await call('POST', RELEASE('landing:projects'), { body: { note: NOTE } });
+    assert.equal(r.status, 200, JSON.stringify(r.body));
+    assert.equal(r.body.outcome, 'abandoned');
+    assert.equal(task(7002).status, 'abandoned');
+    assert.equal(task(7002).value_summary, `Abandoned: ${NOTE}`);
+    const flight = (await call('GET', '/copy-desk/pages')).body.in_flight.find((f) => f.page_id === 'landing:projects');
+    assert.equal(flight, undefined, 'the page has no open round any more');
+  });
+
+  await test('a second release finds nothing stuck and changes nothing', async () => {
+    const r = await call('POST', RELEASE('landing:projects'), { body: { note: NOTE } });
+    assert.equal(r.status, 409);
+    assert.equal(errCode(r.body), 'not_stuck');
+  });
+
+  await test('the port refuses a round held for its artist, a shipped round and an ordinary task', async () => {
+    db.tasks.push({ id: '7004', status: 'completed', title: 'x', description: '', source: 'page-tweak', source_ref: pages.roundSourceRef('landing:index', 9), touches: [] });
+    db.grades.set('7004', true);
+    assert.equal((await lifecyclePort.releaseStuckTweak({ taskId: '7004', builderId: CARL, expectedStatus: 'completed' })).outcome, 'not_stuck');
+    assert.equal(task(7004).status, 'completed');
+    db.tasks.push({ id: '7005', status: 'completed', title: 'x', description: '', source: 'planning-session', source_ref: 'x', touches: [] });
+    assert.equal((await lifecyclePort.releaseStuckTweak({ taskId: '7005', builderId: CARL, expectedStatus: 'completed' })).outcome, 'wrong_source');
+    assert.equal((await lifecyclePort.releaseStuckTweak({ taskId: '7002', builderId: CARL, expectedStatus: 'abandoned' })).outcome, 'not_stuck');
+    db.tasks.push({ id: '7006', status: 'active', title: 'x', description: '', source: 'page-tweak', source_ref: pages.roundSourceRef('landing:index', 8), touches: [] });
+    db.claims.push({ id: String(++db.seq.claim), task_id: '7006', builder_id: ALICE, worktree_name: null, creator_session_id: null, claimed_at: '2026-09-19T00:00:00Z', released_at: null });
+    assert.equal((await lifecyclePort.releaseStuckTweak({ taskId: '7006', builderId: CARL, expectedStatus: 'active' })).outcome, 'round_moved', 'a claim taken since the read stops the release');
+    assert.equal(task(7006).status, 'active');
+    assert.equal((await lifecyclePort.releaseStuckTweak({ taskId: '7003', builderId: CARL, expectedStatus: 'active' })).outcome, 'round_moved');
+  });
+} finally {
+  server.close();
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
+summary();

package/tests/copy_inventory.mjs

@@ -26,7 +26,7 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const inv = require(path.join(ROOT, 'scripts', 'gds', 'copy-inventory.js'));
+const inv = require(path.join(ROOT, 'scripts', 'bongos', 'copy-inventory.js'));
 
 test('stable ids survive a move and change with the text', () => {
   const a = inv.stableId('builders-hall', 'Close your tab');
@@ -230,7 +230,7 @@ test('the report says what it cannot see, every time', () => {
 test('the committed artifacts match the tree (regenerate + commit, never hand-edit)', () => {
   const { stale } = inv.write({ check: true });
   assert.deepEqual(stale, [],
-    `stale: ${stale.join(', ')} — run \`node scripts/gds/copy-inventory.js\` and commit the result`);
+    `stale: ${stale.join(', ')} — run \`node scripts/bongos/copy-inventory.js\` and commit the result`);
 });
 
 test('the landing surface points at the real template, not the file that reads it', () => {

package/tests/core_auto_upgrade.mjs

@@ -13,7 +13,7 @@
 // Run:  node tests/core_auto_upgrade.mjs
 
 import { strict as assert } from 'node:assert';
-import { autoUpgradeTick, AUTO_MOVES_PER_TICK, autoUpgradeEnabled, TRANSIENT_HOLD_MS } from '../scripts/gds/provision-auto-upgrade.js';
+import { autoUpgradeTick, AUTO_MOVES_PER_TICK, autoUpgradeEnabled, TRANSIENT_HOLD_MS } from '../scripts/bongos/provision-auto-upgrade.js';
 
 let passed = 0;
 let failed = 0;

package/tests/core_move_notice.mjs

@@ -1,7 +1,7 @@
 // tests/core_move_notice.mjs — after the project's core moves, its own hall says so once,
 // with what changed, and Settings → Software update keeps a short history (task 1004731).
 //
-// The move writes one row to THIS project's own core_upgrades ledger (scripts/gds/upgrade.js);
+// The move writes one row to THIS project's own core_upgrades ledger (scripts/bongos/upgrade.js);
 // the running core carries the release notes for every version up to itself
 // (release-notes.json). src/bongos/core-moves.js reads both back: GET /core-update carries
 // the one-time notice (`moved`) for the banner, GET /software-update the history. The
@@ -344,7 +344,7 @@ await t('no history, no change: the panel draws exactly what it did before', asy
 // ---- the hub's automatic move marks itself in the project's ledger -------------------------
 
 await t('the hub\'s automatic move passes the auto-subscription note; a door move and a preview do not', () => {
-  const R = require('../scripts/gds/provision-core-upgrade.js');
+  const R = require('../scripts/bongos/provision-core-upgrade.js');
   const box = { slug: 'toast', port: 4100, hosting_shape: 'cloud-host' };
   const as = { runAs: 'bongos', migrateAs: 'bongos' };
   assert.match(R.upgradeInvocation(box, '1.21.23', { ...as, automatic: true }).cmd, / --note auto-subscription(\s|$)/);

package/tests/core_origin_follow.mjs

@@ -18,8 +18,8 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 
 const require = createRequire(import.meta.url);
-const follow = require('../scripts/gds/core-origin-follow.js');
-const pinSync = require('../scripts/gds/core-pin-sync.js');
+const follow = require('../scripts/bongos/core-origin-follow.js');
+const pinSync = require('../scripts/bongos/core-pin-sync.js');
 
 let passed = 0;
 let failed = 0;
@@ -50,10 +50,10 @@ function installCore(root, version) {
   const core = path.join(root, 'node_modules', '@bongos', 'core');
   fs.rmSync(path.join(root, 'node_modules'), { recursive: true, force: true });
   fs.mkdirSync(path.join(core, 'bin'), { recursive: true });
-  fs.mkdirSync(path.join(core, 'scripts', 'gds'), { recursive: true });
+  fs.mkdirSync(path.join(core, 'scripts', 'bongos'), { recursive: true });
   fs.writeFileSync(path.join(core, 'package.json'), JSON.stringify({ name: '@bongos/core', version }));
   fs.writeFileSync(path.join(core, 'bin', 'bongos.js'), '');
-  fs.writeFileSync(path.join(core, 'scripts', 'gds', 'fitness.js'), '');
+  fs.writeFileSync(path.join(core, 'scripts', 'bongos', 'fitness.js'), '');
   return core;
 }
 
@@ -124,7 +124,7 @@ test('clean main: says the project moved, fast-forwards, reinstalls, re-runs, sc
   assert.equal(calls.installs.length, 1, 'npm ran once');
   assert.equal(calls.installs[0][0], 'ci');
   assert.deepEqual(calls.reruns, [['start']], 'start re-ran under the new core');
-  assert.ok(fs.existsSync(path.join(laptop, 'scripts', 'gds', 'fitness.js')), 'the scripts link still resolves');
+  assert.ok(fs.existsSync(path.join(laptop, 'scripts', 'bongos', 'fitness.js')), 'the scripts link still resolves');
   const installed = JSON.parse(fs.readFileSync(path.join(laptop, 'node_modules', '@bongos', 'core', 'package.json'), 'utf8'));
   assert.equal(installed.version, NEW);
 });
@@ -270,7 +270,7 @@ test('a scripts link left dangling after the install is re-pointed at the instal
   fs.rmSync(gone, { recursive: true });
   const logs = [];
   assert.equal(pinSync.healScriptsLink(laptop, { log: (s) => logs.push(s) }), 'repointed');
-  assert.ok(fs.existsSync(path.join(link, 'gds', 'fitness.js')));
+  assert.ok(fs.existsSync(path.join(link, 'bongos', 'fitness.js')));
   // a real scripts/ directory (the core repo shape) is never touched
   const real = fs.mkdtempSync(path.join(os.tmpdir(), 'core-origin-follow-real-'));
   fs.mkdirSync(path.join(real, 'scripts'));
@@ -280,7 +280,7 @@ test('a scripts link left dangling after the install is re-pointed at the instal
 test('the dispatcher runs the follow before ship and start', () => {
   const src = fs.readFileSync(new URL('../bin/bongos.js', import.meta.url), 'utf8');
   assert.match(src, /verb === 'ship' \|\| verb === 'start'/);
-  assert.match(src, /require\('\.\.\/scripts\/gds\/core-origin-follow\.js'\)\.ensureCurrentCore/);
+  assert.match(src, /require\('\.\.\/scripts\/(?:gds|bongos)\/core-origin-follow\.js'\)\.ensureCurrentCore/);
 });
 
 console.log(`\n${passed} passed, ${failed} failed`);

package/tests/core_pin_sync.mjs

@@ -17,7 +17,7 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 
 const require = createRequire(import.meta.url);
-const sync = require('../scripts/gds/core-pin-sync.js');
+const sync = require('../scripts/bongos/core-pin-sync.js');
 
 let passed = 0;
 let failed = 0;
@@ -233,8 +233,8 @@ test('the dispatcher runs the check for ship (and start only after a followed co
   // which calls ensurePinnedCore for `ship` always and for `start` only after it
   // fast-forwarded a hub pin move (tests/core_origin_follow.mjs drives both).
   const src = fs.readFileSync(new URL('../bin/bongos.js', import.meta.url), 'utf8');
-  assert.match(src, /if \(!COMPILED && \(verb === 'ship' \|\| verb === 'start'\)\) \{\s*const synced = require\('\.\.\/scripts\/gds\/core-origin-follow\.js'\)\.ensureCurrentCore/);
-  const follow = fs.readFileSync(new URL('../scripts/gds/core-origin-follow.js', import.meta.url), 'utf8');
+  assert.match(src, /if \(!COMPILED && \(verb === 'ship' \|\| verb === 'start'\)\) \{\s*const synced = require\('\.\.\/scripts\/(?:gds|bongos)\/core-origin-follow\.js'\)\.ensureCurrentCore/);
+  const follow = fs.readFileSync(new URL('../scripts/bongos/core-origin-follow.js', import.meta.url), 'utf8');
   assert.match(follow, /if \(verb !== 'ship' && followed\.action !== 'fast-forwarded'\) return null;\s*return pinSync\.ensurePinnedCore/);
 });
 

package/tests/core_upgrade_door.mjs

@@ -375,7 +375,7 @@ await t('THE SELF-ROW GUARD IS VACUOUS FOR THIS ACTION, so neither door half may
   }
   // Neither half of the door may name it. If a later edit puts it back, this fails
   // and points at the sentence above rather than at a mystery.
-  for (const f of [['modules', 'provisioning', 'core-upgrade.js'], ['scripts', 'gds', 'provision-core-upgrade.js']]) {
+  for (const f of [['modules', 'provisioning', 'core-upgrade.js'], ['scripts', 'bongos', 'provision-core-upgrade.js']]) {
     const src = read(...f).replace(/\/\*[\s\S]*?\*\//g, ' ').replace(/^\s*\/\/.*$/gm, ' ');
     assert.ok(!/intentAllowedForShape\s*\(/.test(src),
       `${f.join('/')} must not call intentAllowedForShape — it can only ever return true here`);
@@ -933,7 +933,7 @@ const runChannel = async (inst, body, calls = []) => {
 };
 
 await t('the web tier\'s channel list is the runner\'s, and the migration\'s CHECK carries the same values', () => {
-  const policy = require('../scripts/gds/update-channel.js');
+  const policy = require('../scripts/bongos/update-channel.js');
   assert.deepEqual([...UPDATE_CHANNELS], policy.VALID_CHANNELS, 're-stated in the module (ADR 0083) — so it must be equal');
   assert.equal(DEFAULT_UPDATE_CHANNEL, policy.DEFAULT_CHANNEL);
   const sql = read('modules', 'provisioning', 'migrations', 'provisioning_029_update_channel.sql');

package/tests/core_upgrade_owner_door.mjs

@@ -38,7 +38,7 @@ const seams = require('../src/module-seams.js');
 const catalog = require('../modules/government/catalog.js');
 const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
 const AZ = require('../modules/provisioning/core-upgrade-authz.js');
-const { requestedByOf } = require('../scripts/gds/provision-core-upgrade.js');
+const { requestedByOf } = require('../scripts/bongos/provision-core-upgrade.js');
 const { hubDeployUrl } = require('../src/bongos/routes/core-update.js');
 
 let passed = 0;
@@ -323,6 +323,39 @@ await t('an Archon is admitted by the atom without the second door being asked',
 seams._reset();
 nextSession = null;
 
+// ── 5b. who may press Move (task 1004829) ─────────────────────────────────────
+// The deploy page draws its "Move to X?" card only where the preview says
+// viewer_may_move. Both previews already took the move's two doors, so the answer
+// is the move's LAST check: act-alone at Release, skipped for the project's owner
+// exactly as the move skips it.
+
+console.log('\nwho may press Move:');
+
+const { viewerMayMove } = require('../modules/provisioning/routes/core-upgrade.js');
+async function mayMoveWith(actAlone, req) {
+  seams._reset();
+  if (actAlone !== undefined) seams.registerProvider('government', { checkActAlone: actAlone });
+  try { return await viewerMayMove(req); } finally { seams._reset(); }
+}
+const PIN_REQ = { builder: { id: 42 }, coreUpgradeAuthority: 'pin' };
+
+await t('a pin holder the Release building lets act alone may press Move', async () => {
+  assert.equal(await mayMoveWith(async (area) => { assert.equal(area, 'release'); return { ok: true }; }, PIN_REQ), true);
+});
+await t('a pin holder whose Release is decided by the board may not', async () => {
+  assert.equal(await mayMoveWith(async () => ({ ok: false, reason: 'decided_by_sitting' }), PIN_REQ), false);
+});
+await t('an unreadable rule offers no Move, as the move itself would refuse', async () => {
+  assert.equal(await mayMoveWith(async () => { throw new Error('db down'); }, PIN_REQ), false);
+});
+await t('the project\'s owner is not asked about Release, as the move does not ask', async () => {
+  const spy = async () => { throw new Error('must not be consulted for the owner door'); };
+  assert.equal(await mayMoveWith(spy, { builder: { id: 7 }, coreUpgradeAuthority: 'owner' }), true);
+});
+await t('no government port passes, as requireActAlone does', async () => {
+  assert.equal(await mayMoveWith(undefined, PIN_REQ), true);
+});
+
 // ── 6. the hand-off address, and the hall that uses it ────────────────────────
 
 console.log('\nthe hand-off to the hub:');