@bongos/core 1.21.12 → 1.21.14

package/tests/autobongos_host_access.mjs

@@ -0,0 +1,176 @@
+// tests/autobongos_host_access.mjs — the runner skips work it structurally
+// cannot do (task 1004537).
+//
+// The runner machine holds no SSH key, no root and no service environment for a
+// live droplet (ADR 0031 §6 / ADR 0055). Tasks 1003969 and 1003980 were still
+// picked, three times between them, and each run burned a claim and filed an
+// owner blocker saying the work was never doable there. These tests hold the
+// fence that stops that: a host-access task is SKIPPED, before any claim, with
+// the reason `needs_host_access` in nothing_claimable's skipped[], and an
+// ordinary code task beside it is still picked.
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+
+const require = createRequire(import.meta.url);
+const fence = require('../modules/autonomy/fence.js');
+const runner = require('../scripts/gds/autobongos-run.js');
+
+const { needsHostAccess, decideTask } = fence;
+
+// The two real shapes, excerpted from their task rows (touches, tags and
+// manual_degree exactly as they were: nothing explicit marked either one).
+const T1003969 = {
+  id: 1003969, goal_id: 1000119, kind: 'bug', status: 'ready', requires_rank: 'xenos',
+  touches: ['docs/recipes/upgrading-the-core.md'], manual_degree: null, automation_tag: null,
+  title: 'Install the core-update-subscription timer at the declared 15min cadence on the cloudbongos.com control plane',
+  description: [
+    'WHAT REMAINS (host state, not in this repo): the systemd unit lives on the droplet.',
+    '/etc/systemd/system/cloudbongos-core-update-subscription.timer is still OnCalendar=daily with RandomizedDelaySec=1800. Change it to:',
+    '    OnCalendar=*:0/15',
+    'then `sudo systemctl daemon-reload && sudo systemctl restart cloudbongos-core-update-subscription.timer`',
+  ].join('\n'),
+};
+const T1003980 = {
+  id: 1003980, goal_id: 1000119, kind: 'bug', status: 'ready', requires_rank: 'xenos',
+  touches: [], manual_degree: null, automation_tag: null,
+  title: 'Recover the five lost bug-attachment screenshots from the co-hosting box, or accept the loss on the record',
+  description: [
+    'WHAT IS LEFT. ADR 0126 kept the old co-hosting droplet as a rollback net after the 2026-07-05 move.',
+    'If its var/bug-attachments survived, the five files are recoverable by copying them onto the control-plane droplet at BUG_ATTACHMENTS_DIR.',
+    'WHY IT IS A SEPARATE ROW. It needs an interactive session on two live boxes - look for var/bug-attachments on the old droplet,',
+    'copy across, set BUG_ATTACHMENTS_DIR in the service environment, confirm the probe goes green.',
+    'DONE WHEN: either the audit reports zero missing, or the files are confirmed unrecoverable.',
+  ].join('\n'),
+};
+const CODE_TASK = {
+  id: 9002, goal_id: 1000119, kind: 'feature', status: 'ready', requires_rank: 'xenos',
+  touches: ['scripts/gds/sequence.js'], manual_degree: null, automation_tag: null,
+  title: 'Teach the picker a new halt reason',
+  description: 'Add a halt reason to scripts/gds/sequence.js and cover it with a tests/*.mjs case. '.repeat(4)
+    + 'DONE WHEN: the new case passes and the old ones still do.',
+};
+
+// ── the predicate ───────────────────────────────────────────────────────────────
+
+test('the 1003969 shape (systemd unit edited on the droplet via sudo) needs host access', () => {
+  const d = needsHostAccess(T1003969);
+  assert.equal(d.needs, true);
+  assert.equal(d.source, 'text');
+  assert.ok(d.signals.length, 'the matched phrase is named, so a false positive can be seen and overridden');
+});
+
+test('the 1003980 shape (copying files between two live boxes) needs host access', () => {
+  const d = needsHostAccess(T1003980);
+  assert.equal(d.needs, true);
+  assert.equal(d.source, 'text');
+});
+
+test('an ordinary code task does not', () => {
+  assert.equal(needsHostAccess(CODE_TASK).needs, false);
+});
+
+test("the explicit tag wins both ways: 'live-only' skips with no text, 'overnight-safe' overrides the text", () => {
+  const tagged = needsHostAccess({ ...CODE_TASK, automation_tag: 'live-only' });
+  assert.equal(tagged.needs, true);
+  assert.equal(tagged.source, 'automation_tag');
+  // An owner who reads the reason and disagrees marks the task safe; the phrase
+  // match must then stay quiet rather than refuse forever.
+  assert.equal(needsHostAccess({ ...T1003969, automation_tag: 'overnight-safe' }).needs, false);
+});
+
+test('code that merely talks ABOUT droplets is not mistaken for work ON one', () => {
+  const t = { ...CODE_TASK, description: 'The DigitalOcean droplet-create call in modules/box/do-client.js leaks a droplet when the API blips. Fix the retry so no droplet is orphaned. '.repeat(2) };
+  assert.equal(needsHostAccess(t).needs, false);
+});
+
+test('one passing mention of the box does not refuse a code task (the task 1004463 shape)', () => {
+  // A real ready task on 2026-10-02: a code fix whose description quotes the
+  // owner's current workaround. One phrase is description, not the work.
+  const t = { ...CODE_TASK, description: `${CODE_TASK.description} Today the owner's only route is \`ssh cloudbongos 'systemctl restart cloudbongos'\`; the hall should do it instead.` };
+  const d = needsHostAccess(t);
+  assert.equal(d.needs, false);
+  assert.deepEqual(d.signals, ['systemctl restart'], 'the lone phrase is still reported, so the threshold is visible');
+  // The same phrase twice over, as in the two real shapes, does refuse.
+  const twice = { ...t, description: `${t.description} Then sudo systemctl daemon-reload on the production droplet.` };
+  assert.equal(needsHostAccess(twice).needs, true);
+});
+
+test('a missing task is not a host-access task (decideTask refuses it on its own)', () => {
+  assert.equal(needsHostAccess(null).needs, false);
+});
+
+// ── decideTask refuses it, like protected_path ─────────────────────────────────
+
+test('decideTask refuses a host-access task with code needs_host_access', () => {
+  const d = decideTask({ task: T1003969, goals: [1000119], protectedHits: [] });
+  assert.equal(d.go, false);
+  assert.equal(d.code, 'needs_host_access');
+  assert.match(d.reason, /live host/);
+  assert.equal(decideTask({ task: CODE_TASK, goals: [1000119], protectedHits: [] }).go, true);
+});
+
+// ── the picker: skipped with a reason, and the code task behind it is picked ───
+
+function fakeApi(tasks, claimable) {
+  return {
+    me: { getMe: async () => ({ ok: true, data: { builder: { rank: 'archon' } } }) },
+    tasks: {
+      getTasks: async ({ query }) => ({ ok: true, data: { tasks: query.offset ? [] : tasks } }),
+      getTasksId: async ({ id }) => {
+        const t = tasks.find((x) => Number(x.id) === Number(id));
+        return t ? { ok: true, data: { task: { dependencies: [], dependents: [], ...t } } } : { ok: false };
+      },
+      getTasksClaimable: async () => ({ ok: true, data: { claimable: claimable.map((id) => ({ id })) } }),
+    },
+  };
+}
+
+test('pickTask walks past the host-access tasks to the code task behind them', async () => {
+  const api = fakeApi([T1003969, T1003980, CODE_TASK], [1003969, 1003980, 9002]);
+  const got = await runner.pickTask([1000119], { api, rank: 'archon' });
+  assert.equal(got.task && got.task.id, 9002, 'an ordinary code task is still picked');
+});
+
+test('when only host-access tasks are left, they appear in skipped[] as needs_host_access', async () => {
+  const api = fakeApi([T1003969, T1003980], [1003969, 1003980]);
+  const got = await runner.pickTask([1000119], { api, rank: 'archon' });
+  assert.equal(got.none, true, 'no claim is made on work the machine cannot do');
+  const byId = new Map(got.skipped.map((s) => [Number(s.id), s]));
+  for (const id of [1003969, 1003980]) {
+    const sk = byId.get(id);
+    assert.ok(sk, `task ${id} must be listed, not silently vanish`);
+    assert.ok(sk.reasons.some((r) => r.code === 'needs_host_access'), `task ${id} carries the reason`);
+    assert.equal(sk.goal_id, 1000119);
+  }
+});
+
+test('the nothing_claimable row the iteration writes carries needs_host_access', async () => {
+  const api = fakeApi([T1003969], [1003969]);
+  let claimed = false;
+  const row = await runner.iteration({ goals: [1000119] }, {
+    readFence: async () => ({ raw: { enabled: true, paused_reason: null, goals: [{ goal_id: 1000119 }] }, graderBypassed: false }),
+    gauge: () => ({ decision: { go: true, unknown: false, sleepUntil: null, reason: 'headroom' } }),
+    state: runner.newRunnerState(),
+    pickTask: (goals, d) => runner.pickTask(goals, { ...d, api, rank: 'archon' }),
+    run: async () => { claimed = true; return { ok: true, code: 0, stdout: '', stderr: '' }; },
+    // Inert stand-ins, so a regression that DOES pick the task fails this test
+    // without spawning a real worker or writing to a real ledger.
+    spawnWorker: async () => { claimed = true; return { code: 0, envelope: null, stdout: '', stderr: '' }; },
+    worktreeName: () => 'autobongos-test-host-access',
+    gradeLedgerPath: () => path.join(os.tmpdir(), `autobongos-host-access-${process.pid}.jsonl`),
+    api,
+    verifyDeps: {
+      task: { id: 1003969, status: 'shipped', updated_at: new Date().toISOString() },
+      probeArtifact: async () => ({ checked: true, onMain: true, sha: 'a'.repeat(40), subject: 'x' }),
+      fileBlocker: async () => ({ filed: false }),
+    },
+    record: (r) => r,
+  });
+  assert.equal(row.event, 'nothing_claimable');
+  assert.equal(claimed, false, 'no worktree is made and no claim is attempted');
+  assert.deepEqual(row.skipped, [{ id: 1003969, goal_id: 1000119, reasons: ['needs_host_access'] }]);
+});

package/tests/hall_matter_card.mjs

@@ -0,0 +1,387 @@
+// tests/hall_matter_card.mjs — THE MATTER CARD THAT ACTS (task 1004528, goal
+// 1000125).
+//
+// WHAT IT GUARDS. A pin on the street opens the prototype's full card()
+// (docs/design/mocks/governor-city/Street.dc.html), built by street-card.js over
+// the docket, the Board Room's read and the constitution in force, and its acts
+// go to the EXISTING routes. What can go wrong:
+//   * the card says something the ballot does not (a seat, a tally, a voice, a
+//     counsel note, a wording change) or offers an act that is not the viewer's;
+//   * an act reaches a route other than the one that does it, with a body that
+//     route refuses (a yes with a reason, an objection with no section), or a
+//     "release" moves the live core pin from a card;
+//   * an act that records nothing (abstain, hold) sends a request anyway;
+//   * after an act the street does not answer: no toast, no re-read, no
+//     building that rises or lights, no evening when nothing waits;
+//   * the card reaches innerHTML, or its motion escapes the Kill Switch.
+//
+// Run:  node tests/hall_matter_card.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const PUB = path.join(ROOT, 'modules/hall-ui/public');
+const require = createRequire(import.meta.url);
+require(path.join(PUB, 'city-draw.js'));
+require(path.join(PUB, 'street-draw.js'));
+const C = require(path.join(PUB, 'street-card.js'));
+const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8');
+const NOW = Date.parse('2026-10-02T12:00:00.000Z');
+const VIEWER = '95';
+
+// ── fixtures in the routes' own shapes ──────────────────────────────────────
+// docket matter: modules/government/docket.js normalizeMatter / boardMatter
+function matter(over = {}) {
+  return { id: 'board:41', source: 'board', building: 'charter', rule: 'unanimous', state: 'needs', title: 'Give Review a seat', short: 'amendment', where: 'charter · amendment', opened_at: '2026-10-01T09:00:00.000Z', deadline: '2026-10-03T09:00:00.000Z', proposer: { id: '4', login: 'ana', name: 'Ana Ruiz' }, tally: { for: 3, against: 0, open: 2, needs: 'needs everyone who votes' }, href: '/board-room?item=41', ref: { type: 'board_item', id: '41' }, ...over };
+}
+function docket(ms, over = {}) {
+  const counts = { needs: 0, moving: 0, settled: 0 };
+  ms.forEach((m) => { counts[m.state] += 1; });
+  return {
+    viewer: { id: VIEWER }, counts, line: '', matters: ms, readings: [], sources: [],
+    buildings: [{ key: 'review', counts: {}, matter_ids: [], decision: { who: 'whoever may mark work as meeting its checks', rule: 'decide', rule_words: 'decides alone', as_today: true, sitting: false } }],
+    vocabulary: {}, ...over,
+  };
+}
+const vote = (id, name, direction, over = {}) => ({ voter_id: String(id), github_login: name.toLowerCase(), display_name: name, direction, reason_md: null, section_key: null, cast_at: '2026-10-01T10:00:00.000Z', ...over });
+// board item: board.js boardRoomView project()
+function item(over = {}) {
+  return {
+    id: '41', subject_type: 'constitutional_amendment', subject_id: '7',
+    subject: { kind: 'decision_rules', proposed: { decision_rules: [{ area: 'review', decided_by: 'rank:tester', rule: 'signoff', who: 'the testers' }] }, rationale_md: 'Three pieces of finished work are waiting because no one is allowed to test them.\n\nMore below.', author_id: '4' },
+    opened_by: '4', opened_at: '2026-10-01T09:00:00.000Z', closes_at: '2026-10-03T09:00:00.000Z', remaining_seconds: 3600, expired: false, closed_at: null, outcome: null,
+    constitution: { membership: 'rank:metic+', pass_rule: 'unanimous', window_minutes: 1440, close_early_on_full_turnout: true },
+    votes: [vote(4, 'Ana Ruiz', 'yes'), vote(5, 'Theo', 'yes'), vote(6, 'Mira', 'yes')],
+    ...over,
+  };
+}
+const room = (open = [], closed = []) => ({ viewer_id: VIEWER, open, closed });
+const card = (ms, key, r = null, cons = null) => C.model({ docket: docket(ms), key, room: r, constitution: cons, now: NOW });
+
+// ── the card for each rule ──────────────────────────────────────────────────
+
+test('an open unanimous sitting that waits on you: the proposer\'s words, the change, the seats, counsel and the three acts', () => {
+  const cv = card([matter()], 'board:41', room([item()]));
+  assert.deepEqual([cv.where, cv.when, cv.title], ['charter · amendment', 'sat', 'Give Review a seat']);
+  assert.deepEqual(cv.quote, { by: 'Ana', words: 'Three pieces of finished work are waiting because no one is allowed to test them.' }, 'the first paragraph, in their own words');
+  assert.deepEqual(cv.change.rows, [{ label: 'Review', struck: 'whoever may mark work as meeting its checks, decides alone', inserted: 'the testers, signed off by someone who did not build it' }]);
+  assert.deepEqual(cv.seats.map((s) => [s.init, s.pos]), [['A', 'for'], ['T', 'for'], ['M', 'for'], ['you', 'you'], ['', 'open']], 'three for, your seat, one more open');
+  assert.equal(cv.tally, '3 for · 0 against · needs everyone who votes');
+  assert.match(cv.counsel.words, /^Everyone who votes has to agree, so one objection sends it back to Ana/);
+  assert.equal(cv.counsel.revise, false);
+  assert.deepEqual(cv.actions.map((a) => [a.key, a.label, a.tone]), [['for', 'vote for', 'primary'], ['object', 'object', 'quiet']]);
+  assert.deepEqual(cv.textActions.map((a) => a.key), ['abstain']);
+  assert.ok(cv.objectForm.sections.length >= 3);
+  assert.equal(cv.readOnly, false);
+});
+
+test('a majority sitting with an objection, after your yes: voices for and against, what it still needs', () => {
+  const it = item({ constitution: { membership: 'rank:metic+', pass_rule: 'majority', window_minutes: 1440, close_early_on_full_turnout: true }, votes: [vote(4, 'Ana Ruiz', 'yes'), vote(95, 'You', 'yes'), vote(7, 'Jun', 'no', { reason_md: 'Testers are volunteers. If they go quiet, nothing ships.', section_key: 'scope' })] });
+  const cv = card([matter({ rule: 'majority', state: 'moving', tally: { for: 2, against: 1, open: 2, needs: 'needs more than half' } })], 'board:41', room([it]));
+  assert.deepEqual(cv.voices, [{ side: 'for', by: 'for', words: 'Ana and You' }, { side: 'against', by: 'Jun · objects to what it changes', words: 'Testers are volunteers. If they go quiet, nothing ships.' }]);
+  assert.equal(cv.seats.find((s) => s.key === 'you').pos, 'for', 'your cast seat is filled');
+  assert.equal(cv.result, 'You voted for. It needs 1 more yes.', '5 seats: 3 carries it, 2 are in');
+  assert.match(cv.counsel.words, /^Jun objects to what it changes\. Under a majority/);
+  assert.deepEqual(cv.actions, [], 'no second vote');
+  assert.equal(cv.readOnly, true);
+});
+
+test('a sitting that came back to you: counsel answers the objection, revise and sit again, and the revision struck and inserted', () => {
+  const earlier = item({ id: '30', subject_type: 'review_matter', subject: { area: 'review', title: 'Testers sign off', detail_md: 'Testers sign off finished work.', author_id: VIEWER }, opened_at: '2026-09-20T09:00:00.000Z', closed_at: '2026-09-21T09:00:00.000Z', outcome: 'returned', votes: [vote(7, 'Jun', 'no', { reason_md: 'Volunteers go quiet.', section_key: 'scope' })] });
+  const back = item({ id: '44', subject_type: 'review_matter', subject: { area: 'review', title: 'Testers sign off', detail_md: 'Testers sign off finished work; after 3 days any council member can.', author_id: VIEWER }, opened_at: '2026-09-22T09:00:00.000Z', closed_at: '2026-09-23T09:00:00.000Z', outcome: 'returned', votes: [vote(7, 'Jun', 'no', { reason_md: 'Three days is too short.', section_key: 'success' })] });
+  const cv = card([matter({ id: 'board:44', building: 'review', state: 'settled', ref: { type: 'board_item', id: '44' }, proposer: { id: VIEWER, login: 'me', name: 'Me' } })], 'board:44', room([], [back, earlier]));
+  assert.equal(cv.result, 'It came back to you.');
+  assert.match(cv.counsel.words, /^Jun objected to how we will know it worked: “Three days is too short\.” Answer that/);
+  assert.equal(cv.counsel.revise, true);
+  assert.deepEqual(cv.reviseForm, { text: 'Testers sign off finished work; after 3 days any council member can.', label: 'the matter, in your words' });
+  assert.deepEqual(cv.revision, { struck: 'Testers sign off finished work.', inserted: 'Testers sign off finished work; after 3 days any council member can.' });
+  assert.equal(cv.readOnly, false);
+});
+
+test('passed, not yours, a Full Idea, and a ballot not read yet are read-only', () => {
+  const passed = card([matter({ state: 'settled' })], 'board:41', room([], [item({ closed_at: '2026-10-02T09:00:00.000Z', outcome: 'passed', votes: [vote(4, 'Ana', 'yes'), vote(5, 'Theo', 'yes')] })]));
+  assert.equal(passed.result, 'Passed 2–0. In force from 2026-10-02.');
+  assert.deepEqual([passed.readOnly, passed.actions.length, passed.textActions.length], [true, 0, 0]);
+  const notMine = card([matter({ state: 'settled', proposer: null })], 'board:41', room([item({ subject: { ...item().subject, author_id: '4' } })]));
+  assert.equal(notMine.result, 'Not yours to vote on. You will see how it ends.');
+  assert.equal(notMine.actions.length, 0);
+  assert.ok(!notMine.seats.some((s) => s.pos === 'you'), 'no seat drawn for you when you have none');
+  const idea = card([matter({ building: 'planning', state: 'needs' })], 'board:41', room([item({ subject_type: 'full_idea', subject: { title: 'An idea', author_id: '4', field_values: { purpose: 'It does a thing.' } } })]));
+  assert.equal(idea.actions.length, 0, 'a Full Idea is voted on with its sections in front of you');
+  assert.match(idea.result, /Board Room/);
+  assert.equal(idea.href, '/board-room?item=41');
+  const loading = card([matter()], 'board:41', null);
+  assert.deepEqual([loading.loading, loading.readOnly, loading.result], [true, true, 'Reading the sitting…']);
+  const gone = card([matter()], 'board:41', room([]));
+  assert.equal(gone.result, 'This sitting could not be read just now.');
+});
+
+test('a constitution amendment shows each changed setting struck and inserted against the constitution in force', () => {
+  const it = item({ subject: { proposed: { membership: 'rank:metic+', pass_rule: 'unanimous', window_minutes: 1440, close_early_on_full_turnout: true }, rationale_md: 'Let the council decide.', author_id: '4' } });
+  const cv = card([matter()], 'board:41', room([it]), { board: { membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true } });
+  assert.deepEqual(cv.change.rows, [
+    { label: 'who sits', struck: 'the archon rank', inserted: 'metic and above' },
+    { label: 'how it passes', struck: 'the first yes decides', inserted: 'everyone has to agree' },
+    { label: 'how long it sits', struck: 'no clock', inserted: '1 day' },
+  ], 'the unchanged setting is left out');
+});
+
+test('admissions: fine by me or object when it is yours, read-only when it is not', () => {
+  const m = { id: 'access_requests:7', source: 'access_requests', building: 'people', rule: 'decide', state: 'needs', title: 'Admit Kai as a builder', short: 'admit kai', where: 'people · waiting to join · vouched', proposer: { login: 'kai', name: 'Kai' }, tally: null, href: '/watch', ref: { type: 'access_request', id: '7' } };
+  const cv = card([m], 'access_requests:7');
+  assert.equal(cv.quote.words, 'Kai asked to join as a builder, and someone vouched for them.');
+  assert.deepEqual(cv.actions.map((a) => [a.key, a.label]), [['fine', 'fine by me'], ['refuse', 'object']]);
+  const other = card([{ ...m, state: 'moving' }], 'access_requests:7');
+  assert.deepEqual([other.readOnly, other.actions.length], [true, 0]);
+});
+
+test('release or hold at the gate and for an override; a newer core is released where its check runs, never from the card', () => {
+  const o = card([{ id: 'override_requests:9', source: 'override_requests', building: 'release', rule: 'decide', state: 'needs', title: 'Release the new sign-up', where: 'release · past a failed check or grade', proposer: null, href: '/task/12', ref: { type: 'override_request', id: '9' } }], 'override_requests:9');
+  assert.deepEqual(o.actions.map((a) => [a.key, a.tone]), [['release', 'primary'], ['hold', 'quiet']]);
+  const core = card([{ id: 'core_update:1.21.0', source: 'core_update', building: 'release', rule: 'decide', state: 'needs', title: 'Take core 1.21.0', where: 'release · core update', proposer: null, href: '/settings#software-update', ref: { type: 'core_version', id: '1.21.0' } }], 'core_update:1.21.0');
+  assert.equal(core.actions[0].go, '/settings#software-update', 'a link to where the pin is moved with its dry run');
+  assert.equal(C.request(core, 'release', {}), null, 'the card itself never moves the pin');
+  const uat = card([{ id: 'criteria_uat:3', source: 'criteria_uat', building: 'review', rule: 'signoff', state: 'needs', title: 'Sign-up works', where: 'review', href: '/goals', ref: { type: 'criterion', id: '3' } }], 'criteria_uat:3');
+  assert.deepEqual([uat.readOnly, uat.actions.length], [true, 0]);
+});
+
+// ── act → the existing route ────────────────────────────────────────────────
+
+test('every act maps to the route that does it, with the body that route accepts', () => {
+  const sit = card([matter()], 'board:41', room([item()]));
+  assert.deepEqual(C.request(sit, 'for'), { method: 'POST', url: '/api/bongos/government/board/items/41/votes', body: { direction: 'yes' } });
+  assert.deepEqual(C.request(sit, 'object', { reason: '  Volunteers go quiet. ', section: 'scope' }), { method: 'POST', url: '/api/bongos/government/board/items/41/votes', body: { direction: 'no', reason_md: 'Volunteers go quiet.', section_key: 'scope' } });
+  assert.equal(C.request(sit, 'abstain'), null, 'abstaining records nothing');
+  assert.deepEqual(C.request(sit, 'revise', { text: 'New words' }), { method: 'POST', url: '/api/bongos/government/board/decision-rules', body: { rules: item().subject.proposed.decision_rules, rationale_md: 'New words' } });
+  const amend = card([matter()], 'board:41', room([item({ subject: { proposed: { membership: 'rank:archon', pass_rule: 'consent', window_minutes: null, close_early_on_full_turnout: true }, rationale_md: 'x', author_id: VIEWER } })]));
+  assert.deepEqual(C.request(amend, 'revise', { text: 'Why, again' }), { method: 'POST', url: '/api/bongos/government/board/items', body: { subject_type: 'constitutional_amendment', proposal: { membership: 'rank:archon', pass_rule: 'consent', window_minutes: null, close_early_on_full_turnout: true }, rationale_md: 'Why, again' } });
+  const mat = card([matter()], 'board:41', room([item({ subject_type: 'people_matter', subject: { area: 'people', title: 'Make Kai a tester', detail_md: 'd', action: { type: 'assign_rank', builder_id: 12, rank_key: 'tester' }, author_id: VIEWER } })]));
+  assert.deepEqual(C.request(mat, 'revise', { text: 'Kai tests well.' }), { method: 'POST', url: '/api/bongos/government/board/matters', body: { area: 'people', title: 'Make Kai a tester', detail_md: 'Kai tests well.', action: { type: 'assign_rank', builder_id: 12, rank_key: 'tester' } } });
+
+  const acc = card([{ id: 'access_requests:7', source: 'access_requests', building: 'people', state: 'needs', title: 'Admit Kai', proposer: { login: 'kai' }, ref: { type: 'access_request', id: '7' } }], 'access_requests:7');
+  assert.deepEqual(C.request(acc, 'fine'), { method: 'PATCH', url: '/api/bongos/access-requests/7', body: { status: 'invited' } });
+  assert.deepEqual(C.request(acc, 'refuse'), { method: 'PATCH', url: '/api/bongos/access-requests/7', body: { status: 'dismissed' } });
+  const join = card([{ id: 'goal_join_requests:5', source: 'goal_join_requests', building: 'people', state: 'needs', title: 'Join', proposer: { login: 'bo' }, href: '/goals#/goal/1000125', ref: { type: 'goal_membership_request', id: '5' } }], 'goal_join_requests:5');
+  assert.deepEqual(C.request(join, 'fine'), { method: 'POST', url: '/api/bongos/goals/1000125/requests/5/respond', body: { action: 'approve' } });
+  assert.deepEqual(C.request(join, 'refuse'), { method: 'POST', url: '/api/bongos/goals/1000125/requests/5/respond', body: { action: 'deny' } });
+  const ov = card([{ id: 'override_requests:9', source: 'override_requests', building: 'release', state: 'needs', title: 'Release', ref: { type: 'override_request', id: '9' } }], 'override_requests:9');
+  assert.deepEqual(C.request(ov, 'release'), { method: 'POST', url: '/api/bongos/override-requests/9/decide', body: { decision: 'approve' } });
+  assert.equal(C.request(ov, 'hold'), null, 'holding records nothing');
+  const gate = card([{ id: 'gate_approvals:812', source: 'gate_approvals', building: 'release', state: 'needs', title: 'A PR', ref: { type: 'pull_request', id: 812 } }], 'gate_approvals:812');
+  assert.deepEqual(C.request(gate, 'release'), { method: 'POST', url: '/api/bongos/gate-approvals/812/approve', body: {} });
+});
+
+test('no act on any card reaches the core pin or a provisioning route', () => {
+  const src = read('street-card.js').replace(/^\s*\/\/.*$/gm, '');
+  assert.doesNotMatch(src, /core-upgrade|provisioning|\/core-update/);
+});
+
+test('an objection names its reason and its part before anything is sent; the parts are the server\'s own keys', () => {
+  const sit = card([matter()], 'board:41', room([item()]));
+  assert.match(C.check(sit, 'object', { reason: ' ', section: 'scope' }), /^Say why/);
+  assert.match(C.check(sit, 'object', { reason: 'Because.', section: '' }), /^Pick the part/);
+  assert.equal(C.check(sit, 'object', { reason: 'Because.', section: 'scope' }), null);
+  assert.match(C.check(sit, 'revise', { text: '' }), /^Write the revised words/);
+  const board = fs.readFileSync(path.join(ROOT, 'modules/government/board.js'), 'utf8');
+  const keys = [...board.match(/const FULL_IDEA_SECTION_KEYS = Object\.freeze\(\[([\s\S]*?)\]\)/)[1].matchAll(/'([a-z_]+)'/g)].map((m) => m[1]);
+  assert.ok(keys.length >= 5);
+  for (const s of C.SECTIONS) assert.ok(keys.includes(s.key), `${s.key} is a key the vote route accepts`);
+});
+
+test('after an act the street answers: what rises, what lights, what settles, and when the card closes', () => {
+  const sit = card([matter()], 'board:41', room([item()]));
+  assert.deepEqual(C.answer(sit, 'for', { item_closed: true, outcome: 'passed' }), { toast: 'Passed. It is in force from today.', building: 'charter', kind: 'rise', close: false });
+  assert.deepEqual(C.answer(sit, 'for', {}), { toast: 'Your yes is on the record.', building: 'charter', kind: 'light', close: false });
+  assert.equal(C.answer(sit, 'object', { item_closed: true, outcome: 'returned' }).kind, 'settle');
+  assert.deepEqual(C.answer(sit, 'abstain', {}).building, null, 'nothing recorded, nothing moves');
+  const ov = card([{ id: 'override_requests:9', source: 'override_requests', building: 'release', state: 'needs', title: 'Release', ref: { type: 'override_request', id: '9' } }], 'override_requests:9');
+  assert.deepEqual(C.answer(ov, 'release', { ok: true }), { toast: 'Released. It goes live.', building: 'release', kind: 'rise', close: true });
+  assert.equal(C.refusal(403, { error: { code: 'not_board_member' } }), 'Only the members of this sitting may vote on it.');
+  assert.equal(C.refusal(403, { error: { code: 'forbidden' } }), 'That is not yours to do.');
+});
+
+// ── the page ────────────────────────────────────────────────────────────────
+
+function fakeDom() {
+  const byId = new Map();
+  const focused = { el: null };
+  const mk = (tag) => ({
+    tagName: tag, attrs: {}, children: [], style: { setProperty(k, v) { this[k] = v; } }, className: '', listeners: {}, _text: '', hidden: false, value: '',
+    clientWidth: 1440, clientHeight: 708, offsetLeft: 0, scrollLeft: 0, parentNode: null,
+    get firstChild() { return this.children[0] || null; },
+    setAttribute(k, v) { this.attrs[k] = String(v); if (k === 'id') byId.set(String(v), this); },
+    getAttribute(k) { return k in this.attrs ? this.attrs[k] : null; },
+    appendChild(c) { this.children.push(c); c.parentNode = this; return c; },
+    removeChild(c) { this.children = this.children.filter((x) => x !== c); return c; },
+    addEventListener(t, fn) { (this.listeners[t] = this.listeners[t] || []).push(fn); },
+    fire(t) { (this.listeners[t] || []).forEach((fn) => fn({ type: t, preventDefault() {} })); },
+    focus() { focused.el = this; },
+    set textContent(v) { this._text = String(v); this.children = []; },
+    get textContent() { return this._text; },
+    get innerHTML() { throw new Error('the card must not read innerHTML'); },
+    set innerHTML(v) { throw new Error('the card must not write innerHTML'); },
+  });
+  const ids = ['streetMode', 'streetModeIcon', 'streetModeWord', 'streetWindow', 'streetSizer', 'streetBoard', 'streetSvg', 'streetFlat', 'streetBlds', 'streetCrates', 'streetCols', 'streetGroups', 'streetDoors', 'streetPins', 'streetSigns', 'streetHint', 'streetEvening', 'streetEveningLine', 'hudNeeds', 'hudMoving', 'hudShare', 'hudDot', 'streetHome', 'streetCard', 'streetCardWhere', 'streetCardWhen', 'streetCardTitle', 'streetCardBody', 'streetCardOpen', 'streetCardClose', 'streetToast'];
+  for (const id of ids) mk('x').setAttribute('id', id);
+  byId.get('streetToast').hidden = true; // as the page ships it
+  const document = { documentElement: mk('html'), getElementById: (id) => byId.get(id) || null, createElement: (t) => mk(t), createElementNS: (_ns, t) => mk(t) };
+  return { document, byId, focused };
+}
+const walk = (el, pred, out = []) => { if (pred(el)) out.push(el); (el.children || []).forEach((c) => walk(c, pred, out)); return out; };
+const byAct = (el, key) => walk(el, (n) => n.attrs && n.attrs['data-act'] === key)[0];
+const settle = () => new Promise((r) => setImmediate(r));
+
+// feeds: url → body, or (call) → body; a POST answers from `posts`.
+async function bootPage({ feeds, posts = {} }) {
+  const { document, byId, focused } = fakeDom();
+  const calls = [];
+  const window = {
+    innerWidth: 1440, innerHeight: 900, location: { hash: '' },
+    localStorage: { getItem: () => null, setItem() {} },
+    matchMedia: () => ({ matches: true, addEventListener() {} }),
+    addEventListener() {},
+  };
+  const fetch = (url, opts = {}) => {
+    const method = opts.method || 'GET';
+    calls.push({ url, method, body: opts.body ? JSON.parse(opts.body) : null });
+    const src = method === 'GET' ? feeds[url] : posts[`${method} ${url}`];
+    const ans = typeof src === 'function' ? src(calls) : src;
+    if (ans === undefined) return Promise.resolve({ ok: false, status: 404, json: async () => ({}) });
+    const status = ans && ans.__status ? ans.__status : 200;
+    return Promise.resolve({ ok: status < 400, status, json: async () => ans });
+  };
+  const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, Date, console, encodeURIComponent, decodeURIComponent, isNaN, isFinite });
+  ctx.globalThis = ctx;
+  for (const f of ['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street.js']) vm.runInContext(read(f), ctx);
+  await window.GovStreetPage.ready;
+  return { window, byId, calls, focused };
+}
+const BASE = (d) => ({
+  '/api/bongos/government/docket': d,
+  '/api/bongos/goals': { goals: [] },
+  '/api/bongos/goals/rollups': { rollups: [] },
+  '/api/bongos/builders/95/earnings': { days: [] },
+  '/api/bongos/government/board/items': room([item()]),
+  '/api/bongos/government/constitution': { board: { membership: 'rank:metic+', pass_rule: 'unanimous', window_minutes: 1440, close_early_on_full_turnout: true } },
+});
+
+test('a pin opens the full card: the ballot is read, then the seats, counsel and acts are drawn as text', async () => {
+  const p = await bootPage({ feeds: BASE(docket([matter({ title: '<b>x</b>' })])) });
+  p.byId.get('streetPins').children[0].fire('click');
+  await settle(); await settle();
+  assert.ok(p.calls.some((c) => c.url === '/api/bongos/government/board/items'), 'the room is read when a sitting opens');
+  const body = p.byId.get('streetCardBody');
+  assert.equal(p.byId.get('streetCardTitle').textContent, '<b>x</b>');
+  assert.equal(walk(body, (n) => /mcard-seat /.test(n.className)).length, 5);
+  assert.ok(byAct(body, 'for') && byAct(body, 'object') && byAct(body, 'abstain'));
+  assert.equal(walk(body, (n) => n.className === 'mcard-counsel').length, 1);
+});
+
+test('vote for: one POST to the vote route, a toast, the docket re-read, and the Charter lights with its pin settling', async () => {
+  let reads = 0;
+  const after = docket([matter({ state: 'moving', tally: { for: 4, against: 0, open: 1, needs: 'needs everyone who votes' } })]);
+  const feeds = BASE((() => { const d0 = docket([matter()]); return () => (reads++ === 0 ? d0 : after); })());
+  feeds['/api/bongos/government/docket'] = (() => { const d0 = docket([matter()]); return () => (reads++ === 0 ? d0 : after); })();
+  const p = await bootPage({ feeds, posts: { 'POST /api/bongos/government/board/items/41/votes': { ok: true, vote: {}, already_voted: false, karma_delta: 1 } } });
+  p.byId.get('streetPins').children[0].fire('click');
+  await settle(); await settle();
+  byAct(p.byId.get('streetCardBody'), 'for').fire('click');
+  await settle(); await settle(); await settle();
+  const posts = p.calls.filter((c) => c.method !== 'GET');
+  assert.deepEqual(posts, [{ url: '/api/bongos/government/board/items/41/votes', method: 'POST', body: { direction: 'yes' } }]);
+  assert.equal(p.byId.get('streetToast').textContent, 'Your yes is on the record.');
+  assert.equal(p.byId.get('streetToast').hidden, false);
+  assert.ok(reads >= 2, 'the docket is read again');
+  const charter = p.byId.get('streetBlds').children.find((g) => g.attrs['data-key'] === 'charter');
+  assert.equal(charter.attrs.class, 'street-answer street-answer--light');
+  assert.match(p.byId.get('streetPins').children[0].className, /street-pin--moving street-pin--answer/, 'the pin moved from needs to moving');
+});
+
+test('object: the form asks for the reason and the part, then puts both on the record', async () => {
+  const p = await bootPage({ feeds: BASE(docket([matter()])), posts: { 'POST /api/bongos/government/board/items/41/votes': { ok: true, vote: {}, item_closed: true, outcome: 'returned' } } });
+  p.byId.get('streetPins').children[0].fire('click');
+  await settle(); await settle();
+  byAct(p.byId.get('streetCardBody'), 'object').fire('click');
+  assert.equal(p.focused.el, p.byId.get('mcardReason'), 'focus goes to the reason');
+  byAct(p.byId.get('streetCardBody'), 'object-send').fire('click');
+  await settle();
+  assert.equal(p.calls.filter((c) => c.method !== 'GET').length, 0, 'an empty objection is refused before it is sent');
+  assert.match(walk(p.byId.get('streetCardBody'), (n) => n.className === 'mcard-error')[0].textContent, /^Say why/);
+  p.byId.get('mcardReason').value = 'Volunteers go quiet.';
+  p.byId.get('mcardSection').value = 'scope';
+  byAct(p.byId.get('streetCardBody'), 'object-send').fire('click');
+  await settle(); await settle(); await settle();
+  assert.deepEqual(p.calls.filter((c) => c.method !== 'GET').map((c) => c.body), [{ direction: 'no', reason_md: 'Volunteers go quiet.', section_key: 'scope' }]);
+  assert.equal(p.byId.get('streetToast').textContent, 'Your objection is on the record. It goes back to its author to revise.');
+});
+
+test('a refused act says why and records nothing; abstain sends nothing at all', async () => {
+  const p = await bootPage({ feeds: BASE(docket([matter()])), posts: { 'POST /api/bongos/government/board/items/41/votes': { __status: 403, error: { code: 'not_board_member' } } } });
+  p.byId.get('streetPins').children[0].fire('click');
+  await settle(); await settle();
+  byAct(p.byId.get('streetCardBody'), 'for').fire('click');
+  await settle(); await settle();
+  assert.equal(walk(p.byId.get('streetCardBody'), (n) => n.className === 'mcard-error')[0].textContent, 'Only the members of this sitting may vote on it.');
+  assert.equal(p.byId.get('streetToast').hidden, true, 'no toast for a refusal');
+  const before = p.calls.length;
+  byAct(p.byId.get('streetCardBody'), 'abstain').fire('click');
+  await settle();
+  assert.equal(p.calls.length, before, 'abstaining sends nothing');
+  assert.equal(p.byId.get('streetCard').hidden, true);
+});
+
+test('release: the override is approved, the card closes, Release rises, and with nothing left the street turns to evening', async () => {
+  const ov = { id: 'override_requests:9', source: 'override_requests', building: 'release', rule: 'decide', state: 'needs', title: 'Release the new sign-up', where: 'release · past a failed check or grade', proposer: { login: 'lu' }, href: '/task/12', ref: { type: 'override_request', id: '9' } };
+  let reads = 0;
+  const feeds = BASE(null);
+  feeds['/api/bongos/government/docket'] = () => (reads++ === 0 ? docket([ov]) : docket([]));
+  const p = await bootPage({ feeds, posts: { 'POST /api/bongos/override-requests/9/decide': { ok: true } } });
+  assert.equal(p.byId.get('streetEvening').hidden, true);
+  p.byId.get('streetPins').children[0].fire('click');
+  byAct(p.byId.get('streetCardBody'), 'release').fire('click');
+  await settle(); await settle(); await settle();
+  assert.deepEqual(p.calls.filter((c) => c.method !== 'GET').map((c) => [c.method, c.url, c.body]), [['POST', '/api/bongos/override-requests/9/decide', { decision: 'approve' }]]);
+  assert.equal(p.byId.get('streetCard').hidden, true);
+  assert.equal(p.byId.get('streetToast').textContent, 'Released. It goes live.');
+  assert.equal(p.byId.get('streetBlds').children.find((g) => g.attrs['data-key'] === 'release').attrs.class, 'street-answer street-answer--rise');
+  assert.equal(p.byId.get('streetEvening').hidden, false, 'nothing waits on you');
+  assert.equal(p.byId.get('hudNeeds').textContent, '0');
+});
+
+// ── the sheet ───────────────────────────────────────────────────────────────
+
+test('the card\'s motion is CSS only and dies under reduced motion; tokens only; no innerHTML', () => {
+  const css = read('street-card.css').replace(/\/\*[\s\S]*?\*\//g, '');
+  assert.doesNotMatch(css, /:root/);
+  assert.doesNotMatch(css, /#fb9569/i, 'the accent is the token');
+  const literals = [...css.matchAll(/#[0-9a-f]{3,8}\b/gi)].map((m) => m[0].toLowerCase());
+  assert.ok(literals.every((h) => h === '#000000' || h === '#ffffff'), `only black or white in a mix: ${literals}`);
+  for (const k of ['street-rise', 'street-light', 'street-settle', 'street-seat']) assert.match(css, new RegExp(`@keyframes ${k} `));
+  const kill = css.match(/@media \(prefers-reduced-motion: reduce\) \{([\s\S]*)\}\s*$/)[1];
+  for (const c of ['.street-answer', '.street-pin--answer', '.mcard-seat--fresh', '.street-toast']) assert.ok(kill.includes(c), `${c} stops under reduced motion`);
+  assert.match(kill, /animation: none !important; transition: none !important;/);
+  const js = read('street-card.js').replace(/^\s*\/\/.*$/gm, '');
+  assert.doesNotMatch(js, /innerHTML|insertAdjacentHTML|requestAnimationFrame|setInterval|setTimeout/);
+  const html = read('street.html');
+  assert.match(html, /<link rel="stylesheet" href="\/builders\/street-card\.css/);
+  assert.match(html, /id="streetToast" role="status" aria-live="polite"/);
+});
+
+// ── the Board Room names the new subjects ───────────────────────────────────
+
+test('the Board Room labels a building\'s matter as that building\'s matter, and a who-decides change as its own amendment', () => {
+  const src = read('board-room.js');
+  const fn = src.slice(src.indexOf('  function subjectLine(item) {'), src.indexOf('  function clockLine(item) {'));
+  const esc = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  const subjectLine = new Function('escapeHtml', 'pill', `${fn}\nreturn subjectLine;`)(esc, (tone, t) => `[${t}]`);
+  assert.equal(subjectLine({ subject_type: 'people_matter', subject: { title: 'Make <Kai> a tester' } }), 'Make &lt;Kai&gt; a tester [people matter]');
+  assert.equal(subjectLine({ subject_type: 'treasury_matter', subject: null }), 'A matter at treasury [treasury matter]');
+  assert.equal(subjectLine({ subject_type: 'constitutional_amendment', subject: { kind: 'decision_rules' } }), 'Who decides what [amendment]');
+  assert.equal(subjectLine({ subject_type: 'constitutional_amendment', subject: { proposed: {} } }), 'Constitutional amendment [amendment]');
+});

package/tests/hall_street.mjs

@@ -377,7 +377,7 @@ test('the page holds the prototype\'s header, the street, the readings and the c
   for (const id of ['hudNeeds', 'hudMoving', 'hudShare', 'streetMode', 'streetSigns', 'streetPins', 'streetDoors', 'streetCard']) assert.match(html, new RegExp(`id="${id}"`), id);
   assert.doesNotMatch(html, /app-sidebar|shell\.js/, 'no hall chrome, as the city');
   const scripts = [...html.matchAll(/<script src="\/builders\/([a-z-]+)\.js/g)].map((m) => m[1]);
-  assert.deepEqual(scripts, ['city-draw', 'street-draw', 'street-inside', 'street'], 'the shared kit loads first, then the interiors (task 1004526)');
+  assert.deepEqual(scripts, ['city-draw', 'street-draw', 'street-card', 'street-inside', 'street'], 'the shared kit loads first, then the card (task 1004528) and the interiors (task 1004526)');
   assert.equal(City.STREET_HREF, '/builders/street', 'the city\'s door is this page');
 });
 
@@ -422,7 +422,7 @@ function fakeDom() {
   };
   const focused = { el: null };
   const html = mk('html');
-  const ids = ['streetMode', 'streetModeIcon', 'streetModeWord', 'streetWindow', 'streetSizer', 'streetBoard', 'streetSvg', 'streetFlat', 'streetBlds', 'streetCrates', 'streetCols', 'streetGroups', 'streetDoors', 'streetPins', 'streetSigns', 'streetHint', 'streetEvening', 'streetEveningLine', 'hudNeeds', 'hudMoving', 'hudShare', 'hudDot', 'streetHome', 'streetCard', 'streetCardWhere', 'streetCardWhen', 'streetCardTitle', 'streetCardMeta', 'streetCardLines', 'streetCardResult', 'streetCardOpen', 'streetCardClose'];
+  const ids = ['streetMode', 'streetModeIcon', 'streetModeWord', 'streetWindow', 'streetSizer', 'streetBoard', 'streetSvg', 'streetFlat', 'streetBlds', 'streetCrates', 'streetCols', 'streetGroups', 'streetDoors', 'streetPins', 'streetSigns', 'streetHint', 'streetEvening', 'streetEveningLine', 'hudNeeds', 'hudMoving', 'hudShare', 'hudDot', 'streetHome', 'streetCard', 'streetCardWhere', 'streetCardWhen', 'streetCardTitle', 'streetCardBody', 'streetCardOpen', 'streetCardClose', 'streetToast'];
   for (const id of ids) mk('x').setAttribute('id', id);
   const document = { documentElement: html, getElementById: (id) => byId.get(id) || null, createElement: (t) => mk(t), createElementNS: (_ns, t) => mk(t) };
   return { document, byId, html, focused };
@@ -449,6 +449,7 @@ async function bootPage({ feeds = {}, stored = null, osDark = true, hash = '' }
   // each file hangs its api on `window`, as the browser loads them
   vm.runInContext(read('city-draw.js'), ctx);
   vm.runInContext(read('street-draw.js'), ctx);
+  vm.runInContext(read('street-card.js'), ctx);
   vm.runInContext(read('street.js'), ctx);
   await window.GovStreetPage.ready;
   const key = (t, e) => (listeners[t] || []).forEach((fn) => fn(e));

package/tests/hall_street_inside.mjs

@@ -414,7 +414,7 @@ async function bootPage({ hash = '', feeds = {}, innerWidth = 1440 } = {}) {
   };
   const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, Date, console, encodeURIComponent, decodeURIComponent, isNaN, isFinite, Map });
   ctx.globalThis = ctx;
-  for (const f of ['city-draw.js', 'street-draw.js', 'street-inside.js', 'street.js']) vm.runInContext(read(f), ctx);
+  for (const f of ['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street.js']) vm.runInContext(read(f), ctx);
   await window.GovStreetPage.ready;
   await new Promise((r) => setTimeout(r, 0));
   const fireWin = (t, e) => (listeners[t] || []).forEach((fn) => fn(e));