@bongos/core 1.18.19 → 1.19.3

package/tests/rank_tier_single_source.mjs

@@ -0,0 +1,205 @@
+// tests/rank_tier_single_source.mjs — the rank-tier single-source guard (BV1.R108).
+//
+// The canonical rank → tier map is db-kernel.RANK_TIER, DERIVED from
+// LIVE_RANK_LADDER and exposed on the doorway (api.RANK_TIER). This guard makes
+// the collapse hold three ways:
+//
+//   1. IMPORTABLE code holds the SAME OBJECT, not a copy — modules/lifecycle/db.js
+//      (the claim-floor brain) and the doorway getter are Object.is-identical to
+//      the kernel map.
+//   2. Every DELIBERATELY-LOCAL copy is pinned byte-equivalent. These exist for
+//      documented reasons and may not be force-merged (the D1 decision,
+//      modules/discord/discord-channels.js): dependency-free substrate
+//      (permission-path-check runs in a bare git hook), source-parsed literals
+//      (src/bongos/db.js — gate-review.js + diagram-facts.js regex its text),
+//      standalone CLIs (sequence, box-connect-lib), the require-free dev-box
+//      module template (boxes.js), zero-dep catalog + its text-parsing auditor
+//      (route-rank-check), and the hall browser statics.
+//   3. NO NEW parallel map can land: a repo scan flags any rank→number map or
+//      rank-ladder array literal outside the allowlist below, both directions —
+//      an unlisted literal fails, and a stale allowlist entry fails too.
+//
+// Run:  node tests/rank_tier_single_source.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const kernel = require(path.join(ROOT, 'src', 'bongos', 'db-kernel.js'));
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+const coreDb = require(path.join(ROOT, 'src', 'bongos', 'db.js'));
+const lifecycleDb = require(path.join(ROOT, 'modules', 'lifecycle', 'db.js'));
+const ppc = require(path.join(ROOT, 'src', 'bongos', 'permission-path-check.js'));
+const rrc = require(path.join(ROOT, 'src', 'bongos', 'route-rank-check.js'));
+const sequence = require(path.join(ROOT, 'scripts', 'gds', 'sequence.js'));
+const boxConnect = require(path.join(ROOT, 'scripts', 'gds', 'box-connect-lib.js'));
+const boxes = require(path.join(ROOT, 'modules', 'dev-box', 'boxes.js'));
+const catalog = require(path.join(ROOT, 'modules', 'governance', 'catalog.js'));
+
+const LADDER = kernel.LIVE_RANK_LADDER;
+const TIER = kernel.RANK_TIER;
+const RANK_KEYS = ['xenos', 'thetes', 'metic', 'archon'];
+
+// ===========================================================================
+// 1 — the canonical derivation
+// ===========================================================================
+
+test('RANK_TIER is derived from LIVE_RANK_LADDER (1-based) and frozen', () => {
+  assert.deepEqual(LADDER, RANK_KEYS, 'the live ladder itself changed — update this guard deliberately');
+  assert.ok(Object.isFrozen(TIER));
+  assert.deepEqual(TIER, Object.fromEntries(LADDER.map((r, i) => [r, i + 1])));
+});
+
+test('the doorway and the lifecycle brain hold the SAME object, not copies', () => {
+  assert.ok(Object.is(api.RANK_TIER, TIER), 'api.RANK_TIER must be the kernel map itself');
+  assert.ok(Object.is(api.LIVE_RANK_LADDER, LADDER));
+  assert.ok(Object.is(lifecycleDb.REQUIRES_RANK_TIER, TIER),
+    'modules/lifecycle/db.js must derive from the doorway, never hand-copy');
+});
+
+// ===========================================================================
+// 2 — every deliberately-local copy is pinned
+// ===========================================================================
+
+test('src/bongos/db.js literal (the source-parsed brain) matches the kernel map', () => {
+  assert.deepEqual(coreDb.REQUIRES_RANK_TIER, TIER);
+  // The literal must stay PARSEABLE TEXT — gate-review.js's root-of-trust region
+  // watch and diagram-facts.js both regex it out of the source.
+  const src = fs.readFileSync(path.join(ROOT, 'src', 'bongos', 'db.js'), 'utf8');
+  const m = /REQUIRES_RANK_TIER\s*=\s*\{([^}]*)\}/.exec(src);
+  assert.ok(m, 'db.js must keep an inline REQUIRES_RANK_TIER object literal');
+  assert.deepEqual(parsePairs(m[1]), TIER, 'the db.js literal text drifted from the kernel map');
+});
+
+test('1-based local copies match: permission-path-check, sequence CLI', () => {
+  assert.deepEqual(ppc.RANK_TIER, TIER, 'permission-path-check drifted — the #863 failure class');
+  assert.deepEqual(sequence.RANK_TIER, TIER, 'sequence.js CLI copy drifted');
+});
+
+test('0-based local copies match: box-connect-lib CLI, dev-box boxes.js', () => {
+  for (const [name, map] of [['box-connect-lib', boxConnect.RANK_ORDER], ['boxes', boxes.RANK_ORDER]]) {
+    assert.deepEqual(Object.keys(map).sort(), [...RANK_KEYS].sort(), `${name} keys drifted`);
+    for (const r of RANK_KEYS) {
+      assert.equal(map[r], TIER[r] - 1, `${name}.RANK_ORDER.${r} must be tier-1 (0-based)`);
+    }
+  }
+});
+
+test('ladder mirrors match: governance catalog, route-rank-check', () => {
+  assert.deepEqual([...catalog.RANK_ORDER], [...LADDER]);
+  assert.deepEqual([...rrc.PERMISSION_RANK_ORDER], [...LADDER]);
+});
+
+// Files that cannot require server code (browser statics, dependency-free
+// module CLIs) — their literal must be EXACTLY the canonical form. The loose
+// scanner below flags any rank-ish literal in these files; this exact check is
+// what turns "flagged but allowlisted" into "provably not drifted".
+const EXACT_LADDER_RE = /\[\s*'xenos',\s*'thetes',\s*'metic',\s*'archon'\s*\]/;
+const STATIC_LADDER_FILES = [
+  'modules/discord/discord-channels.js',
+  'modules/memory/search.js',
+  'modules/hall-ui/public/ranks.js',
+  'modules/hall-ui/public/profile.js',
+  'modules/hall-ui/public/watch.js',
+];
+test('static ladder copies carry the exact canonical ladder', () => {
+  for (const rel of STATIC_LADDER_FILES) {
+    const src = fs.readFileSync(path.join(ROOT, rel), 'utf8');
+    assert.ok(EXACT_LADDER_RE.test(src), `${rel}: ladder literal missing or drifted from canonical order`);
+  }
+});
+
+const STATIC_MAP_FILES = ['modules/hall-ui/public/builders.js', 'modules/hall-ui/public/goals-page.js'];
+test('hall static tier maps match the kernel map', () => {
+  for (const rel of STATIC_MAP_FILES) {
+    const src = fs.readFileSync(path.join(ROOT, rel), 'utf8');
+    const maps = extractRankMaps(src);
+    assert.ok(maps.length > 0, `${rel}: expected a rank tier map`);
+    for (const map of maps) assert.deepEqual(map, TIER, `${rel}: tier map drifted`);
+  }
+});
+
+// ===========================================================================
+// 3 — the reintroduction scanner (both directions vs the allowlist)
+// ===========================================================================
+
+// Where a rank→number map literal is allowed to exist (each is pinned above).
+const MAP_ALLOWLIST = new Set([
+  'src/bongos/db.js',
+  'src/bongos/permission-path-check.js',
+  'scripts/gds/sequence.js',
+  'scripts/gds/box-connect-lib.js',
+  'modules/dev-box/boxes.js',
+  'modules/hall-ui/public/builders.js',
+  'modules/hall-ui/public/goals-page.js',
+]);
+// Where a rank-ladder array literal is allowed to exist.
+const LADDER_ALLOWLIST = new Set([
+  'src/bongos/db-kernel.js', // the canonical source itself
+  'modules/governance/catalog.js',
+  'src/bongos/route-rank-check.js',
+  ...STATIC_LADDER_FILES,
+]);
+
+// A rank→digit pair inside an object block. Hex values (RANK_COLORS) never
+// match: \d+ must run straight into , or }.
+const pairRe = (rank) => new RegExp(`(?:^|[{,\\s'"])${rank}['"]?\\s*:\\s*\\d+\\s*[,}]`);
+// ≥3 rank keys with digit values in one object literal = a tier map — including
+// the drifted 3-key shape that caused #863 (a rank silently missing).
+function hasRankMap(src) {
+  for (const m of src.matchAll(/\{[^{}]*\}/g)) {
+    if (RANK_KEYS.filter((r) => pairRe(r).test(m[0])).length >= 3) return true;
+  }
+  return false;
+}
+function parsePairs(inner) {
+  const out = {};
+  for (const m of inner.matchAll(/([a-z]+)['"]?\s*:\s*(\d+)/g)) out[m[1]] = Number(m[2]);
+  return out;
+}
+function extractRankMaps(src) {
+  const out = [];
+  for (const m of src.matchAll(/\{[^{}]*\}/g)) {
+    if (RANK_KEYS.filter((r) => pairRe(r).test(m[0])).length >= 3) {
+      out.push(parsePairs(m[0].slice(1, -1)));
+    }
+  }
+  return out;
+}
+// ≥3 CONSECUTIVE live-rank strings in one array literal = a ladder copy.
+const LOOSE_LADDER_RE = /\[\s*(?:['"](?:xenos|thetes|metic|archon)['"]\s*,?\s*){3,}\]/;
+
+test('no rank map or ladder literal exists outside the allowlist (and none is stale)', () => {
+  const tracked = execFileSync('git', ['-C', ROOT, 'ls-files', 'src', 'modules', 'scripts'], { encoding: 'utf8' })
+    .split('\n').map((l) => l.trim())
+    .filter((f) => f.endsWith('.js') && !f.includes('/tests/') && !f.endsWith('.test.js'));
+  assert.ok(tracked.length > 50, `suspiciously few tracked files (${tracked.length}) — scanner broken?`);
+
+  const mapHits = new Set();
+  const ladderHits = new Set();
+  for (const rel of tracked) {
+    const src = fs.readFileSync(path.join(ROOT, rel), 'utf8');
+    if (hasRankMap(src)) mapHits.add(rel);
+    if (LOOSE_LADDER_RE.test(src)) ladderHits.add(rel);
+  }
+  for (const f of mapHits) {
+    assert.ok(MAP_ALLOWLIST.has(f),
+      `${f} declares a rank→tier map literal. Derive it from api.RANK_TIER / db-kernel.RANK_TIER instead — or, if it genuinely cannot require server code, add it here WITH a pinning assertion above.`);
+  }
+  for (const f of ladderHits) {
+    assert.ok(LADDER_ALLOWLIST.has(f),
+      `${f} declares a rank-ladder array literal. Derive it from api.LIVE_RANK_LADDER instead — or, if it genuinely cannot require server code, add it here WITH a pinning assertion above.`);
+  }
+  for (const f of MAP_ALLOWLIST) {
+    assert.ok(mapHits.has(f), `allowlist entry ${f} no longer contains a rank map — prune it`);
+  }
+  for (const f of LADDER_ALLOWLIST) {
+    assert.ok(ladderHits.has(f), `allowlist entry ${f} no longer contains a ladder literal — prune it`);
+  }
+});

package/tests/recall_hints.mjs

@@ -10,10 +10,11 @@
 
 import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
+import { requireHostModule } from './helpers.mjs';
 
 const require = createRequire(import.meta.url);
 const { taskQuery, pickActiveClaim, formatHints, DEADLINE_MS } =
-  require('../.claude/hooks/recall-hints.js');
+  requireHostModule(require, '../.claude/hooks/recall-hints.js');
 
 let passed = 0;
 let failed = 0;

package/tests/repo_map.mjs

@@ -71,6 +71,10 @@ test('each nested CLAUDE.md carries a delimited generated block with signatures'
     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`);
+    // In a PUBLISHED core the nested agent notes are replaced by package-core.js's
+    // CORE_AGENT_DOC_STUB, so there is no hand-written prose to preserve (task 1002470).
+    // Where the real doc is present the prose must survive the generated-block injection.
+    if (doc.includes('@bongos/core — installed platform dependency')) continue;
     // the hand-written prose is preserved alongside the generated block
     assert.match(doc, /Nested CLAUDE\.md — loads on demand/);
   }

package/tests/route_permission_check.mjs

@@ -41,12 +41,16 @@ const rowOf = (src) => rrc.classifyText(src)[0];
 // here ONCE by hand. This is the independent side of every classification assertion
 // below — if someone lowers `backup.manage` to 'xenos', the classifier follows the
 // catalog and this file goes red, which is the whole point.
+// ADR 0157 moved 20 atoms archon→metic. `audit_log.read` and `builder.roster.read` are
+// transcribed at their new floor below; the archon entries that remain are the
+// rank/identity core, which is the point of that ADR.
 const HAND_WRITTEN_FLOORS = {
   'builder.rank.set': 'archon',
-  'audit_log.read': 'archon',
   'auth.session.revoke': 'archon',
-  'builder.roster.read': 'archon',
   'builder.status.set': 'archon',
+  'access_request.review': 'archon',
+  'audit_log.read': 'metic',
+  'builder.roster.read': 'metic',
   'backup.manage': 'metic',
   'idea.triage': 'metic',
   'security.report.file': 'metic',
@@ -132,13 +136,17 @@ test('P1: the label agrees with the REAL threshold function over the whole rank
 });
 
 test('P1: AND semantics — a multi-atom gate takes the STRICTEST floor', () => {
-  const src = "router.post('/x', auth.requireBuilder, auth.requirePermission('idea.file', 'audit_log.read'), h);";
+  // Uses `builder.rank.set` as the archon end of the pair: ADR 0157 lowered
+  // `audit_log.read` (the previous example) to metic, which would no longer exercise the
+  // metic-vs-archon spread this test exists to prove. Rank-setting is the one power that
+  // ADR 0157 guarantees stays archon, so it is the stable choice here.
+  const src = "router.post('/x', auth.requireBuilder, auth.requirePermission('idea.file', 'builder.rank.set'), h);";
   assert.equal(rankOf(src), 'archon',
     'requirePermission ANDs, so the gate is as strict as its strictest atom (archon), not its loosest');
   const src2 = "router.post('/x', auth.requireBuilder, auth.requirePermission('cost.log', 'backup.manage'), h);";
   assert.equal(rankOf(src2), 'metic+archon');
   // order must not matter
-  const src3 = "router.post('/x', auth.requireBuilder, auth.requirePermission('audit_log.read', 'idea.file'), h);";
+  const src3 = "router.post('/x', auth.requireBuilder, auth.requirePermission('builder.rank.set', 'idea.file'), h);";
   assert.equal(rankOf(src3), 'archon');
 });
 
@@ -274,7 +282,8 @@ test('P4: gen-api-docs labels a permission-gated route by its floor, not any-bui
   const trigger = model.find((r) => r.route === '/backup/trigger');
   const audit = model.find((r) => r.route === '/audit-log');
   assert.equal(trigger.rank, 'metic+archon', 'the published rank must be the real floor');
-  assert.equal(audit.rank, 'archon');
+  // ADR 0157: `audit_log.read` floor archon→metic, so the published rank follows.
+  assert.equal(audit.rank, 'metic+archon');
   assert.deepEqual(trigger.perms, ['backup.manage'], 'the docs also name the authority atom');
 
   const spec = genApiDocs.buildOpenapi(model);

package/tests/rubric_fixtures.mjs

@@ -23,6 +23,7 @@
 import { strict as assert } from 'node:assert';
 import { readFileSync, existsSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import { skipUnlessPresent } from './helpers.mjs';
 import { dirname, resolve } from 'node:path';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
@@ -30,6 +31,8 @@ const ROOT = resolve(HERE, '..');
 const FIXTURES_DIR = resolve(ROOT, 'modules', 'art-pipeline', 'template', 'rubric_fixtures');
 const MANIFEST = resolve(FIXTURES_DIR, 'fixtures.json');
 const RUBRIC = resolve(ROOT, 'modules', 'art-pipeline', 'template', 'rubric.json');
+skipUnlessPresent('modules/art-pipeline/template/rubric_fixtures',
+  'The art-pipeline module is not installed in this instance.');
 
 let passed = 0;
 function test(name, fn) {

package/tests/run_routine_two_root.mjs

@@ -19,11 +19,13 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { skipUnlessPresent } from './helpers.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const REPO = path.resolve(__dirname, '..'); // the core root (this repo), fixed by resolveCoreRoot()
 const RUN_ROUTINE = path.join(REPO, 'scripts', 'gds', 'run-routine.js');
 const CORE_RESOLVE = path.join(REPO, '.claude', 'hooks', '_core-resolve.js');
+skipUnlessPresent('.claude/hooks/_core-resolve.js');
 
 let passed = 0, failed = 0;
 function test(name, fn) {

package/tests/sandbox_stage.mjs

@@ -240,7 +240,10 @@ function boxDeps(markerFile, overrides = {}) {
       if (cmd === 'git') return execFileSync(cmd, args, opts);
       return '';
     },
-    fetchImpl: async () => ({ status: 200 }),
+    // task 1002607: emulate a real PREVIEW — 200 on the health URL, 404 on the
+    // /api/gds/healthz discriminator (the game-only entry mounts no /api/gds).
+    // A flat always-200 mock would now read as "the MAIN server answered".
+    fetchImpl: async (url) => ({ status: String(url).includes('/api/gds/healthz') ? 404 : 200 }),
     markerPath: markerFile,
     cwd: tmp,
     pollMs: 1,
@@ -346,11 +349,19 @@ await ta('runShipGate: --skip-stage → ok, untouched', async () => {
   assert.equal(fs.existsSync(mp), false);
 });
 
-await ta('runShipGate: staging failure (health never green) warns but does not block', async () => {
+// task 1002607 (§4.4 station 9): a staging failure used to WARN one stderr line
+// and return ok — the review gate silently turned itself off. It now fails
+// CLOSED (like the smoke gate, task 1002605): abort, claim intact, --skip-stage
+// as the explicit bypass, and the reason says plainly the review DID NOT run.
+await ta('1002607 runShipGate: staging failure (health never green) ABORTS — review gate cannot silently turn itself off', async () => {
   const mp = path.join(markerDir, 'm8.json');
   const deps = boxDeps(mp, { fetchImpl: async () => ({ status: 502 }), timeoutMs: 10 });
   const r = await sbx.runShipGate({ taskId: 927, files: ['public/game/a.js'], skipStage: false, tty: true }, deps);
-  assert.equal(r.ok, true, 'a broken preview must not brick shipping');
+  assert.equal(r.ok, false, 'a failed stage must not ship as if the review happened');
+  assert.equal(r.review, undefined, 'a failure to present is NOT a calm review pause');
+  assert.match(r.reason, /DID NOT run/, 'says plainly the review step did not run');
+  assert.match(r.reason, /--skip-stage/, 'names the explicit bypass');
+  assert.match(r.reason, /claim is still active/i, 'claim-preserving');
 });
 
 // ---------- recorded self-approval (#1048), box ----------
@@ -502,12 +513,62 @@ await ta('stage(box): a HARD verify failure → {ok:false,hard:true}, no marker'
   assert.equal(fs.existsSync(mp), false, 'no marker on a hard verify failure');
 });
 
-await ta('runShipGate(box): a SOFT failure (preview never healthy) still warns + continues', async () => {
+await ta('1002607 runShipGate(box): a SOFT failure (preview never healthy) now fails closed — abort, claim intact', async () => {
   const mp = path.join(markerDir, 'soft1.json');
-  // sync ok (injected), but health never green → soft failure → ship continues
+  // sync ok (injected), but health never green → the ship must NOT continue
+  // as if the review ran (that was the silent-disable defect).
   const deps = boxDeps(mp, { fetchImpl: async () => ({ status: 502 }), timeoutMs: 10 });
   const r = await sbx.runShipGate({ taskId: 1068, files: ['public/game/a.js'], skipStage: false, tty: true }, deps);
-  assert.equal(r.ok, true, 'a broken preview must not brick shipping (soft failure)');
+  assert.equal(r.ok, false, 'the soft failure aborts instead of silently skipping the review');
+  assert.match(r.reason, /sandbox staging failed/);
+});
+
+// ---------- task 1002607: waitHealthy truth table ----------
+
+await ta('1002607 waitHealthy: 404 at the health URL is NOT healthy (was: anything < 500 passed)', async () => {
+  const r = await sbx.waitHealthy({ fetchImpl: async () => ({ status: 404 }), timeoutMs: 10, pollMs: 1 });
+  assert.equal(r.ok, false);
+  assert.match(r.reason, /HTTP 404/);
+});
+
+await ta('1002607 waitHealthy: a 200 answered by the MAIN server (api healthz 200) is an impostor, not a healthy preview', async () => {
+  // The full server binds the same 127.0.0.1:3000 — root answers 200, and so does
+  // /api/gds/healthz. The game-only preview (ADR 0052) would 404 the latter.
+  const r = await sbx.waitHealthy({ fetchImpl: async () => ({ status: 200 }), timeoutMs: 1000, pollMs: 1 });
+  assert.equal(r.ok, false, 'a dead preview must not report healthy off the main server');
+  assert.match(r.reason, /MAIN server/);
+  assert.match(r.reason, /preview did not start/);
+});
+
+await ta('1002607 waitHealthy: a real preview (root 200, api healthz 404) is healthy', async () => {
+  const r = await sbx.waitHealthy({
+    fetchImpl: async (url) => ({ status: String(url).includes('/api/gds/healthz') ? 404 : 200 }),
+    timeoutMs: 1000, pollMs: 1,
+  });
+  assert.equal(r.ok, true);
+});
+
+await ta('1002607 waitHealthy: a discriminator probe that ERRORS counts as "not the main server" (preview healthy)', async () => {
+  const r = await sbx.waitHealthy({
+    fetchImpl: async (url) => {
+      if (String(url).includes('/api/gds/healthz')) throw new Error('ECONNREFUSED on a path the preview never mounts');
+      return { status: 200 };
+    },
+    timeoutMs: 1000, pollMs: 1,
+  });
+  assert.equal(r.ok, true, 'only a definite 200 on api healthz marks the impostor');
+});
+
+t('1002607 apiHealthzProbeUrl: same origin as the health URL, api path; null on garbage', () => {
+  assert.equal(sbx.apiHealthzProbeUrl('http://127.0.0.1:3000/'), 'http://127.0.0.1:3000/api/gds/healthz');
+  assert.equal(sbx.apiHealthzProbeUrl('http://127.0.0.1:3100/healthz'), 'http://127.0.0.1:3100/api/gds/healthz');
+  assert.equal(sbx.apiHealthzProbeUrl('not a url'), null);
+});
+
+t('1002607 NO_SANDBOX_MSG: names what is actually missing, not the builder\'s clone', () => {
+  assert.match(sbx.NO_SANDBOX_MSG, /src\/preview-server\.js/, 'names the missing entry file');
+  assert.match(sbx.NO_SANDBOX_MSG, /ADR 0052/, 'points at the contract that defines it');
+  assert.doesNotMatch(sbx.NO_SANDBOX_MSG, /this clone has no game preview entry/, 'the old your-clone-is-at-fault phrasing is gone');
 });
 
 // ---------- runShipGate: LOCAL preview context + recorded approval (task 1056) ----------
@@ -529,7 +590,8 @@ function localDeps(markerFile, overrides = {}) {
       writeFileSync: (p, d) => fs.writeFileSync(p, d),
     },
     execFileSync: (cmd, args, opts) => (cmd === 'git' ? execFileSync(cmd, args, opts) : ''),
-    fetchImpl: async () => ({ status: 200 }),
+    // task 1002607: preview-shaped mock — health 200, API-healthz discriminator 404.
+    fetchImpl: async (url) => ({ status: String(url).includes('/api/gds/healthz') ? 404 : 200 }),
     markerPath: markerFile,
     cwd: tmp,
     pollMs: 1,

package/tests/search_ingest.mjs

@@ -30,6 +30,13 @@ test('metic-tagging: read-sensitive doc surfaces → metic', () => {
   assert.equal(minRankForDoc('docs/audits/2026-06-08-server-security-audit.md'), 'metic');
   assert.equal(minRankForDoc('docs/adr/0016-trust-boundary-server-enforced-permissions.md'), 'metic');
   assert.equal(minRankForDoc('docs/adr/0043-git-ssh-trust-boundary-and-rank-floor-on-permission-paths.md'), 'metic');
+  // task 1002598: docs/governance/ holds the complete gate enumeration (the authority
+  // sweep) and the choke-point map, which catalogue live fail-open paths by file:line.
+  // Served at xenos they were a searchable exploitation index for the population they
+  // describe; the read floor matches security.report.adjudicate, where ADR 0158 §6
+  // sends the same class of detail.
+  assert.equal(minRankForDoc('docs/governance/rank-choke-point-map-2026-08-06.md'), 'metic');
+  assert.equal(minRankForDoc('docs/governance/authority-sweep-2026-07-24.md'), 'metic');
 });
 
 test('metic-tagging: ordinary docs → xenos (read-public)', () => {

package/tests/security_docs.mjs

@@ -18,8 +18,11 @@
 //     - the slug character-class regex rejects non-kebab slugs
 //
 //   Rank wiring (source assertion — mirrors tests/cli_token_reissue.mjs):
-//     - all three /security/docs* routes are auth.requireRank('archon')
-//     - route-rank-check pins them to 'archon' in EXPECTED_RANKS
+//     - all three /security/docs* routes gate on the atom
+//       auth.requirePermission('security.report.adjudicate') (BV1.R104; was
+//       requireRank('archon') and admitted exactly the same builders, ADR 0151)
+//     - that atom's floor moved archon→metic in ADR 0157, so the routes now classify
+//       'metic+archon' and are pinned BY ATOM (`perm:…`) rather than by rank
 //
 // We stub the pool by pre-seeding the require cache for src/db.js so the db
 // module under test never opens a socket — the same monkeypatch seam the repo
@@ -167,18 +170,37 @@ await test('slug character-class regex rejects non-kebab slugs', () => {
 
 console.log('\nsecurity_docs — rank wiring (source + pin):');
 
-await test('all three /security/docs* routes are requireRank(archon)', () => {
+await test('all three /security/docs* routes gate on security.report.adjudicate (metic floor)', () => {
   const src = fs.readFileSync(path.join(ROOT, 'src', 'bongos', 'routes', 'security.js'), 'utf8');
   const routes = rrc.classifyText(src).filter((r) => r.route.startsWith('/security/docs'));
   assert.equal(routes.length, 3, 'expected GET list, GET :slug, POST');
   for (const r of routes) {
-    assert.equal(r.rank, 'archon', `${r.key} must classify as archon (serves exploit detail)`);
+    // The ATOM is the authority once governance grows custom roles; the rank is what
+    // that atom's catalog floor resolves to today. Assert both, so neither a swapped
+    // atom nor an UNINTENDED floor edit can quietly widen who reads the exploit cookbook.
+    //
+    // ADR 0157 made that widening INTENTIONALLY: `security.report.adjudicate` moved
+    // archon→metic with the rest of the operational block, so the engagement-report
+    // store is now readable by the working rank. That is the one place in the ADR where
+    // delegation carries a genuine CONFIDENTIALITY cost rather than just an
+    // administrative one — every other delegated atom widens who may *act*, this one
+    // widens who may *read attacker-usable detail*. If that trade is unwanted, the fix
+    // is to split the atom the way ADR 0157 §4 split `gate_approval.read` off
+    // `gate_approval.decide`: keep a `security.docs.read` at archon for the cookbook and
+    // let report adjudication delegate. Recorded here so the next reader sees the choice
+    // rather than inferring it from a floor value.
+    assert.deepEqual(r.perms, ['security.report.adjudicate'],
+      `${r.key} must gate on the adjudicate atom (serves exploit detail)`);
+    assert.equal(r.rank, 'metic+archon', `${r.key} must classify as metic+archon (ADR 0157)`);
   }
 });
 
-await test('route-rank-check pins all three /security/docs* routes to archon', () => {
+await test('route-rank-check pins all three /security/docs* routes by atom', () => {
+  // Re-pinned from the rank 'archon' to the ATOM in ADR 0157: the invariant worth
+  // guarding is "these gate on the adjudicate permission", which survives a floor move.
   for (const key of ['GET /security/docs', 'GET /security/docs/:slug', 'POST /security/docs']) {
-    assert.equal(rrc.EXPECTED_RANKS[key], 'archon', `${key} must be pinned archon in EXPECTED_RANKS`);
+    assert.equal(rrc.EXPECTED_RANKS[key], 'perm:security.report.adjudicate',
+      `${key} must be pinned to the adjudicate atom in EXPECTED_RANKS`);
   }
 });
 

package/tests/sequence.mjs

@@ -13,6 +13,7 @@ const {
   topoOrder,
   chainFrom,
   haltReasons,
+  pickNext,
   summarize,
   MIN_SPEC_CHARS,
 } = require('../scripts/gds/sequence.js');
@@ -263,5 +264,68 @@ t('summarize tolerates missing numbers', () => {
     { count: 1, credits: 0, minutes: 0 });
 });
 
+// ------------------------------------------------------- pickNext (--next)
+
+// The live regression this closes (goal 1000030, 2026-08-05): a backlog task
+// sorted to position 0 and --next reported "nothing runnable" while two ready
+// tasks sat behind it.
+const GOAL_1000030 = () => [
+  task({ id: 1002556, status: 'backlog', title: 'perf: fold the resolve' }),
+  task({ id: 1001850, status: 'ready', title: 'R108 — collapse rank-tier maps' }),
+  task({ id: 1001858, status: 'ready', title: 'R110 — governance API routes' }),
+];
+const claimable = (...ids) => ({ rank: 'archon', claimableIds: new Set(ids) });
+
+t('pickNext offers the head when the head is clear', () => {
+  const plan = GOAL_1000030().slice(1);
+  const r = pickNext(plan, claimable(1001850, 1001858));
+  assert.equal(r.next.id, 1001850);
+  assert.deepEqual(r.skipped, []);
+});
+
+t('pickNext skips a blocked head and offers the first runnable task', () => {
+  const r = pickNext(GOAL_1000030(), claimable(1001850, 1001858));
+  assert.equal(r.next.id, 1001850, 'must not dead-end on the backlog task at position 0');
+  assert.equal(r.skipped.length, 1);
+  assert.equal(r.skipped[0].id, 1002556);
+});
+
+t('pickNext reports WHY each skipped task was passed over', () => {
+  const r = pickNext(GOAL_1000030(), claimable(1001850, 1001858));
+  assert.ok(r.skipped[0].reasons.some((x) => x.code === 'deps_unmet'));
+  assert.ok(r.skipped[0].title, 'skipped entries carry a title for the printout');
+});
+
+t('pickNext keeps topological order among the runnable — first clear wins', () => {
+  const r = pickNext(GOAL_1000030(), claimable(1001850, 1001858));
+  assert.equal(r.next.id, 1001850, 'not 1001858, which sorts later');
+});
+
+t('pickNext still halts when NOTHING in the plan clears', () => {
+  const plan = [
+    task({ id: 1, status: 'backlog' }),
+    task({ id: 2, status: 'shipped' }),
+    task({ id: 3, status: 'ready', requires_rank: 'archon' }),
+  ];
+  const r = pickNext(plan, { rank: 'xenos', claimableIds: new Set([3]) });
+  assert.equal(r.next, null);
+  assert.equal(r.skipped.length, 3, 'every task was tried');
+  assert.equal(r.head.id, 1, 'the head is preserved so the halt prints its reasons');
+});
+
+t('pickNext does not weaken a gate — a ready-but-unclaimable task is skipped, not offered', () => {
+  const plan = [task({ id: 9, status: 'ready' })];
+  const r = pickNext(plan, claimable(/* 9 absent from the claimable feed */));
+  assert.equal(r.next, null);
+  assert.ok(r.skipped[0].reasons.some((x) => x.code === 'not_claimable'));
+});
+
+t('pickNext on an empty plan returns no pick and nothing skipped', () => {
+  const r = pickNext([], claimable());
+  assert.equal(r.next, null);
+  assert.deepEqual(r.skipped, []);
+  assert.equal(r.head, null);
+});
+
 console.log(`\nsequence: ${passed} passed, ${failed} failed`);
 process.exit(failed ? 1 : 0);

package/tests/session-cards.mjs

@@ -12,9 +12,10 @@
 
 import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
+import { requireHostModule } from './helpers.mjs';
 
 const require = createRequire(import.meta.url);
-const hook = require('../.claude/hooks/session-cards.js');
+const hook = requireHostModule(require, '../.claude/hooks/session-cards.js');
 
 let passed = 0;
 let failed = 0;

package/tests/session_start_freshness.mjs

@@ -16,9 +16,10 @@
 
 import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
+import { requireHostModule } from './helpers.mjs';
 
 const require = createRequire(import.meta.url);
-const { decideFreshness } = require('../.claude/hooks/session-start.js');
+const { decideFreshness } = requireHostModule(require, '../.claude/hooks/session-start.js');
 
 let passed = 0;
 let failed = 0;