@bongos/core 1.21.3 → 1.21.5

package/tests/governor_docket.mjs

@@ -0,0 +1,552 @@
+// tests/governor_docket.mjs — the governor's docket (task 1004523, goal 1000125):
+// ONE read of every matter awaiting a governor, which the Governor City screens
+// (tasks 1004524-1004528) all draw from. modules/government/docket.js collects
+// sources contributed to the `governor.docket` point by their owning modules.
+//
+// What this pins:
+//   1. THE MAPPER — normalizeMatter's one shape, and its fail-safe defaults (an
+//      unknown state is never a false "needs you"; an unknown rule is null).
+//   2. THE BOARD'S PER-VIEWER STATE mirrors the /me summons (pendingVotesFor):
+//      needs = member, not cast, not the author, not expired; else moving/settled.
+//   3. RANK SCOPING — a source the viewer may not see returns NO rows and reports
+//      `not_yours`; a contribution with no recognisable gate is never run; a
+//      gate-less or malformed one cannot widen anything (fail-closed).
+//   4. NOTHING INVENTED — a design-named source with nothing recorded is `coming`,
+//      a module that is off is `off`, a read that throws or hangs is `unavailable`.
+//   5. EVERY CONTRIBUTED SOURCE DECLARES ITS OWN LIST ROUTE'S ATOM — read off the
+//      route source by the route-rank auditor, so the city can never show a viewer
+//      a matter the owning route would refuse them.
+//   6. THE ROUTE — GET /government/docket gates on board.vote.cast and answers the
+//      documented shape through the real router.
+//
+// DB-free: db reads are monkeypatched by property; the real seam carries the
+// contributions.
+//
+// Run:  node tests/governor_docket.mjs
+
+import { strict as assert } from 'node:assert';
+import { test, after } from 'node:test';
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+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 api = require(path.join(ROOT, 'src', 'module-api.js'));
+const seams = require(path.join(ROOT, 'src', 'module-seams.js'));
+const docket = require(path.join(ROOT, 'modules', 'government', 'docket.js'));
+const vocab = require(path.join(ROOT, 'modules', 'government', 'docket-vocab.js'));
+const board = require(path.join(ROOT, 'modules', 'government', 'board.js'));
+const govDb = require(path.join(ROOT, 'modules', 'government', 'db.js'));
+const resolver = require(path.join(ROOT, 'modules', 'government', 'resolver.js'));
+const lifecycleDocket = require(path.join(ROOT, 'modules', 'lifecycle', 'governor-docket.js'));
+const coreUpdateRoute = require(path.join(ROOT, 'src', 'bongos', 'routes', 'core-update.js'));
+const ideasDocket = require(path.join(ROOT, 'modules', 'ideas', 'governor-docket.js'));
+const autonomyDocket = require(path.join(ROOT, 'modules', 'autonomy', 'governor-docket.js'));
+const accessRequestsRoute = require(path.join(ROOT, 'modules', 'onboarding', 'routes', 'access-requests.js'));
+const reportsRoute = require(path.join(ROOT, 'modules', 'security', 'routes', 'reports.js'));
+const moduleRechecks = require(path.join(ROOT, 'src', 'bongos', 'module-rechecks.js'));
+const rrc = require(path.join(ROOT, 'src', 'bongos', 'route-rank-check.js'));
+const { attachFail } = require(path.join(ROOT, 'src', 'bongos', 'middleware', 'error-envelope.js'));
+const express = require('express');
+
+// ── stubs: the board and headcount reads (no DB) ─────────────────────────────
+
+const REAL = {
+  boardRoomView: board.boardRoomView,
+  getActiveBuildersWithRank: govDb.getActiveBuildersWithRank,
+  countActiveBuilders: govDb.countActiveBuilders,
+  resolveBuilderPermissions: resolver.resolveBuilderPermissions,
+};
+let boardView = { open: [], closed: [] };
+let members = [{ builder_id: 7, github_login: 'ana', display_name: 'Ana' }, { builder_id: 9, github_login: 'theo', display_name: 'Theo' }];
+board.boardRoomView = async () => boardView;
+govDb.getActiveBuildersWithRank = async () => members;
+govDb.countActiveBuilders = async () => 12;
+after(() => {
+  board.boardRoomView = REAL.boardRoomView;
+  govDb.getActiveBuildersWithRank = REAL.getActiveBuildersWithRank;
+  govDb.countActiveBuilders = REAL.countActiveBuilders;
+  resolver.resolveBuilderPermissions = REAL.resolveBuilderPermissions;
+  seams._reset();
+});
+
+const NOW = Date.parse('2026-10-01T12:00:00Z');
+const CONSENT = { membership: 'rank:archon', pass_rule: 'consent' };
+const item = (over = {}) => ({
+  id: '11', subject_type: 'constitutional_amendment', subject_id: '3',
+  subject: { rationale_md: '# Give Review a seat\nmore', author_id: '9' },
+  opened_at: '2026-09-29T00:00:00Z', closes_at: '2026-10-03T00:00:00Z',
+  expired: false, closed_at: null, outcome: null, constitution: CONSENT, votes: [],
+  ...over,
+});
+const none = () => ({ sources: new Map(), readings: new Map() });
+
+// ── 1. the mapper ────────────────────────────────────────────────────────────
+
+test('normalizeMatter: the one shape, prefixed id, ISO dates', () => {
+  const m = docket.normalizeMatter({
+    id: 5, title: 'Admit Kai', rule: 'consent', state: 'needs', opened_at: '2026-09-30T10:00:00Z',
+    proposer: { id: 3, login: 'theo' }, tally: { for: 2, against: '1', open: 2, needs: 'x' }, ref: { type: 'a', id: 5 },
+  }, { source: 'access_requests', building: 'people' });
+  assert.equal(m.id, 'access_requests:5');
+  assert.equal(m.building, 'people');
+  assert.equal(m.opened_at, '2026-09-30T10:00:00.000Z');
+  assert.equal(m.deadline, null);
+  assert.deepEqual(m.proposer, { id: '3', login: 'theo', name: null });
+  assert.deepEqual(m.tally, { for: 2, against: 1, open: 2, needs: 'x' });
+  assert.deepEqual(m.ref, { type: 'a', id: '5' });
+  assert.deepEqual(Object.keys(m).sort(), ['building', 'deadline', 'href', 'id', 'opened_at', 'proposer', 'ref', 'rule', 'short', 'source', 'state', 'tally', 'title', 'where'].sort());
+});
+
+test('normalizeMatter fails SAFE: unknown state → moving (never a false "needs you"), unknown rule → null', () => {
+  const m = docket.normalizeMatter({ id: 1, title: 't', state: 'urgent!!', rule: 'vibes', building: 'castle' }, { source: 's', building: 'review' });
+  assert.equal(m.state, 'moving');
+  assert.equal(m.rule, null);
+  assert.equal(m.building, 'review', 'an unknown building falls back to the source\'s own');
+  assert.equal(docket.normalizeMatter({ title: 'no id' }, { source: 's', building: 'review' }), null);
+  assert.equal(docket.normalizeMatter({ id: 1 }, { source: 's', building: 'review' }), null);
+});
+
+test('gateAllows is fail-closed on anything it does not recognise', () => {
+  const ctx = { has: (p) => p === 'x' };
+  assert.equal(docket.gateAllows({ permission: 'x' }, ctx), true);
+  assert.equal(docket.gateAllows({ permission: 'y' }, ctx), false);
+  assert.equal(docket.gateAllows({ anyBuilder: true }, ctx), true);
+  for (const g of [null, undefined, {}, { anyBuilder: 'yes' }, { permission: '' }, 'x', { rank: 'archon' }]) {
+    assert.equal(docket.gateAllows(g, ctx), false, JSON.stringify(g));
+  }
+});
+
+test('homeLine speaks the design\'s words', () => {
+  assert.equal(docket.homeLine({ needs: 0, moving: 0, settled: 4 }), 'nothing waits on you.');
+  assert.equal(docket.homeLine({ needs: 3, moving: 2, settled: 0 }), '3 matters wait on you · 2 moving');
+  assert.equal(docket.homeLine({ needs: 1, moving: 0, settled: 0 }), '1 matter waits on you');
+});
+
+// ── 2. the board, per viewer ─────────────────────────────────────────────────
+
+test('board: a member who has not voted NEEDS to; the same item after their vote is MOVING', () => {
+  const viewer = { viewerId: '7', members };
+  assert.equal(docket.boardMatter(item(), viewer).state, 'needs');
+  const voted = item({ votes: [{ voter_id: '7', direction: 'yes', github_login: 'ana' }] });
+  const m = docket.boardMatter(voted, viewer);
+  assert.equal(m.state, 'moving');
+  assert.deepEqual(m.tally, { for: 1, against: 0, open: 1, needs: 'passes unless someone objects' });
+  assert.equal(m.rule, 'consent');
+  assert.equal(m.building, 'charter');
+  assert.equal(m.title, 'Give Review a seat');
+  assert.deepEqual(m.proposer, { id: '9', login: 'theo', name: 'Theo' });
+  assert.equal(m.deadline, '2026-10-03T00:00:00Z');
+});
+
+test('board: the author is not summoned (the /me summons rule), a non-member sees it settled, an expired one never needs you', () => {
+  assert.equal(docket.boardMatter(item(), { viewerId: '9', members }).state, 'moving', 'author');
+  assert.equal(docket.boardMatter(item(), { viewerId: '55', members }).state, 'settled', 'not a member');
+  assert.equal(docket.boardMatter(item({ expired: true }), { viewerId: '7', members }).state, 'moving', 'expired');
+  assert.equal(docket.boardMatter(item({ closed_at: '2026-09-30T00:00:00Z', outcome: 'passed' }), { viewerId: '7', members }).state, 'settled');
+});
+
+test('board: a genesis stage has no author to hold back, and a full idea stands at Planning', () => {
+  const stage = item({ subject_type: 'genesis_stage', subject_id: '3', subject: { label: 'Charter', author_id: '7' }, opened_by: '7' });
+  assert.equal(docket.boardMatter(stage, { viewerId: '7', members }).state, 'needs');
+  const idea = item({ subject_type: 'full_idea', subject: { title: 'A template marketplace', author_id: '9' }, constitution: { membership: 'rank:archon', pass_rule: 'unanimous' } });
+  const m = docket.boardMatter(idea, { viewerId: '7', members });
+  assert.equal(m.building, 'planning');
+  assert.equal(m.rule, 'unanimous');
+  assert.equal(m.title, 'A template marketplace');
+  assert.equal(docket.boardMatter(item({ constitution: { pass_rule: 'nonsense' } }), { viewerId: '7', members }).rule, null);
+});
+
+test('the city and the /me summons agree on "needs you": boardMatter and pendingVotesFor over one matrix', async () => {
+  // Every combination the rule turns on: membership, cast or not, author or not,
+  // and the subject type (a genesis stage has no author to hold back). Each case
+  // is one open, unexpired item seen by viewer 7; the two readers must agree.
+  const realAwaiting = govDb.openBoardItemsAwaitingVoter;
+  const realHolds = govDb.builderHoldsRankActive;
+  try {
+    for (const member of [true, false]) {
+      for (const voted of [true, false]) {
+        for (const author of ['7', '9', null]) {
+          for (const subjectType of ['constitutional_amendment', 'full_idea', 'genesis_stage']) {
+            const label = JSON.stringify({ member, voted, author, subjectType });
+            // pendingVotesFor reads the SQL row shape (the genesis author is nulled in SQL).
+            govDb.openBoardItemsAwaitingVoter = async () => [{
+              id: '11', subject_type: subjectType, subject_id: '3', constitution: CONSENT,
+              opened_at: 't', closes_at: null,
+              author_id: subjectType === 'genesis_stage' ? null : author,
+              already_voted: voted,
+            }];
+            govDb.builderHoldsRankActive = async () => member;
+            const summons = await board.pendingVotesFor('7');
+            // boardMatter reads the room's shape.
+            const m = docket.boardMatter(item({
+              subject_type: subjectType,
+              subject: { author_id: author, title: 't', label: 'Charter', rationale_md: 'r' },
+              votes: voted ? [{ voter_id: '7', direction: 'yes' }] : [],
+            }), { viewerId: '7', members: member ? [{ builder_id: '7' }] : [] });
+            assert.equal(m.state === 'needs', summons.count === 1, label);
+          }
+        }
+      }
+    }
+  } finally {
+    govDb.openBoardItemsAwaitingVoter = realAwaiting;
+    govDb.builderHoldsRankActive = realHolds;
+  }
+});
+
+test('awaitsVoter: the one definition, fail-closed', () => {
+  const yes = { builderId: '7', authorId: '9', alreadyVoted: false, isMember: true };
+  assert.equal(board.awaitsVoter(yes), true);
+  assert.equal(board.awaitsVoter({ ...yes, authorId: 7 }), false, 'number and string ids compare equal');
+  assert.equal(board.awaitsVoter({ ...yes, authorId: null }), true, 'no author, nobody held back');
+  assert.equal(board.awaitsVoter({ ...yes, alreadyVoted: true }), false);
+  assert.equal(board.awaitsVoter({ ...yes, isMember: false }), false);
+  assert.equal(board.awaitsVoter({ ...yes, expired: true }), false);
+  assert.equal(board.awaitsVoter({ ...yes, closed: true }), false);
+  assert.equal(board.awaitsVoter({ ...yes, builderId: '' }), false);
+  assert.equal(board.awaitsVoter(), false);
+});
+
+// ── 3 + 4. scoping, statuses, the collector ──────────────────────────────────
+
+const VIEWER = { id: 7, rank: 'metic' };
+const contrib = (over) => ({ building: 'release', gate: { anyBuilder: true }, read: async () => [], ...over });
+
+test('a source the viewer may not see returns NO rows and reports not_yours — and its read never runs', async () => {
+  boardView = { open: [], closed: [] };
+  let ran = false;
+  const c = none();
+  c.sources.set('override_requests', contrib({ gate: { permission: 'override_request.decide' }, read: async () => { ran = true; return [{ id: 1, title: 'secret', state: 'needs' }]; } }));
+  const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: c, now: NOW });
+  assert.equal(ran, false);
+  assert.equal(d.matters.length, 0);
+  assert.equal(d.sources.find((s) => s.source === 'override_requests').status, 'not_yours');
+  // The same viewer holding the atom sees it.
+  const d2 = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast', 'override_request.decide'], contributions: c, now: NOW });
+  assert.equal(d2.matters.length, 1);
+  assert.equal(d2.matters[0].id, 'override_requests:1');
+  assert.equal(d2.sources.find((s) => s.source === 'override_requests').status, 'live');
+});
+
+test('the board itself is scoped too: without board.vote.cast it is not_yours', async () => {
+  boardView = { open: [item()], closed: [] };
+  const d = await docket.buildDocket({ viewer: VIEWER, permissions: [], contributions: none(), now: NOW });
+  assert.equal(d.sources.find((s) => s.source === 'board').status, 'not_yours');
+  assert.equal(d.matters.length, 0);
+  const d2 = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: none(), now: NOW });
+  assert.equal(d2.matters.length, 1);
+  assert.equal(d2.matters[0].id, 'board:11');
+});
+
+test('a contribution without a recognisable gate is DROPPED, never run (registeredContributions)', () => {
+  seams._reset();
+  seams.contribute(docket.CONTRIBUTION_POINT, { source: 'blockers', building: 'planning', read: async () => [] });
+  seams.contribute(docket.CONTRIBUTION_POINT, { source: 'goal_join_requests', building: 'people', gate: { rank: 'xenos' }, read: async () => [] });
+  seams.contribute(docket.CONTRIBUTION_POINT, { source: 'removal_proposals', building: 'disputes', gate: { permission: 'task.promote' } });
+  seams.contribute(docket.CONTRIBUTION_POINT, { source: 'criteria_uat', building: 'review', gate: { permission: 'criterion.review' }, read: async () => [] });
+  const reg = docket.registeredContributions();
+  assert.deepEqual([...reg.sources.keys()], ['criteria_uat']);
+  seams._reset();
+});
+
+test('nothing is invented: coming / off / unavailable are each reported, with no rows', async () => {
+  boardView = { open: [], closed: [] };
+  const c = none();
+  c.sources.set('blockers', contrib({ read: async () => { throw new Error('db down'); } }));
+  c.sources.set('core_update', contrib({ read: () => new Promise(() => {}) })); // never answers
+  const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: c, now: NOW, timeoutMs: 30 });
+  const by = Object.fromEntries(d.sources.map((s) => [s.source, s]));
+  assert.equal(by.blockers.status, 'unavailable');
+  assert.equal(by.core_update.status, 'unavailable');
+  assert.match(by.core_update.reason, /in time/);
+  assert.equal(by.access_requests.status, 'off', 'no contributor registered → its module is off');
+  assert.equal(by.module_rechecks.status, 'off', 'module re-checks are a real source now, never coming');
+  for (const k of ['grade_appeals', 'standing_rules', 'treasury_spending']) {
+    assert.equal(by[k].status, 'coming', k);
+    assert.ok(by[k].reason, `${k} says why`);
+  }
+  assert.equal(d.matters.length, 0);
+  // every source the design names is reported, in declared order, once
+  const keys = d.sources.map((s) => s.source);
+  assert.equal(new Set(keys).size, keys.length);
+  for (const e of docket.EXPECTED_SOURCES) assert.ok(keys.includes(e.source), e.source);
+  assert.equal(keys[0], 'board');
+});
+
+test('the response shape: counts, line, street-ordered buildings, sorted matters, six readings, vocabulary', async () => {
+  boardView = { open: [item()], closed: [item({ id: '12', closed_at: '2026-09-30T00:00:00Z', outcome: 'passed' }), item({ id: '13', closed_at: '2026-08-01T00:00:00Z', outcome: 'passed' })] };
+  const c = none();
+  c.sources.set('blockers', contrib({ building: 'planning', read: async () => [{ id: 4, title: 'Which payment provider', state: 'moving', opened_at: '2026-09-20T00:00:00Z' }] }));
+  c.sources.set('redteam_reports', contrib({ building: 'disputes', gate: { permission: 'security.report.adjudicate' }, read: async () => [{ id: 2, title: 'Security report: sign-in limits', state: 'needs', rule: 'decide', opened_at: '2026-09-29T00:00:00Z' }] }));
+  c.readings.set('flow', { reading: 'flow', gate: { anyBuilder: true }, read: async () => ({ value: 3, figure: '3 stuck', line: 'longest wait 4 days, waiting for review', hot: true }) });
+  const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast', 'security.report.adjudicate'], contributions: c, now: NOW });
+
+  assert.deepEqual(Object.keys(d).sort(), ['buildings', 'counts', 'generated_at', 'line', 'matters', 'readings', 'sources', 'viewer', 'vocabulary'].sort());
+  assert.deepEqual(d.viewer, { id: '7' });
+  // board 11 (needs) + board 12 (settled, closed this week) + blocker + report; board 13 is too old
+  assert.deepEqual(d.counts, { needs: 2, moving: 1, settled: 1 });
+  assert.equal(d.line, '2 matters wait on you · 1 moving');
+  assert.deepEqual(d.matters.map((m) => m.state), ['needs', 'needs', 'moving', 'settled'], 'needs first');
+  assert.equal(d.matters[0].id, 'board:11', 'among needs, the soonest deadline first');
+  assert.deepEqual(d.buildings.map((b) => b.key), vocab.BUILDING_KEYS);
+  const charter = d.buildings.find((b) => b.key === 'charter');
+  assert.deepEqual(charter.counts, { needs: 1, moving: 0, settled: 1 });
+  assert.deepEqual(charter.matter_ids.sort(), ['board:11', 'board:12']);
+
+  const r = Object.fromEntries(d.readings.map((x) => [x.key, x]));
+  assert.deepEqual(d.readings.map((x) => x.key), ['flow', 'promises', 'money', 'people', 'fairness', 'rules']);
+  assert.equal(r.flow.status, 'live');
+  assert.equal(r.flow.figure, '3 stuck');
+  assert.equal(r.people.figure, '12 builders');
+  assert.equal(r.fairness.status, 'live');
+  assert.equal(r.fairness.value, 1, 'one open dispute the viewer can see');
+  assert.equal(r.fairness.hot, true);
+  assert.equal(r.money.status, 'off', 'no autonomy contributor in this test, never a made-up figure');
+  assert.equal(r.rules.status, 'off');
+  assert.equal(r.promises.status, 'off', 'no lifecycle contributor in this test');
+  assert.deepEqual(d.vocabulary.states, ['needs', 'moving', 'settled']);
+  assert.deepEqual(d.vocabulary.rules.map((x) => x.key), ['decide', 'first', 'consent', 'majority', 'unanimous', 'signoff', 'rule']);
+});
+
+test('fairness is not_yours when the viewer can see no Disputes source (never a false "0 open")', async () => {
+  boardView = { open: [], closed: [] };
+  const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: none(), now: NOW });
+  assert.equal(d.readings.find((x) => x.key === 'fairness').status, 'not_yours');
+});
+
+// ── lifecycle + core mappers ─────────────────────────────────────────────────
+
+test('lifecycle mappers: override, removal, UAT, join request', () => {
+  const o = lifecycleDocket.overrideMatter({ id: 3, task_id: 99, task_title: 'Refund flow', requested_by_builder_id: 9, requester_login: 'theo', requester_display_name: 'Theo', created_at: 't' }, true);
+  assert.equal(o.state, 'needs');
+  assert.equal(o.title, 'Override: Refund flow');
+  assert.equal(o.href, '/task/99');
+  assert.equal(lifecycleDocket.overrideMatter({ id: 3, task_id: 99 }, false).state, 'moving');
+  const rm = lifecycleDocket.removalMatter({ proposal_task_id: '50', title: 'Was the old search page removed?', goal_title: 'Hall', filed_at: 't' });
+  assert.equal(rm.where, 'disputes · removal · Hall');
+  const u = lifecycleDocket.uatMatter({ id: 8, criterion_md: 'Refunds work', goal_id: 4, goal_title: 'Payments', shipped_total: 3 });
+  assert.equal(u.rule, 'signoff');
+  assert.equal(u.href, '/goals#/goal/4');
+  const j = lifecycleDocket.joinRequestMatter({ id: 2, goal_id: 4, goal_title: 'Payments', builder_id: 11, github_login: 'kai', display_name: 'Kai', created_at: 't' }, false);
+  assert.equal(j.title, 'Kai asks to join Payments');
+  assert.equal(j.state, 'needs');
+  assert.equal(lifecycleDocket.joinRequestMatter({ id: 2, goal_id: 4, goal_title: 'Payments' }, true).state, 'moving');
+});
+
+test('flow and promises readings', () => {
+  const day = 24 * 60 * 60 * 1000;
+  const f = lifecycleDocket.flowReading({ completed: [{ updated_at: new Date(NOW - 4 * day).toISOString() }, { updated_at: new Date(NOW - day).toISOString() }], confirmed: [{ updated_at: new Date(NOW).toISOString() }] }, NOW);
+  assert.deepEqual(f, { value: 3, figure: '3 stuck', line: 'longest wait 4 days, waiting for review', hot: true });
+  assert.equal(lifecycleDocket.flowReading({}, NOW).figure, 'all moving');
+  assert.equal(lifecycleDocket.promisesReading([{ satisfied: true }, { satisfied: false }, { satisfied: true }]).figure, '2 of 3 kept');
+  assert.equal(lifecycleDocket.promisesReading([]).value, null);
+});
+
+test('core update: behind is a matter, current is none, no answer is an error (never "up to date")', () => {
+  const m = coreUpdateRoute.coreUpdateDocketMatters({ reading: 'ok', behind: true, latest: '1.21.0', running: '1.20.75' });
+  assert.equal(m.length, 1);
+  assert.equal(m[0].title, 'Take core 1.21.0 (running 1.20.75)');
+  assert.deepEqual(coreUpdateRoute.coreUpdateDocketMatters({ reading: 'ok', behind: false }), []);
+  assert.throws(() => coreUpdateRoute.coreUpdateDocketMatters({ reading: 'no_answer', behind: false }));
+});
+
+test('blockers: needs only a viewer who may resolve one; the hold count reads in words', () => {
+  const b = { id: 4, title: 'Which payment provider', created_at: 't', blocking_task_ids: [1, 2, 3] };
+  const m = ideasDocket.blockerDocketMatter(b, true);
+  assert.equal(m.state, 'needs');
+  assert.equal(m.where, 'planning · holds 3 tasks');
+  assert.equal(m.href, '/blockers#blocker-4');
+  assert.equal(ideasDocket.blockerDocketMatter({ ...b, blocking_task_ids: [9] }, false).state, 'moving');
+  assert.equal(ideasDocket.blockerDocketMatter({ ...b, blocking_task_ids: [9] }, false).where, 'planning · holds 1 task');
+  assert.equal(ideasDocket.blockerDocketMatter({ ...b, blocking_task_ids: [] }, true).where, 'planning · waiting on a decision');
+});
+
+test('rules at work: the routing rule and what it settled this month', () => {
+  assert.deepEqual(ideasDocket.rulesReading(45), {
+    value: { rules: 1, settled_this_month: 45 }, figure: '1 rule',
+    line: 'the landing rule settled 45 filings this month without a vote', hot: false,
+  });
+  assert.equal(ideasDocket.rulesReading(1).line, 'the landing rule settled 1 filing this month without a vote');
+  assert.equal(ideasDocket.rulesReading(0).line, 'the landing rule settled nothing this month');
+});
+
+test('the fence: a matter only when it needs a governor, and only a fence manager is told it needs them', () => {
+  assert.deepEqual(autonomyDocket.fenceDocketMatters({ enabled: true, goals: [{ goal_id: 1 }] }, true), []);
+  const off = autonomyDocket.fenceDocketMatters({ enabled: false, paused_reason: 'payments touched', goals: [{ goal_id: 1 }], updated_by: 3 }, true);
+  assert.equal(off.length, 1);
+  assert.equal(off[0].title, 'Unattended building is switched off');
+  assert.equal(off[0].where, 'automation · the switch · payments touched');
+  assert.equal(off[0].state, 'needs');
+  assert.equal(autonomyDocket.fenceDocketMatters({ enabled: false, goals: [] }, false)[0].state, 'settled');
+  assert.equal(autonomyDocket.fenceDocketMatters({ enabled: true, goals: [] }, true)[0].title, 'Unattended building is on, but no goal is allowed');
+});
+
+test('money: what unattended building may still spend this month, never negative, hot under a fifth', () => {
+  const m = autonomyDocket.moneyReading({ ceilingUsd: 30, spentUsd: 12.5 });
+  assert.equal(m.figure, '$17.50 left');
+  assert.equal(m.line, 'unattended building this month · $12.50 of $30 spent');
+  assert.equal(m.value.scope, 'unattended building, this month');
+  assert.equal(m.hot, false);
+  assert.equal(autonomyDocket.moneyReading({ ceilingUsd: 30, spentUsd: 27 }).hot, true);
+  assert.equal(autonomyDocket.moneyReading({ ceilingUsd: 30, spentUsd: 41 }).figure, '$0 left');
+});
+
+test('access requests and red-team reports map to their buildings words', () => {
+  const a = accessRequestsRoute.accessRequestDocketMatter({ id: 5, github_login: 'kai', display_name: 'Kai', vouched: true, created_at: 't' });
+  assert.equal(a.title, 'Admit Kai as a builder');
+  assert.equal(a.where, 'people · waiting to join · vouched');
+  assert.equal(a.state, 'needs');
+  assert.equal(accessRequestsRoute.accessRequestDocketMatter({ id: 5, github_login: 'kai', vouched: false }).where, 'people · waiting to join');
+  const r = reportsRoute.redteamDocketMatter({ id: 2, title: 'sign-in limits', severity: 'high', status: 'repro_attempted', reporter_builder_id: 8, reported_at: 't' });
+  assert.equal(r.title, 'Security report: sign-in limits');
+  assert.equal(r.short, 'high report');
+  assert.equal(r.where, 'disputes · security report · being reproduced');
+  assert.deepEqual(r.proposer, { id: 8 });
+  assert.equal(reportsRoute.redteamDocketMatter({ id: 2, title: 'x', status: 'open' }).where, 'disputes · security report');
+});
+
+test('module re-checks: a failed gate needs a governor who may ask; a pending part is moving; the query reads the CURRENT signal', async () => {
+  const failed = moduleRechecks.moduleRecheckMatter({ version_id: 7, module_key: 'image-tools', version: '1.2.0', security_failed: true, pending_parts: null, measured_at: 't' }, true);
+  assert.equal(failed.state, 'needs');
+  assert.equal(failed.title, 'image-tools 1.2.0 failed its security check');
+  assert.equal(failed.where, 'release · modules · flagged for a re-check');
+  assert.equal(moduleRechecks.moduleRecheckMatter({ version_id: 7, module_key: 'm', version: '1.0.0', security_failed: true }, false).state, 'moving');
+  const pending = moduleRechecks.moduleRecheckMatter({ version_id: 8, module_key: 'm', version: '1.0.0', security_failed: false, pending_parts: ['tests'] }, true);
+  assert.equal(pending.state, 'moving');
+  assert.equal(pending.where, 'release · modules · tests pending');
+  let sql = null;
+  await moduleRechecks.listModuleRechecks({ db: { query: async (q, params) => { sql = q; assert.deepEqual(params, [50]); return { rows: [] }; } } });
+  assert.match(sql, /DISTINCT ON \(s\.version_id, s\.part\)/, 'the newest signal per part, not every historical row');
+  assert.match(sql, /ORDER BY s\.version_id, s\.part, s\.measured_at DESC, s\.id DESC/);
+  assert.match(sql, /outcome = 'failed'/);
+  assert.match(sql, /outcome = 'pending'/);
+  // The DISTINCT ON walks core_265's own composite index, whose column order is the
+  // query's ORDER BY exactly — pinned so a reorder of either side fails here.
+  const mig = fs.readFileSync(path.join(ROOT, 'migrations', 'core_265_module_assessments.sql'), 'utf8');
+  assert.match(mig, /idx_module_assessment_signals_current\s+ON module_assessment_signals \(version_id, part, measured_at DESC, id DESC\)/);
+});
+
+test('the six readings, end to end with every module contributing: each reading is live or names why not', async () => {
+  seams._reset();
+  for (const f of ['modules/ideas/routes/blockers.js', 'modules/lifecycle/routes/lifecycle.js', 'modules/autonomy/routes/autonomy.js']) require(path.join(ROOT, f))();
+  const reg = docket.registeredContributions();
+  // Stub each contributed reading's read so no DB is touched; the GATE stays real.
+  const stubbed = { sources: new Map(), readings: new Map() };
+  const answers = {
+    flow: { value: 3, figure: '3 stuck', line: 'l', hot: true },
+    promises: { value: { kept: 11, total: 17 }, figure: '11 of 17 kept', line: 'l', hot: false },
+    money: { value: {}, figure: '$17.50 left', line: 'l', hot: false },
+    rules: { value: {}, figure: '1 rule', line: 'l', hot: false },
+  };
+  for (const [k, c] of reg.readings) stubbed.readings.set(k, { ...c, read: async () => answers[k] });
+  boardView = { open: [], closed: [] };
+  const metic = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast', 'autonomy.precheck', 'security.report.adjudicate'], contributions: stubbed, now: NOW });
+  const by = Object.fromEntries(metic.readings.map((x) => [x.key, x]));
+  for (const k of ['flow', 'promises', 'money', 'people', 'rules']) assert.equal(by[k].status, 'live', k);
+  assert.equal(by.money.figure, '$17.50 left');
+  // A viewer without the precheck atom does not see the spend ceiling.
+  const xenos = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: stubbed, now: NOW });
+  assert.equal(xenos.readings.find((x) => x.key === 'money').status, 'not_yours');
+  assert.equal(xenos.readings.find((x) => x.key === 'money').figure, null);
+  seams._reset();
+});
+
+// ── 5. every contributed source declares its own list route's atom ───────────
+
+test('each contributed source gates on EXACTLY the atom its own list route requires', async () => {
+  seams._reset();
+  const factories = [
+    'modules/ideas/routes/blockers.js',
+    'modules/lifecycle/routes/lifecycle.js',
+    'modules/lifecycle/routes/gate-approvals.js',
+    'modules/onboarding/routes/access-requests.js',
+    'modules/security/routes/reports.js',
+    'modules/autonomy/routes/autonomy.js',
+    'src/bongos/routes/core-update.js',
+    'src/bongos/routes/modules.js',
+  ];
+  for (const f of factories) require(path.join(ROOT, f))();
+  const reg = docket.registeredContributions();
+  const routePerm = (file, key) => {
+    const r = rrc.classifyText(fs.readFileSync(path.join(ROOT, file), 'utf8')).find((x) => x.key === key);
+    assert.ok(r, `${key} declared in ${file}`);
+    return r.perms;
+  };
+  const expect = {
+    override_requests: ['modules/lifecycle/routes/tasks.js', 'GET /override-requests'],
+    removal_proposals: ['modules/lifecycle/routes/removal-proposals.js', 'GET /removal-proposals'],
+    criteria_uat: ['modules/lifecycle/routes/done-when.js', 'GET /done-when/pending-review'],
+    gate_approvals: ['modules/lifecycle/routes/gate-approvals.js', 'GET /gate-approvals'],
+    access_requests: ['modules/onboarding/routes/access-requests.js', 'GET /access-requests'],
+    redteam_reports: ['modules/security/routes/reports.js', 'GET /security/reports'],
+    core_update: ['src/bongos/routes/core-update.js', 'GET /core-update'],
+  };
+  for (const [source, [file, key]] of Object.entries(expect)) {
+    const c = reg.sources.get(source);
+    assert.ok(c, `${source} is contributed`);
+    assert.deepEqual([c.gate.permission], routePerm(file, key), `${source} gates on ${key}'s atom`);
+  }
+  // The own-scoped / public reads say so explicitly, and nothing else is anyBuilder.
+  const anyBuilder = [...reg.sources].filter(([, c]) => c.gate.anyBuilder === true).map(([k]) => k).sort();
+  assert.deepEqual(anyBuilder, ['autobongos_fence', 'blockers', 'goal_join_requests']);
+  for (const [k, c] of reg.sources) {
+    const decl = docket.EXPECTED_SOURCES.find((e) => e.source === k);
+    assert.ok(decl, `${k} is a declared source`);
+    assert.equal(c.building, decl.building, `${k} stands where the docket says`);
+  }
+  assert.equal(reg.sources.get('module_rechecks').gate.permission, 'module.assessment.rerun',
+    'module re-checks gate on the reassess route atom (there is no assessment read route)');
+  assert.deepEqual(routePerm('src/bongos/routes/modules.js', 'POST /store/modules/:key/versions/:version/reassess'), ['module.assessment.rerun']);
+  assert.deepEqual([...reg.readings.keys()].sort(), ['flow', 'money', 'promises', 'rules']);
+  assert.equal(reg.readings.get('money').gate.permission, 'autonomy.precheck');
+  assert.deepEqual(routePerm('modules/autonomy/routes/autonomy.js', 'GET /autonomy/precheck'), ['autonomy.precheck']);
+  // Every reading the street draws has a contributor once the modules are mounted.
+  for (const r of vocab.READINGS) {
+    if (r.key === 'people' || r.key === 'fairness') continue; // answered inside government
+    assert.ok(reg.readings.has(r.key), 'reading ' + r.key + ' is contributed');
+  }
+  seams._reset();
+});
+
+// ── 6. the route ─────────────────────────────────────────────────────────────
+
+const realRequireBuilder = api.requireBuilder;
+api.requireBuilder = (req, res, next) => { req.builder = { id: 7, rank: 'metic' }; next(); };
+let held = ['board.vote.cast'];
+function grant(keys) {
+  held = keys;
+  seams._reset();
+  seams.registerProvider('government', { resolveBuilderPermissions: async () => held });
+}
+grant(['board.vote.cast']);
+resolver.resolveBuilderPermissions = async () => held;
+const buildGovernmentRouter = require(path.join(ROOT, 'modules', 'government', 'routes', 'government.js'));
+const app = express();
+app.use(express.json());
+app.use(attachFail);
+app.use(buildGovernmentRouter());
+const server = http.createServer(app);
+await new Promise((r) => server.listen(0, '127.0.0.1', r));
+const BASE = `http://127.0.0.1:${server.address().port}`;
+after(() => { server.close(); api.requireBuilder = realRequireBuilder; });
+
+test('GET /government/docket: 403 without board.vote.cast, the documented shape with it', async () => {
+  boardView = { open: [item()], closed: [] };
+  grant([]);
+  let res = await fetch(`${BASE}/government/docket`);
+  assert.equal(res.status, 403);
+  grant(['board.vote.cast']);
+  // a hidden source contributed AFTER the router was built is still scoped
+  seams.contribute(docket.CONTRIBUTION_POINT, { source: 'access_requests', building: 'people', gate: { permission: 'access_request.review' }, read: async () => [{ id: 1, title: 'Admit Kai', state: 'needs' }] });
+  res = await fetch(`${BASE}/government/docket`);
+  assert.equal(res.status, 200);
+  const body = await res.json();
+  assert.equal(body.viewer.id, '7');
+  assert.deepEqual(body.matters.map((m) => m.id), ['board:11']);
+  assert.equal(body.sources.find((s) => s.source === 'access_requests').status, 'not_yours');
+  assert.ok(!JSON.stringify(body).includes('Admit Kai'), 'a hidden source leaks nothing');
+});

package/tests/onboard.mjs

@@ -81,10 +81,16 @@ test('every form OFFERS the optional step and names what skipping costs — skil
   assert.match(cli, /Press Enter to skip/, 'the terminal form offers the skip in the prompt itself');
   assert.match(cli, /off the public map/, 'and says what a missing description means');
 
-  // the web form
-  const hub = read('modules/public-landing/public/projects.html');
-  assert.match(hub, /id="panel-detail"/, 'the wizard ships the panel');
-  assert.match(hub, /id="skipDetail"/, 'with a skip control of its own');
+  // the web form — since task 1004504 the optional step is no panel of its own: the
+  // sentence is an optional field on "What are you making?" whose label names what
+  // leaving it empty costs, and the team shape is the review's Team size row
+  const hub = read('modules/public-landing/public/projects.html').replace(/\r\n/g, '\n');
+  const what = (hub.match(/<section class="panel" id="panel-what"[\s\S]*?\n {10}<\/section>/) || [''])[0];
+  assert.ok(what, 'the wizard ships the screen that carries the sentence');
+  assert.match(what, /<label class="wizField"><span>In a sentence <small>\(optional — puts it on the public map\)<\/small><\/span>\s*<input type="text" id="f-desc"/,
+    'the sentence is offered as optional, and its label says what skipping costs');
+  assert.match(hub, /<div class="setRow" data-row="team">[\s\S]*?id="teamCards"/, 'the team shape rides the review\'s Team size row');
+  assert.doesNotMatch(hub, /id="panel-detail"|id="skipDetail"/, 'the old About panel and its skip control are gone');
 
   // the route that receives it
   const route = read('modules/provisioning/routes/provisioning.js');

package/tests/platform_boot.mjs

@@ -147,7 +147,7 @@ test('/create redirects into the hub wizard, seed intact (task 1002763)', async
   assert.equal(hub.status, 200);
   assert.match(hub.headers['content-type'] || '', /text\/html/);
   assert.match(hub.body, /window\.__BRANDING__=/);
-  assert.match(hub.body, /Create a project/);
+  assert.match(hub.body, /<h1 id="gate-h">Make something\.<\/h1>/);   // the wizard's sign-in screen (task 1004504)
   // the wizard files the request against the provisioning API, nothing else
   assert.match(hub.body, /provisioning\/instances/);
 });