@bongos/core 1.21.175 → 1.21.177

package/tests/recall_corpus_health.mjs

@@ -34,7 +34,7 @@ import { fileURLToPath } from 'node:url';
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const search = require('../modules/memory/search.js');
-const { renderNoMatch } = require('../scripts/gds/recall.js');
+const { renderNoMatch } = require('../scripts/bongos/recall.js');
 const { classifyEmptyResult } = search;
 
 let passed = 0;
@@ -174,7 +174,8 @@ test('the response literal stays STATIC so the OpenAPI schema survives', () => {
   assert.match(src, /res\.json\(\{ query: q, count: results\.length, total_full_tokens: totalFullTokens, results, corpus \}\)/,
     'the search response must be a flat, static object literal');
   assert.doesNotMatch(src, /\.\.\.\(corpus \?/, 'no conditional spread in the response literal');
-  const spec = JSON.parse(fs.readFileSync(path.join(ROOT, 'docs/api/openapi.json'), 'utf8'));
+  // The spec is gitignored (task 1004866): build it from the routes.
+  const spec = require('../scripts/bongos/gen-api-docs.js').build().spec;
   const schema = spec.components.schemas.PostSearchResponse;
   assert.ok(schema, 'PostSearchResponse must still exist in the spec');
   assert.ok('corpus' in schema.properties, 'and now document the corpus diagnostic');

package/tests/recall_hints.mjs

@@ -73,7 +73,7 @@ t('formatHints: renders claim id, titles, source, and the /recall pointer', () =
     { task_id: 963, title: 'Session-start recall hints' },
     [
       { title: 'ADR 0060 — GDS retrieval layer', heading_path: 'docs/adr/0060-gds-retrieval-layer.md' },
-      { title: 'recall skill', source_ref: 'scripts/gds/recall.js' },
+      { title: 'recall skill', source_ref: 'scripts/bongos/recall.js' },
     ]
   );
   assert.match(out, /#963/);

package/tests/recruiter_sliver_boundary.mjs

@@ -940,7 +940,7 @@ test('no rank, role, permission or membership travels with the sliver, under any
 // ===========================================================================
 
 test('this proof runs in the DB-free unit lane', () => {
-  const runner = fs.readFileSync(path.join(ROOT, 'scripts/gds/run-unit-tests.js'), 'utf8');
+  const runner = fs.readFileSync(path.join(ROOT, 'scripts/bongos/run-unit-tests.js'), 'utf8');
   assert.ok(!/recruiter_sliver_boundary/.test(runner),
     'named in run-unit-tests.js it would be parked into INTEGRATION or KNOWN_FAILING and gate nothing (learning 1000218)');
 });

package/tests/redteam_patrol.mjs

@@ -10,7 +10,7 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const p = require(path.join(ROOT, 'scripts', 'gds', 'redteam-patrol.js'));
+const p = require(path.join(ROOT, 'scripts', 'bongos', 'redteam-patrol.js'));
 
 test('parseGitleaksReport maps rows to high-severity findings; junk → []', () => {
   const rows = JSON.stringify([{ RuleID: 'aws-key', File: 'x.js', Commit: 'abcdef1234567890' }]);
@@ -118,7 +118,7 @@ test('filingBlocker reports a sessionless runner instead of exiting with re-auth
   // simulate a runner with no session file — the suite's own machine has one.
   const home = fs.mkdtempSync(path.join(os.tmpdir(), 'patrol-home-'));
   const r = spawnSync(process.execPath, ['-e',
-    `const p = require(${JSON.stringify(path.join(ROOT, 'scripts', 'gds', 'redteam-patrol.js'))});
+    `const p = require(${JSON.stringify(path.join(ROOT, 'scripts', 'bongos', 'redteam-patrol.js'))});
      console.log(JSON.stringify({ blocker: p.filingBlocker() }));`,
   ], { env: { ...process.env, HOME: home, USERPROFILE: home }, encoding: 'utf8' });
   assert.equal(r.status, 0, `expected a clean return, not an exit: ${r.stderr}`);

package/tests/regrade_actual_minutes.mjs

@@ -14,7 +14,7 @@
 // between attempts into the sum — for task 1002343 that is ~3 days, roughly
 // 4300 minutes in place of 19, which is worse than stale and poisons the same
 // calibration the fix was meant to protect. The ship's own session digest
-// (scripts/gds/session-digest-build.js) measures a Claude Code SESSION, which
+// (scripts/bongos/session-digest-build.js) measures a Claude Code SESSION, which
 // routinely spans several tasks and is absent outside an interactive one. An
 // opt-in --minutes flag would be omitted by default, which is the present
 // silence with a flag beside it. So: actual_minutes means CLAIMED-session time,
@@ -80,7 +80,7 @@ test('a task with no actual_minutes at all builds the same prompt', () => {
 
 test('no grader entry reads actual_minutes — the one scorer that did is retired', () => {
   // scoreEstActualBand was the ONE scorer that read the figure. It lived in the v1
-  // gradeDeterministic, whose only non-test caller was scripts/gds/audit-ships.js;
+  // gradeDeterministic, whose only non-test caller was scripts/bongos/audit-ships.js;
   // task 1002842 retired all three. So the stale-figure risk this file guards is now
   // closed at the source, and this pins it: nothing in the grading module may
   // accept or read the figure, and the retired entry may not come back.

package/tests/regrade_eligibility.mjs

@@ -5,7 +5,7 @@
 // lands the task at `completed` with the claim already consumed, and there was
 // no clean CLI path back in to re-grade after fixing the findings.
 //
-// `node scripts/gds/ship.js <id> --regrade` re-runs ONLY the grade step against
+// `node scripts/bongos/ship.js <id> --regrade` re-runs ONLY the grade step against
 // the committed diff with no claim. The gate (evaluateRegradeEligibility) and
 // the POST-body mapper (buildGradePayload) are pure, so they're tested
 // hermetically here — no DB, no network, no git.
@@ -16,7 +16,7 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const ship = require('../scripts/gds/ship.js');
+const ship = require('../scripts/bongos/ship.js');
 
 let passed = 0;
 let failed = 0;

package/tests/release_core.mjs

@@ -13,7 +13,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
-const { releaseDecision, main } = require('../scripts/gds/release-core.js');
+const { releaseDecision, main } = require('../scripts/bongos/release-core.js');
 
 const VERSIONS = ['1.20.70', '1.20.75', '1.20.80', '1.20.81-rc.1'];
 
@@ -90,7 +90,7 @@ const YML = fs.readFileSync(fileURLToPath(new URL('../.github/workflows/publish.
 
 test('publish.yml: the release job asks release-core.js and moves `latest` only on go', () => {
   assert.match(YML, /release_version:/, 'the dispatch input exists');
-  assert.match(YML, /node scripts\/gds\/release-core\.js --version "\$RELEASE_VERSION"/);
+  assert.match(YML, /node scripts\/(?:gds|bongos)\/release-core\.js --version "\$RELEASE_VERSION"/);
   assert.match(YML, /if: steps\.decide\.outputs\.go == 'true'\s+run: npm dist-tag add "@bongos\/core@\$RELEASE_VERSION" latest/);
 });
 

package/tests/release_notes.mjs

@@ -27,15 +27,15 @@ import path from 'node:path';
 import {
   RELEASE_NOTES_FILE, parseChangeRecords, parseLogRecords, buildReleaseNotes, generateReleaseNotes,
   serializeReleaseNotes, boundReleaseNotes, notesBetween,
-} from '../scripts/gds/release-notes.js';
+} from '../scripts/bongos/release-notes.js';
 import {
   releaseNotesArtifact, scanArtifactForLeaks, PRIOR_INSTANCE_FLOOR, buildTar, TAR_ROOT,
   sha256hex, canonicalTreeHash, buildCoreManifest, withTarballInfo, reproducePinFromTree,
-} from '../scripts/gds/package-core.js';
+} from '../scripts/bongos/package-core.js';
 import {
   readPackagedNotes, readInstalledNotes, parseChangeRecords as runnerParser,
-} from '../scripts/gds/provision-core-upgrade.js';
-import { buildRedactionRules, collectSensitiveLiterals } from '../scripts/gds/mirror-redact.js';
+} from '../scripts/bongos/provision-core-upgrade.js';
+import { buildRedactionRules, collectSensitiveLiterals } from '../scripts/bongos/mirror-redact.js';
 
 const TMP = fs.mkdtempSync(path.join(os.tmpdir(), 'bongos-release-notes-test-'));
 process.on('exit', () => { try { fs.rmSync(TMP, { recursive: true, force: true }); } catch { /* best-effort */ } });

package/tests/rename_history_restraint.mjs

@@ -21,8 +21,8 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const check = require(path.join(ROOT, 'scripts', 'gds', 'rename-history-check.js'));
-const scan = require(path.join(ROOT, 'scripts', 'gds', 'gds-literal-scan.js'));
+const check = require(path.join(ROOT, 'scripts', 'bongos', 'rename-history-check.js'));
+const scan = require(path.join(ROOT, 'scripts', 'bongos', 'gds-literal-scan.js'));
 
 const LITERAL = ['G', 'D', 'S'].join(''); // built, not written, so the fixtures below carry no vocabulary of their own
 
@@ -40,7 +40,7 @@ test('a RENAMED migration fails and is named — schema_migrations keys on the s
     'migrations/019_rename_pms_v3_to_gds_v3.sql',
     'modules/economy/migrations/economy_001_fix_gds_shipper_description.sql',
   ];
-  // exactly what a scripts/gds/ → scripts/bongos/ codemod would do to these two
+  // exactly what a scripts/bongos/ → scripts/bongos/ codemod would do to these two
   const present = [
     'migrations/019_rename_pms_v3_to_bongos_v3.sql',
     'modules/economy/migrations/economy_001_fix_bongos_shipper_description.sql',

package/tests/rename_ledger_prose.mjs

@@ -18,14 +18,14 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const L = require(path.join(ROOT, 'scripts', 'gds', 'rename-ledger-prose.js'));
+const L = require(path.join(ROOT, 'scripts', 'bongos', 'rename-ledger-prose.js'));
 
 // ---------- identifiers are not vocabulary ----------
 
 test('every identifier shape survives a rewrite byte for byte', () => {
   for (const kept of [
     'GDS_API_BASE', 'GDS_TOKEN', 'GDS_BRANDING_FILE', 'MEDUSA_GDS_ONLY',
-    '/api/gds', '/api/gds/tasks', 'scripts/gds/ship.js', 'src/gds/db.js',
+    '/api/gds', '/api/gds/tasks', 'scripts/bongos/ship.js', 'src/gds/db.js',
     'gds_session', 'gds-session.json', 'GDS-V3', 'GDS-V4',
   ]) {
     const text = `prose around ${kept} and more prose`;
@@ -36,7 +36,7 @@ test('every identifier shape survives a rewrite byte for byte', () => {
 
 test('a row carrying ONLY identifiers proposes no change at all', () => {
   assert.equal(L.rewrite('set GDS_API_BASE, hit /api/gds, read the gds_session cookie'), null);
-  assert.equal(L.rewrite('run scripts/gds/ship.js'), null);
+  assert.equal(L.rewrite('run scripts/bongos/ship.js'), null);
 });
 
 test('an identifier and real vocabulary in the same sentence: one changes, one does not', () => {
@@ -45,7 +45,7 @@ test('an identifier and real vocabulary in the same sentence: one changes, one d
 });
 
 test('the mask round-trips exactly — a corrupted identifier would be silent', () => {
-  const text = 'GDS_TOKEN and /api/gds and GDS-V4 and scripts/gds/x.js';
+  const text = 'GDS_TOKEN and /api/gds and GDS-V4 and scripts/bongos/x.js';
   const { masked, masks } = L.maskIdentifiers(text);
   assert.ok(!masked.includes('GDS_TOKEN'));
   assert.equal(L.unmask(masked, masks), text);
@@ -55,8 +55,8 @@ test('the version-id rule is SHARED with the C2 ratchet and the C5 pin, not re-d
   // The task asked for exactly this: "REUSE it rather than writing a second,
   // divergent rule". Two copies drift the moment either side learns a new
   // version id, and the drift is silent — this asserts one source.
-  const scan = require(path.join(ROOT, 'scripts', 'gds', 'gds-literal-scan.js'));
-  const history = require(path.join(ROOT, 'scripts', 'gds', 'rename-history-check.js'));
+  const scan = require(path.join(ROOT, 'scripts', 'bongos', 'gds-literal-scan.js'));
+  const history = require(path.join(ROOT, 'scripts', 'bongos', 'rename-history-check.js'));
   assert.ok(L.IDENTIFIER_PATTERNS.includes(scan.GDS_VERSION_ID_RE), 'the version-id regex must be the ratchet’s own object');
   assert.deepEqual([...L.FROZEN_VERSION_IDS], history.PINNED_VERSION_IDS, 'the frozen set must come from the C5 pin');
 });

package/tests/render_api.mjs

@@ -17,7 +17,7 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const { RenderApi, RenderApiError, RenderOwnerMismatch, ownerOf } = require('../scripts/gds/render-api.js');
+const { RenderApi, RenderApiError, RenderOwnerMismatch, ownerOf } = require('../scripts/bongos/render-api.js');
 
 let passed = 0, failed = 0;
 async function ta(name, fn) {

package/tests/render_check.mjs

@@ -8,8 +8,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawnSync } from 'node:child_process';
-import { FIT_FLOORS, SIZES, statesFilesFor, fitFindings, shotsDir, startHarness } from '../scripts/gds/render-check.js';
-import { STEPS, runStep, summarize, format } from '../scripts/gds/ship-check.js';
+import { FIT_FLOORS, SIZES, statesFilesFor, fitFindings, shotsDir, startHarness } from '../scripts/bongos/render-check.js';
+import { STEPS, runStep, summarize, format } from '../scripts/bongos/ship-check.js';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const names = (paths) => statesFilesFor(paths, ROOT).map((f) => path.basename(f));
@@ -101,7 +101,7 @@ test('a harness that comes up is handed back with a stop that ends it', async ()
 });
 
 test('the CLI renders nothing, and says why, when no page a states file describes changed', () => {
-  const cli = (files) => spawnSync(process.execPath, [path.join(ROOT, 'scripts', 'gds', 'render-check.js'), '--files', files], { cwd: ROOT, encoding: 'utf8' });
+  const cli = (files) => spawnSync(process.execPath, [path.join(ROOT, 'scripts', 'bongos', 'render-check.js'), '--files', files], { cwd: ROOT, encoding: 'utf8' });
   const none = cli('src/bongos/db.js');
   assert.equal(none.status, 0);
   assert.match(none.stdout, /no rendered surface changed/);
@@ -112,7 +112,7 @@ test('the CLI renders nothing, and says why, when no page a states file describe
 
 test('ship-check runs the render check as an advisory row: findings warn, no browser skips, neither flips the exit', () => {
   const step = STEPS.find((s) => s.key === 'render-fit');
-  assert.ok(step && step.advisory && step.argv[0] === 'scripts/gds/render-check.js');
+  assert.ok(step && step.advisory && step.argv[0] === 'scripts/bongos/render-check.js');
   assert.ok(step.optional, 'an absent script is skipped, never counted as stale');
   assert.equal(step.skipWith, '--no-render');
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ship-check-advisory-'));

package/tests/render_deploy.mjs

@@ -25,7 +25,7 @@ const deploys = require('../modules/render-deploy/deploys.js');
 const buildApp = require('../modules/render-deploy/routes/app.js');
 const buildHistory = require('../modules/render-deploy/routes/history.js');
 const buildAct = require('../modules/render-deploy/routes/act.js');
-const { RenderApi } = require('../scripts/gds/render-api.js');
+const { RenderApi } = require('../scripts/bongos/render-api.js');
 
 const KEY = 'rnd_TESTKEYTESTKEYTESTKEY1234';
 const OWNER = 'tea-ownerownerowner';

package/tests/repo_info_binding.mjs

@@ -39,7 +39,7 @@ function test(name, fn) {
 }
 
 // Neutral fixture identity. Implementation code under tests/ must not hardcode any real
-// owner's identity (V3.R12, enforced by scripts/gds/audit-authorship.sh) — and the
+// owner's identity (V3.R12, enforced by scripts/bongos/audit-authorship.sh) — and the
 // assertions care only that the parsed pair round-trips, so a synthetic pair is strictly
 // better.
 const FIXTURE_OWNER = 'testowner';

package/tests/repo_map.mjs

@@ -9,7 +9,7 @@ import path from 'node:path';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const GEN = path.join(ROOT, 'scripts', 'gds', 'gen-repo-map.js');
+const GEN = path.join(ROOT, 'scripts', 'bongos', 'gen-repo-map.js');
 const G = require(GEN); // require.main-guarded → importing runs no main()
 
 function run(args) {
@@ -67,7 +67,7 @@ test('the generated repo map has the ranked global table and real signatures', (
 test('each nested CLAUDE.md carries a delimited generated block with signatures', () => {
   const BEGIN = '<!-- BEGIN GENERATED REPO-MAP';
   const END = '<!-- END GENERATED REPO-MAP -->';
-  for (const dir of ['src/bongos', 'src/bongos/routes']) { // scripts/gds left NESTED_DIRS in task 1003548
+  for (const dir of ['src/bongos', 'src/bongos/routes']) { // scripts/bongos left NESTED_DIRS in task 1003548
     const doc = readFileSync(path.join(ROOT, dir, 'CLAUDE.md'), 'utf8');
     assert.ok(doc.includes(BEGIN), `${dir}/CLAUDE.md should have a generated-block start marker`);
     assert.ok(doc.includes(END), `${dir}/CLAUDE.md should have a generated-block end marker`);
@@ -88,9 +88,9 @@ test('extractor parses functions, classes, arrow consts, and module.exports', ()
   const r = run(['--json']);
   const model = JSON.parse(r.stdout);
   // DoApi is a plain `class X extends Y` declaration in a control-plane client.
-  const doApi = model.allSyms.find((s) => s.name === 'DoApi' && s.file === 'scripts/gds/do-api.js');
+  const doApi = model.allSyms.find((s) => s.name === 'DoApi' && s.file === 'scripts/bongos/do-api.js');
   assert.ok(doApi && doApi.kind === 'class', 'class declarations are detected');
-  const apiCall = model.allSyms.find((s) => s.name === 'apiCall' && s.file === 'scripts/gds/cli-lib.js');
+  const apiCall = model.allSyms.find((s) => s.name === 'apiCall' && s.file === 'scripts/bongos/cli-lib.js');
   assert.ok(apiCall && apiCall.exported && apiCall.kind === 'fn', 'exported arrow/fn const detected with export flag');
 });
 
@@ -106,7 +106,7 @@ test('--whole-only never writes a TRACKED nested block (the sparse-checkout dead
   // Asserted on CONTENT, not on the log line: dirty a tracked block, run --whole-only,
   // and require the block to come back byte-identical. A regression that re-enabled the
   // bucket would rewrite it and fail here even if the summary line still looked right.
-  const tracked = path.join(ROOT, 'scripts', 'gds', 'CLAUDE.md');
+  const tracked = path.join(ROOT, 'scripts', 'bongos', 'CLAUDE.md');
   const pristine = readFileSync(tracked, 'utf8');
   const drifted = `${pristine}\n<!-- simulated sparse-checkout drift -->\n`;
   writeFileSync(tracked, drifted);

package/tests/reward_mode_cost_plus_only.mjs

@@ -73,16 +73,20 @@ try {
     'cost-plus-only ⇒ perTaskCredit is off');
 
   await cleanup();
-  await q(`INSERT INTO versions (id,name,status,track) VALUES ($1,'rm','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,'rm','building','internal') ON CONFLICT (id) DO NOTHING`, [VER]);
   // Archon so no rank/newcomer gate interferes with the ship.
   await q(`INSERT INTO builders (id,github_id,github_login,display_name,rank) VALUES ($1,'rm-w','rm-worker','RM Worker','archon')`, [WORKER]);
   // A confirmed task owned by WORKER with a real estimate. In DEFAULT mode this
   // would pay 60 × 1.0 (feature) at ship; in cost-plus-only it must pay nothing.
-  await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind,shipped_by) VALUES ($1,$2,'rm task','confirmed',60,'feature',$3)`, [TASK, VER, WORKER]);
+  await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind,shipped_by,discipline) VALUES ($1,$2,'rm task','confirmed',60,'feature',$3,'engineer')`, [TASK, VER, WORKER]);
   await q(`INSERT INTO claims (task_id,builder_id,claimed_at) VALUES ($1,$2, now())`, [TASK, WORKER]);
 
   // Drive the REAL ship transition (the same call the reconciler/ship.js use).
-  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' } });
 
   const status = (await q(`SELECT status FROM tasks WHERE id=$1`, [TASK]))[0].status;
   ok(status === 'shipped', `the task shipped (status=${status})`);

package/tests/reward_mode_surfacing.mjs

@@ -21,7 +21,7 @@ const require = createRequire(import.meta.url);
 const card = require('../modules/lifecycle/ship-card.js');
 const credits = require('../modules/economy/credits.js');
 const reward = require('../modules/economy/reward.js');
-const cli = require('../scripts/gds/cli-lib.js');
+const cli = require('../scripts/bongos/cli-lib.js');
 
 let passed = 0, failed = 0;
 function test(name, fn) {

package/tests/role_responsibilities.mjs

@@ -28,7 +28,7 @@ const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const src = require(path.join(ROOT, 'src', 'role-responsibilities.js'));
 const modules = require(path.join(ROOT, 'src', 'modules.js'));
 const api = require(path.join(ROOT, 'src', 'module-api.js'));
-const gen = require(path.join(ROOT, 'scripts', 'gds', 'gen-role-responsibilities.js'));
+const gen = require(path.join(ROOT, 'scripts', 'bongos', 'gen-role-responsibilities.js'));
 
 let passed = 0;
 let failed = 0;

package/tests/route_permission_check.mjs

@@ -32,7 +32,7 @@ const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const rrc = require(path.join(ROOT, 'src', 'bongos', 'route-rank-check.js'));
 const auth = require(path.join(ROOT, 'src', 'bongos', 'auth.js'));
-const genApiDocs = require(path.join(ROOT, 'scripts', 'gds', 'gen-api-docs.js'));
+const genApiDocs = require(path.join(ROOT, 'scripts', 'bongos', 'gen-api-docs.js'));
 
 const rankOf = (src) => rrc.classifyText(src)[0].rank;
 const rowOf = (src) => rrc.classifyText(src)[0];

package/tests/route_shadow_guard.mjs

@@ -23,7 +23,7 @@ const {
   mountSequence,
   isBareParam,
   isConstrainedParam,
-} = require('../scripts/gds/route-shadow-guard.js');
+} = require('../scripts/bongos/route-shadow-guard.js');
 
 let passed = 0;
 let failed = 0;

package/tests/route_validation.mjs

@@ -308,7 +308,7 @@ test('SUPERVISOR: POST /tasks/:id/confirm with empty body passes', () => {
 });
 
 // ---- Bonus supervisor-shaped flow: learning-capture.js posts to /learnings ----
-test('SUPERVISOR: POST /learnings shape (from scripts/gds/learning-capture.js) passes', () => {
+test('SUPERVISOR: POST /learnings shape (from scripts/bongos/learning-capture.js) passes', () => {
   const body = {
     tags: ['gds', 'validation'],
     title: 'V3.R33 input validation',

package/tests/routine_capture_kind.mjs

@@ -2,6 +2,7 @@
 // kind the server accepts (task 1003694).
 //
 // THE FAILURE THIS PINS. .claude/scheduled-tasks/dep-audit-nightly/SKILL.md filed
+// (before task 1004878 moved its filing into the server's daily-checks poller)
 // with `--kind security`. That is not one of the kinds — captureIdea throws BAD_KIND
 // and the route 400s — so the capture step of that nightly routine had NEVER filed
 // anything.
@@ -114,34 +115,44 @@ test('every literal --kind in a routine or skill is a kind the server accepts',
 });
 
 test('the matcher reads a literal kind on a capture command', () => {
-  assert.deepEqual(literalKinds('node scripts/gds/capture.js "t" --kind infra --body-file x'), ['infra']);
-  assert.deepEqual(literalKinds('node scripts/gds/capture.js "t" --kind security'), ['security'],
+  assert.deepEqual(literalKinds('node scripts/bongos/capture.js "t" --kind infra --body-file x'), ['infra']);
+  assert.deepEqual(literalKinds('node scripts/bongos/capture.js "t" --kind security'), ['security'],
     'the real bug is still caught');
 });
 
 test('a DIFFERENT tool\'s --kind is not this guard\'s business', () => {
   // recall.js takes --kind doc|db. Reading every --kind in the tree reported three
   // recall invocations as broken on the first run of this guard.
-  assert.deepEqual(literalKinds('node scripts/gds/recall.js nightly backup --kind doc'), []);
+  assert.deepEqual(literalKinds('node scripts/bongos/recall.js nightly backup --kind doc'), []);
   assert.deepEqual(literalKinds('add `--kind doc` for ADRs/recipes'), []);
 });
 
 test('a documented menu is not a value', () => {
-  assert.deepEqual(literalKinds('node scripts/gds/capture.js --kind <bug|cleanup|refactor>'), []);
-  assert.deepEqual(literalKinds('node scripts/gds/capture.js --kind cleanup|refactor \\'), []);
+  assert.deepEqual(literalKinds('node scripts/bongos/capture.js --kind <bug|cleanup|refactor>'), []);
+  assert.deepEqual(literalKinds('node scripts/bongos/capture.js --kind cleanup|refactor \\'), []);
 });
 
 test('a capture command wrapped over lines is still read', () => {
-  const text = ['node scripts/gds/capture.js "t" \\', '  --kind security \\', '  --body-file /tmp/x'].join('\n');
+  const text = ['node scripts/bongos/capture.js "t" \\', '  --kind security \\', '  --body-file /tmp/x'].join('\n');
   assert.deepEqual(literalKinds(text), ['security'],
     'dep-audit-nightly writes exactly this shape — a line-at-a-time matcher misses it');
 });
 
-test('dep-audit-nightly specifically now files with an accepted kind (task 1003694)', () => {
-  const p = path.join(REPO_ROOT, '.claude', 'scheduled-tasks', 'dep-audit-nightly', 'SKILL.md');
-  const src = readFileSync(p, 'utf8');
-  assert.ok(!/--kind\s+security\b/.test(src), 'security is not a kind and never was');
-  const kinds = literalKinds(src);
-  assert.ok(kinds.length > 0, 'the routine must still file something');
-  for (const k of kinds) assert.ok(VALID_KINDS.includes(k), `${k} is not a valid kind`);
+test('dep-audit-nightly specifically now files with an accepted kind (task 1003694)', async () => {
+  // Since task 1004878 the routine files from the server's daily-checks poller, not
+  // from a capture command in its SKILL.md — so the kind to check is the one the
+  // poller hands ideas.capture. Driven, not grepped: a stub npm reports one finding.
+  const { runCheck } = require('../modules/autonomy/pollers/daily-checks.js');
+  const filed = [];
+  const out = await runCheck('dep-audit-nightly', {
+    db: { readAutonomyRuns: async () => [], recordAutonomyRun: async () => ({}) },
+    cwd: '/instance',
+    npmAudit: async () => ({ stdout: JSON.stringify({ vulnerabilities: { x: { severity: 'high', via: [], fixAvailable: true } } }), stderr: '' }),
+    captureIdea: async (idea) => { filed.push(idea); return { id: 1 }; },
+    log: () => {}, error: () => {},
+  });
+  assert.equal(out.outcome, 'filed');
+  assert.equal(filed.length, 1);
+  assert.notEqual(filed[0].kind, 'security', 'security is not a kind and never was');
+  assert.ok(VALID_KINDS.includes(filed[0].kind), `${filed[0].kind} is not a valid kind`);
 });

package/tests/routine_schedule.mjs

@@ -18,8 +18,8 @@ import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const rs = require(path.join(ROOT, 'scripts', 'gds', 'routine-schedule.js'));
-const { parseRoutineFrontmatter } = require(path.join(ROOT, 'scripts', 'gds', 'run-routine.js'));
+const rs = require(path.join(ROOT, 'scripts', 'bongos', 'routine-schedule.js'));
+const { parseRoutineFrontmatter } = require(path.join(ROOT, 'scripts', 'bongos', 'run-routine.js'));
 
 const WEEKLY_WF = {
   file: 'redteam-patrol.yml',
@@ -31,7 +31,7 @@ const WEEKLY_WF = {
     'jobs:',
     '  patrol:',
     '    steps:',
-    '      - run: node scripts/gds/run-routine.js redteam-weekly',
+    '      - run: node scripts/bongos/run-routine.js redteam-weekly',
   ].join('\n'),
 };
 const routines = (withCadence, withoutCadence = []) => ({ withCadence, withoutCadence });
@@ -95,7 +95,7 @@ test('a routine declaring a sub-hourly cadence matches a step cron that fires it
   // committed scheduler actually fires it at 15 minutes.
   const wf = (cron) => [{
     file: 'sweep.yml',
-    text: `on:\n  schedule:\n    - cron: '${cron}'\njobs:\n  go:\n    steps:\n      - run: node scripts/gds/run-routine.js sweepy\n`,
+    text: `on:\n  schedule:\n    - cron: '${cron}'\njobs:\n  go:\n    steps:\n      - run: node scripts/bongos/run-routine.js sweepy\n`,
   }];
   const declared = routines([{ name: 'sweepy', cadence: '15min', steps: [] }]);
   assert.deepEqual(rs.evaluate(declared, wf('*/15 * * * *')).violations, []);
@@ -127,18 +127,18 @@ test('workflowCrons reads every cron a workflow declares, quoted or bare, ignori
 //                                                                an invocation
 
 test('invokesRoutine accepts the dispatcher form and a verbatim step command', () => {
-  assert.equal(rs.invokesRoutine('run: node scripts/gds/run-routine.js redteam-weekly', 'redteam-weekly'), true);
-  assert.equal(rs.invokesRoutine('run: node scripts/gds/run-routine.js --dry-run redteam-weekly', 'redteam-weekly'), true);
+  assert.equal(rs.invokesRoutine('run: node scripts/bongos/run-routine.js redteam-weekly', 'redteam-weekly'), true);
+  assert.equal(rs.invokesRoutine('run: node scripts/bongos/run-routine.js --dry-run redteam-weekly', 'redteam-weekly'), true);
   assert.equal(
-    rs.invokesRoutine('run: node scripts/gds/redteam-patrol.js --file', 'redteam-weekly',
-      [{ command: 'node scripts/gds/redteam-patrol.js --file' }]),
+    rs.invokesRoutine('run: node scripts/bongos/redteam-patrol.js --file', 'redteam-weekly',
+      [{ command: 'node scripts/bongos/redteam-patrol.js --file' }]),
     true);
 });
 
 test('invokesRoutine does not accept a prefix match for a different routine', () => {
   // `redteam-weekly-v2` must not satisfy `redteam-weekly` — that would let a
   // renamed routine keep the old one's green.
-  assert.equal(rs.invokesRoutine('node scripts/gds/run-routine.js redteam-weekly-v2', 'redteam-weekly'), false);
+  assert.equal(rs.invokesRoutine('node scripts/bongos/run-routine.js redteam-weekly-v2', 'redteam-weekly'), false);
 });
 
 // ------------------------------------------------------------------ the check
@@ -234,3 +234,45 @@ test('LIVE: the patrol workflow installs gitleaks, which the history scan cannot
   assert.match(wf, /sha256sum -c -/, 'the binary must be checksum-verified (the tj-actions lesson)');
   assert.match(wf, /fetch-depth: 0/, 'a shallow clone makes the history scan a confident no-op');
 });
+
+// ------------------------------------------------- the server scheduler (task 1004878)
+
+const SRV = [{ routine: 'nightly-thing', cadence: 'daily' }];
+
+test('a server row fires its routine: declared daily + server daily is green with NO workflow', () => {
+  const r = rs.evaluate(routines([{ name: 'nightly-thing', cadence: 'daily', steps: [] }]), [], SRV);
+  assert.deepEqual(r.violations, []);
+});
+
+test('without the server row the same routine is dormant — the row is what makes it green', () => {
+  const v = rs.evaluate(routines([{ name: 'nightly-thing', cadence: 'daily', steps: [] }]), [], []).violations;
+  assert.match(v[0], /NOTHING fires it/);
+});
+
+test('a server row at a different period than the routine declares is red', () => {
+  const v = rs.evaluate(routines([{ name: 'nightly-thing', cadence: 'weekly', steps: [] }]), [], SRV).violations;
+  assert.match(v[0], /declares cadence: weekly but the server fires it daily/);
+});
+
+test('the server firing a routine whose SKILL.md declares no cadence is red, not a quiet warning', () => {
+  const r = rs.evaluate(routines([], [{ name: 'nightly-thing' }]), [], SRV);
+  assert.match(r.violations[0], /fired daily by the server but its SKILL\.md declares no cadence/);
+  assert.equal(r.warnings.length, 0, 'the same routine must not ALSO read as manual-only');
+});
+
+test('a server row naming a routine that is gone is red (rename rot)', () => {
+  const v = rs.evaluate(routines(WEEKLY), [WEEKLY_WF], SRV).violations;
+  assert.ok(v.some((x) => /fires routine 'nightly-thing', which has no/.test(x)), v.join(' | '));
+});
+
+test('with no routine tree at all (an instance before materialize) server rows are not dangling', () => {
+  assert.deepEqual(rs.evaluate(routines([]), null, SRV).violations, []);
+});
+
+test('LIVE: every server-fired routine declares the cadence the server realizes', () => {
+  const { SERVER_ROUTINES } = require(path.join(ROOT, 'modules', 'autonomy', 'server-schedule.js'));
+  const declared = new Map(rs.readRoutines().withCadence.map((r) => [r.name, r.cadence]));
+  for (const s of SERVER_ROUTINES) {
+    assert.equal(declared.get(s.routine), s.cadence, `${s.routine}: SKILL.md cadence vs server-schedule.js`);
+  }
+});

package/tests/run_routine.mjs

@@ -6,7 +6,7 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 const require = createRequire(import.meta.url);
-const { parseRoutineFrontmatter, tokenize, resolveStepArgv } = require('../scripts/gds/run-routine.js');
+const { parseRoutineFrontmatter, tokenize, resolveStepArgv } = require('../scripts/bongos/run-routine.js');
 
 let passed = 0, failed = 0;
 function test(name, fn) {
@@ -74,14 +74,14 @@ const ROOTS = { coreRoot: '/core', instanceRoot: '/inst' };
 
 test('resolveStepArgv: `bongos exec <rel>` resolves under the CORE root', () => {
   assert.deepEqual(
-    resolveStepArgv(['bongos', 'exec', 'scripts/gds/box.js', 'sweep-idle', '--apply'], ROOTS),
-    [process.execPath, path.join('/core', 'scripts/gds/box.js'), 'sweep-idle', '--apply']);
+    resolveStepArgv(['bongos', 'exec', 'scripts/bongos/box.js', 'sweep-idle', '--apply'], ROOTS),
+    [process.execPath, path.join('/core', 'scripts/bongos/box.js'), 'sweep-idle', '--apply']);
 });
 
 test('resolveStepArgv: `node scripts/...` → CORE root; `node .claude/...` companion → INSTANCE root', () => {
   assert.deepEqual(
-    resolveStepArgv(['node', 'scripts/gds/x.js', '--flag'], ROOTS),
-    [process.execPath, path.join('/core', 'scripts/gds/x.js'), '--flag']);
+    resolveStepArgv(['node', 'scripts/bongos/x.js', '--flag'], ROOTS),
+    [process.execPath, path.join('/core', 'scripts/bongos/x.js'), '--flag']);
   assert.deepEqual(
     resolveStepArgv(['node', '.claude/scheduled-tasks/demo/run.js'], ROOTS),
     [process.execPath, path.join('/inst', '.claude/scheduled-tasks/demo/run.js')]);