@bongos/core 1.21.35 → 1.21.37

package/tests/craft_mode_looks.mjs

@@ -0,0 +1,170 @@
+// tests/craft_mode_looks.mjs — each craft mode's look (task 1004495, goal 1000095
+// WA6; direction docs/design/craft-mode-direction.md).
+//
+// Artistry, Ideating and Governing each wear a look: --craft / --craft-on tokens
+// (light + dark twins) in style.css, the header eyebrow beside the page title and
+// the door's scene framed under the brand. Building, Legacy and no mode wear
+// NOTHING — the hall as it always was. These cases run the REAL craft-mode.js over
+// a small DOM and read the REAL style.css, so a look that leaks into Building, a
+// plate that is a second copy of the art, or a colour that loses its contrast reds.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules/hall-ui/public');
+const CRAFT = fs.readFileSync(path.join(HALL, 'craft-mode.js'), 'utf8');
+const CSS = fs.readFileSync(path.join(HALL, 'style.css'), 'utf8');
+
+const LOOKED = ['artistry', 'ideating', 'governing'];
+const WORDS = { artistry: 'the studio · night', ideating: 'the sky', governing: 'the city' };
+
+// A small DOM: enough tree for insertBefore / removeChild / nextSibling to be real.
+function node(tag, id, cls) {
+  const attrs = {};
+  const el = {
+    tagName: tag, id: id || '', className: cls || '', dataset: {}, children: [], parentNode: null,
+    textContent: '', innerHTML: '',
+    setAttribute(k, v) { attrs[k] = String(v); }, getAttribute(k) { return k in attrs ? attrs[k] : null; },
+    hasAttribute(k) { return k in attrs; }, removeAttribute(k) { delete attrs[k]; },
+    get nextSibling() { const sib = this.parentNode && this.parentNode.children; return sib ? sib[sib.indexOf(this) + 1] || null : null; },
+    appendChild(c) { c.parentNode = this; this.children.push(c); return c; },
+    insertBefore(c, ref) {
+      c.parentNode = this;
+      const at = ref ? this.children.indexOf(ref) : -1;
+      if (at === -1) this.children.push(c); else this.children.splice(at, 0, c);
+      return c;
+    },
+    removeChild(c) { this.children.splice(this.children.indexOf(c), 1); c.parentNode = null; return c; },
+    querySelector(sel) { return all(this).find((n) => sel === '.' + n.className) || null; },
+    querySelectorAll() { return []; },
+    addEventListener() {}, classList: { toggle() {} },
+  };
+  return el;
+}
+function all(root) { return root.children.flatMap((c) => [c, ...all(c)]); }
+
+function boot(session = {}) {
+  const sidebar = node('NAV', 'app-sidebar');
+  const brand = sidebar.appendChild(node('DIV', '', 'app-sidebar__brand'));
+  sidebar.appendChild(node('NAV', '', 'app-sidebar__nav'));
+  const topbar = node('DIV', 'app-topbar');
+  topbar.appendChild(node('BUTTON', 'topbar-menu'));
+  const title = topbar.appendChild(node('H2', 'topbar-title'));
+  topbar.appendChild(node('DIV', '', 'topbar-side'));
+  const root = node('HTML');
+  const body = node('BODY');
+  const document = {
+    documentElement: root, body, activeElement: null,
+    getElementById: (id) => [sidebar, topbar, ...all(sidebar), ...all(topbar)].find((n) => n.id === id) || null,
+    querySelectorAll: () => [],
+    createElement: (t) => node(t.toUpperCase()),
+    addEventListener() {}, removeEventListener() {}, dispatchEvent() { return true; },
+  };
+  const mk = (obj) => ({ getItem: (k) => (k in obj ? obj[k] : null), setItem: (k, v) => { obj[k] = String(v); }, removeItem: (k) => { delete obj[k]; } });
+  const window = { localStorage: mk({}), sessionStorage: mk(session), matchMedia: () => ({ matches: false }) };
+  const sandbox = { window, document, CustomEvent: class { constructor(t, i) { this.type = t; Object.assign(this, i); } } };
+  vm.createContext(sandbox);
+  vm.runInContext(CRAFT, sandbox, { filename: 'craft-mode.js' });
+  const craft = window.OTBCraftMode;
+  craft.mount();
+  return {
+    craft, root, sidebar, brand, topbar, title,
+    plates: () => all(sidebar).filter((n) => n.id === 'craft-plate'),
+    marks: () => all(topbar).filter((n) => n.id === 'craft-eyebrow'),
+  };
+}
+
+test('each looked mode frames its own door scene under the brand, and names itself beside the title', () => {
+  const p = boot();
+  for (const m of LOOKED) {
+    p.craft.choose(m);
+    assert.equal(p.plates().length, 1, `${m}: exactly one plate`);
+    const plate = p.plates()[0];
+    assert.equal(p.brand.nextSibling, plate, `${m}: the plate sits right under the brand`);
+    assert.equal(plate.getAttribute('data-plate'), m);
+    assert.equal(plate.getAttribute('aria-hidden'), 'true', 'the plate is decoration');
+    assert.equal(plate.innerHTML, p.craft.artHtml(m), `${m}: the plate IS the picker's door art, not a second copy`);
+    assert.equal(p.marks().length, 1, `${m}: exactly one eyebrow`);
+    assert.equal(p.title.nextSibling, p.marks()[0], `${m}: the eyebrow sits right after the page title`);
+    assert.equal(p.marks()[0].textContent, WORDS[m], `${m}: in the prototype's own words`);
+  }
+});
+
+test('BUILDING, LEGACY AND NO MODE WEAR NO LOOK: no plate, no eyebrow, and switching to them takes the look away', () => {
+  const none = boot();
+  assert.equal(none.root.dataset.craft, undefined);
+  assert.equal(none.plates().length + none.marks().length, 0, 'no mode draws nothing');
+  for (const m of ['building', 'legacy']) {
+    const p = boot({ 'hall-craft': m });
+    assert.equal(p.plates().length + p.marks().length, 0, `${m} at boot draws nothing`);
+    p.craft.choose('governing');
+    assert.equal(p.plates().length, 1);
+    p.craft.choose(m);
+    assert.equal(p.plates().length + p.marks().length, 0, `switching to ${m} removes the plate and the eyebrow`);
+  }
+  assert.deepEqual(Object.keys(none.craft.LOOKS).sort(), [...LOOKED].sort(), 'only the three crafts have a look');
+});
+
+test('the art is drawn once: craft-mode.js has one artHtml and exports it', () => {
+  assert.equal(CRAFT.match(/function artHtml\(/g).length, 1);
+  assert.match(CRAFT, /artHtml: artHtml,/);
+  assert.match(CRAFT, /plate\.innerHTML = artHtml\(mode\);/);
+});
+
+// Every selector in style.css that names a craft mode.
+const CRAFT_SELECTORS = [...CSS.matchAll(/data-craft="([a-z]+)"/g)].map((m) => m[1]);
+
+test('style.css names only the three looked modes — Building and Legacy have no rule at all', () => {
+  assert.ok(CRAFT_SELECTORS.length >= 12, `found ${CRAFT_SELECTORS.length} craft selectors`);
+  for (const m of CRAFT_SELECTORS) assert.ok(LOOKED.includes(m), `a rule names data-craft="${m}"`);
+  assert.doesNotMatch(CSS, /data-craft="(building|legacy)"/);
+  assert.doesNotMatch(CSS, /data-craft\]/, 'no rule matches ANY mode, which would dress Building too');
+});
+
+// The token values, light and dark, read from the stylesheet itself.
+function tokens(selector) {
+  const at = CSS.indexOf(selector + ' {');
+  assert.ok(at !== -1, `style.css has a ${selector} block`);
+  const block = CSS.slice(at, CSS.indexOf('}', at));
+  const get = (name) => (block.match(new RegExp(name + ':\\s*(#[0-9a-f]{6})')) || [])[1];
+  return { craft: get('--craft'), on: get('--craft-on'), bg: get('--bg') };
+}
+function lum(hex) {
+  const c = [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255)
+    .map((v) => (v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4));
+  return 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2];
+}
+function contrast(a, b) { const [x, y] = [lum(a), lum(b)].sort((p, q) => q - p); return (x + 0.05) / (y + 0.05); }
+
+test('every mode colour has a light and a dark twin that keep their contrast', () => {
+  const LIGHT_BG = '#edecee', DARK_BG = '#000000';
+  for (const m of LOOKED) {
+    const light = tokens(`html[data-craft="${m}"]`);
+    const dark = tokens(`html[data-theme="dark"][data-craft="${m}"]`);
+    for (const [k, t] of [['light', light], ['dark', dark]]) {
+      assert.ok(t.craft && t.on, `${m} ${k} sets --craft and --craft-on`);
+    }
+    assert.ok(contrast(light.craft, LIGHT_BG) >= 5.4, `${m} light --craft on paper: ${contrast(light.craft, LIGHT_BG).toFixed(2)}`);
+    assert.ok(contrast(dark.craft, dark.bg || DARK_BG) >= 5.4, `${m} dark --craft on its ground`);
+    assert.ok(contrast(light.on, light.craft) >= 5.8, `${m} light pill text: ${contrast(light.on, light.craft).toFixed(2)}`);
+    assert.ok(contrast(dark.on, dark.craft) >= 5.8, `${m} dark pill text`);
+    assert.equal(light.bg, undefined, `${m}: light keeps the hall's paper ground`);
+  }
+});
+
+test('the shared treatment, the eyebrow and the plate are written as the direction says', () => {
+  const looked = 'html:is([data-craft="artistry"], [data-craft="ideating"], [data-craft="governing"])';
+  for (const target of ['.craft-switch__opt[aria-pressed="true"]', '.nav-item--active', '.nav-item--active::before', '.app-topbar']) {
+    assert.ok(CSS.includes(`${looked} ${target}`), `the looked modes restyle ${target}`);
+  }
+  assert.match(CSS, /@media \(max-width: 640px\) \{ \.craft-eyebrow \{ display: none; \} \}/, 'the eyebrow is hidden on a phone');
+  assert.match(CSS, /\.craft-plate \{[^}]*height: 40px;/, '40px in the closed rail');
+  assert.match(CSS, /\.app-sidebar:focus-within \.craft-plate \{ height: 64px;/, '64px when the rail opens');
+  assert.match(CSS, /html\[data-theme="light"\] \.craft-plate \.craft-art__city \{ filter: invert\(1\) hue-rotate\(180deg\); \}/,
+    'the light city is the dark one inverted, not a second drawing');
+  assert.equal(CSS.match(/prefers-reduced-motion/g).length, 1, 'no second reduced-motion block');
+});

package/tests/craft_mode_nav.mjs

@@ -4,7 +4,7 @@
 // Each craft mode shows only the tabs its craft needs; Legacy mode and no mode
 // show every tab, exactly as before. The owner's rule (2026-10-01): some tabs
 // stay in EVERY mode, Builders first among them, written down as ONE shared list
-// that each mode's list adds to. These cases boot the REAL shell-trail.js +
+// that each mode's list adds to; on 2026-10-03 Collab and Profile joined it. These cases boot the REAL shell-trail.js +
 // craft-mode.js + shell.js and read the sidebar the shell actually rendered, so a
 // tab id that drifts from NAV, or a gate pass that runs after the mode and
 // re-shows a tab, reds here.
@@ -126,13 +126,15 @@ function boot({ session = {}, perms = { 'board.vote.cast': true } } = {}) {
 
 const CRAFTS = ['building', 'artistry', 'ideating', 'governing'];
 
-test('THE ALWAYS-PRESENT LIST: one shared list, Builders first, inside every mode', () => {
+test('THE ALWAYS-PRESENT LIST: one shared list, Builders first, then Collab and Profile, inside every mode', () => {
   const { craft } = boot();
-  assert.equal(craft.ALWAYS_TABS[0], 'roster', 'Builders (NAV id roster) heads the list (owner, 2026-10-01)');
+  assert.deepEqual([...craft.ALWAYS_TABS], ['roster', 'collab', 'profile'],
+    'Builders (NAV id roster) heads the list (owner, 2026-10-01); Collab and Profile join it (owner, 2026-10-03)');
   for (const m of CRAFTS) {
     const tabs = craft.tabsFor(m);
     assert.ok(Array.isArray(tabs), `${m} has a named tab list`);
     for (const id of craft.ALWAYS_TABS) assert.ok(tabs.includes(id), `${m} keeps ${id}`);
+    assert.equal(new Set(tabs).size, tabs.length, `${m} names no tab twice`);
   }
   assert.match(CRAFT, /return own \? ALWAYS_TABS\.concat\(own\) : null;/, 'each list is ALWAYS_TABS plus its own, not a copy of it');
 });
@@ -173,7 +175,7 @@ test('each mode shows its own tabs, and switching updates the nav live', () => {
     p.craft.choose(m);
     assert.equal(p.root.dataset.craft, m);
     assert.deepEqual(new Set(p.showing()), new Set(p.craft.tabsFor(m)), `${m} shows exactly its list`);
-    assert.ok(p.showing().includes('roster'), `Builders stays in ${m}`);
+    for (const id of ['roster', 'collab', 'profile']) assert.ok(p.showing().includes(id), `${id} stays in ${m}`);
     assert.equal(p.headShowing('government'), m === 'governing', `the Government head shows only where its tabs do (${m})`);
   }
   p.craft.choose('legacy');
@@ -185,7 +187,7 @@ test('a mode never shows a tab the gate hid, and a later gate pass keeps the mod
   p.signIn('thetes');
   assert.ok(!p.showing().includes('watch'), 'a thetes in Governing does not get the metic-floored Watch tab');
   assert.ok(!p.headShowing('government'), 'nor its group head');
-  assert.deepEqual(p.showing(), ['blockers', 'board-room', 'roster'], 'what a thetes board member in Governing sees');
+  assert.deepEqual(p.showing(), ['blockers', 'board-room', 'profile', 'collab', 'roster'], 'what a thetes board member in Governing sees');
   p.signIn('archon');
   assert.ok(p.showing().includes('watch'), 'promoted, the gate lets it through and the mode keeps it');
   assert.ok(p.headShowing('government'), 'and its group head comes back with it, which only a mode pass after the gate can know');

package/tests/governor_matter_acts.mjs

@@ -0,0 +1,241 @@
+// tests/governor_matter_acts.mjs — a PASSED matter at Automation, Release,
+// Review or Treasury carries out its act (task 1004561, goal 1000125), the way
+// People already did: after the close commits, through the owning module's act,
+// which calls the same function as that building's direct route. Also the two
+// new desks' server halves (the Treasury budget rows, the Review undo rows) and
+// the budget route's permission pin. DB-free: every write is a stub.
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+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 GOV = path.join(ROOT, 'modules', 'government');
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+const seams = require(path.join(ROOT, 'src', 'module-seams.js'));
+const board = require(path.join(GOV, 'board.js'));
+const decisionBoard = require(path.join(GOV, 'decision-board.js'));
+const db = require(path.join(GOV, 'db.js'));
+const autoActs = require(path.join(ROOT, 'modules', 'autonomy', 'matter-acts.js'));
+const autoDb = require(path.join(ROOT, 'modules', 'autonomy', 'db.js'));
+const lifeActs = require(path.join(ROOT, 'modules', 'lifecycle', 'matter-acts.js'));
+const lifeDb = require(path.join(ROOT, 'modules', 'lifecycle', 'db.js'));
+const doneWhen = require(path.join(ROOT, 'modules', 'lifecycle', 'done-when.js'));
+const doneWhenRoutes = require(path.join(ROOT, 'modules', 'lifecycle', 'routes', 'done-when.js'));
+const gateRoutes = require(path.join(ROOT, 'modules', 'lifecycle', 'routes', 'gate-approvals.js'));
+const lifeDocket = require(path.join(ROOT, 'modules', 'lifecycle', 'governor-docket.js'));
+const buildersRoute = require(path.join(ROOT, 'src', 'bongos', 'routes', 'builders.js'));
+const rrc = require(path.join(ROOT, 'src', 'bongos', 'route-rank-check.js'));
+
+async function stub(obj, stubs, fn) {
+  const originals = {};
+  for (const [k, v] of Object.entries(stubs)) { originals[k] = obj[k]; obj[k] = v; }
+  try { return await fn(); } finally { for (const [k, v] of Object.entries(originals)) obj[k] = v; }
+}
+const sittingRow = (area, decided_by, rule) => ({ area, decided_by, rule, who: null, set_by_item_id: '30' });
+
+// Register every owning module's acts once, as their routers do at boot.
+autoActs.contributeAutomationMatterActs();
+lifeActs.contributeLifecycleMatterActs();
+buildersRoute();
+
+// ── the shape of each act ───────────────────────────────────────────────────
+
+test('each building\'s act is checked strictly when the matter is opened: shape, fields, nothing guessed', () => {
+  const v = decisionBoard.validateMatterAction;
+  assert.deepEqual(v('automation', { type: 'switch_on' }), { ok: true, action: { type: 'switch_on' } });
+  assert.deepEqual(v('automation', { type: 'allow_goal', goal_id: '12' }).action, { type: 'allow_goal', goal_id: 12 });
+  assert.deepEqual(v('release', { type: 'approve_gate', pr: 1500 }).action, { type: 'approve_gate', pr: 1500 });
+  assert.deepEqual(v('release', { type: 'approve_override', request_id: 4 }).action, { type: 'approve_override', request_id: 4 });
+  assert.deepEqual(v('review', { type: 'satisfy_criterion', criterion_id: 9 }).action, { type: 'satisfy_criterion', criterion_id: 9 });
+  assert.deepEqual(v('treasury', { type: 'set_budget', builder_id: 7, monthly_usd: 50 }).action, { type: 'set_budget', builder_id: 7, monthly_usd: 50 });
+  assert.equal(v('treasury', { type: 'set_budget', builder_id: 7, monthly_usd: null }).action.monthly_usd, null, 'null clears the limit');
+  // refusals, each named
+  assert.equal(v('rules', { type: 'switch_on' }).reason, 'action_not_supported_here');
+  assert.equal(v('planning', { type: 'switch_on' }).reason, 'action_not_supported_here');
+  assert.equal(v('automation', { type: 'satisfy_criterion', criterion_id: 9 }).reason, 'bad_action', 'an act from another building');
+  assert.equal(v('automation', { type: 'switch_on', goal_id: 3 }).reason, 'unknown_field');
+  assert.equal(v('automation', { type: 'allow_goal' }).field, 'action.goal_id');
+  assert.equal(v('automation', { type: 'allow_goal', goal_id: 0 }).reason, 'bad_action');
+  assert.equal(v('automation', { type: 'allow_goal', goal_id: true }).reason, 'bad_action');
+  assert.equal(v('treasury', { type: 'set_budget', builder_id: 7, monthly_usd: -1 }).reason, 'bad_action');
+  assert.equal(v('treasury', { type: 'set_budget', builder_id: 7, monthly_usd: '50' }).reason, 'bad_action');
+  assert.equal(v('treasury', { type: 'set_budget', builder_id: 7, monthly_usd: 1e9 }).reason, 'bad_action');
+  assert.equal(v('review', []).reason, 'bad_action');
+  // People is unchanged
+  assert.deepEqual(v('people', { type: 'assign_rank', builder_id: '7', rank_key: 'tester' }).action, { type: 'assign_rank', builder_id: 7, rank_key: 'tester' });
+});
+
+test('every act in the table is carried out by its owning module, and only those', () => {
+  for (const [area, acts] of Object.entries(decisionBoard.MATTER_ACTIONS)) {
+    if (area === 'people') continue; // People acts inside the government module itself
+    for (const type of Object.keys(acts)) assert.ok(decisionBoard.matterActFor(area, type), `${area}.${type} has an act`);
+  }
+  assert.equal(decisionBoard.matterActFor('automation', 'satisfy_criterion'), null);
+});
+
+test('opening a matter whose act no module carries out is refused before anything is filed', async () => {
+  const never = async () => { throw new Error('must not be reached'); };
+  await stub(db, { listDecisionRules: async () => [sittingRow('automation', 'rank:council', 'majority')], createMatter: never, openBoardItem: never }, async () => {
+    await stub(api, { contributions: () => [] }, async () => {
+      const out = await board.openMatter({ area: 'automation', title: 'Switch it on', action: { type: 'switch_on' }, proposedBy: '42' });
+      assert.equal(out.reason, 'action_not_wired');
+    });
+  });
+  let made = null;
+  await stub(db, {
+    listDecisionRules: async () => [sittingRow('treasury', 'rank:council', 'majority')],
+    createMatter: async (a) => { made = a; return { id: '8', ...a }; },
+    openBoardItem: async (a) => ({ id: '40', subject_type: a.subjectType, subject_id: a.subjectId }),
+  }, async () => {
+    const out = await board.openMatter({ area: 'treasury', title: 'Ana: $50 a month', action: { type: 'set_budget', builder_id: 7, monthly_usd: 50 }, proposedBy: '42' });
+    assert.equal(out.ok, true, JSON.stringify(out));
+  });
+  assert.deepEqual(made.action, { type: 'set_budget', builder_id: 7, monthly_usd: 50 });
+});
+
+// ── a passed matter acts; a returned one never does ─────────────────────────
+
+async function closeMatter({ area, action, outcome = 'passed', extraDb = {} }) {
+  const subjectType = `${area}_matter`;
+  const votes = outcome === 'passed' ? [{ voter_id: '9', direction: 'yes' }] : [{ voter_id: '9', direction: 'no', reason_md: 'no' }];
+  const events = [];
+  return stub(api, { emitAsync: async (name, payload) => { events.push([name, payload]); } }, () => stub(db, {
+    getVotesForItem: async () => votes,
+    closeBoardItem: async ({ outcome: o, afterClose }) => {
+      assert.equal(afterClose, null, 'a matter books nothing inside the close');
+      return { id: '40', subject_type: subjectType, subject_id: '8', opened_by: '42', closed_at: 'T', outcome: o };
+    },
+    getMatter: async () => ({ id: '8', area, title: 'A matter', action, proposed_by: '42' }),
+    insertAuthorRatifyKarma: async () => { throw new Error('a matter pays nobody'); },
+    getBoardItemAuthor: async () => '42',
+    ...extraDb,
+  }, async () => {
+    const item = { id: '40', subject_type: subjectType, subject_id: '8', opened_by: '42', closed_at: null, constitution: { membership: 'rank:council', pass_rule: 'first_ratifier', rule: 'first' } };
+    return { out: await board.closeItem(item), events };
+  }));
+}
+
+test('a passed Automation matter switches the fence and allows a goal, as the proposer, through the route\'s own writes', async () => {
+  const writes = [];
+  await stub(autoDb, {
+    setFenceEnabled: async (a) => { writes.push(['fence', a]); return { enabled: a.enabled }; },
+    allowGoal: async (a) => { writes.push(['allow', a]); return { goal_id: a.goalId }; },
+  }, async () => {
+    const on = await closeMatter({ area: 'automation', action: { type: 'switch_on' } });
+    assert.equal(on.out.outcome, 'passed');
+    assert.deepEqual(on.out.acted, { area: 'automation', matter_id: '8', action: 'switch_on', done: true });
+    const passed = on.events.find(([n]) => n === 'board.matter.passed');
+    assert.equal(passed[1].acted, true);
+    await closeMatter({ area: 'automation', action: { type: 'switch_off' } });
+    await closeMatter({ area: 'automation', action: { type: 'allow_goal', goal_id: 12 } });
+  });
+  assert.deepEqual(writes.map(([k, a]) => [k, a.enabled ?? a.goalId, a.builderId]), [['fence', true, '42'], ['fence', false, '42'], ['allow', 12, '42']]);
+  assert.match(writes[0][1].reason, /passed Automation matter \(matter 8\)/);
+});
+
+test('a RETURNED matter carries out nothing', async () => {
+  let wrote = false;
+  await stub(autoDb, { setFenceEnabled: async () => { wrote = true; return {}; } }, async () => {
+    const back = await closeMatter({ area: 'automation', action: { type: 'switch_on' }, outcome: 'returned' });
+    assert.equal(back.out.outcome, 'returned');
+    assert.equal(back.out.acted, undefined);
+  });
+  assert.equal(wrote, false);
+});
+
+test('a passed Review matter signs the criterion off by override, once', async () => {
+  const signed = [];
+  await stub(doneWhenRoutes, { satisfyByOverride: async (a) => { signed.push(a); return { updated: {}, goalResult: {} }; } }, () =>
+    stub(doneWhen, { getCriterion: async (id) => ({ id, satisfied: id === 10 }) }, async () => {
+      const out = (await closeMatter({ area: 'review', action: { type: 'satisfy_criterion', criterion_id: 9 } })).out;
+      assert.equal(out.acted.done, true);
+      const again = (await closeMatter({ area: 'review', action: { type: 'satisfy_criterion', criterion_id: 10 } })).out;
+      assert.deepEqual([again.outcome, again.acted.done, again.acted.reason], ['passed', false, 'already_satisfied'], 'a refusal leaves the decision standing');
+    }));
+  assert.equal(signed.length, 1);
+  assert.equal(signed[0].criterionId, 9);
+  assert.equal(signed[0].signerId, '42');
+  assert.match(signed[0].reason, /passed Review matter/);
+});
+
+test('a passed Release matter approves an override or clears a gate; a request already decided is said, not thrown', async () => {
+  const calls = [];
+  await stub(lifeDb, {
+    decideOverrideRequest: async (a) => {
+      calls.push(['override', a]);
+      if (a.requestId === 5) throw Object.assign(new Error('closed'), { code: 'REQUEST_NOT_OPEN' });
+      return {};
+    },
+  }, () => stub(gateRoutes, { approveGatePr: async (a) => { calls.push(['gate', a]); return a.number === 2 ? { ok: false, code: 'pr_not_open' } : { ok: true, body: {} }; } }, async () => {
+    assert.equal((await closeMatter({ area: 'release', action: { type: 'approve_override', request_id: 4 } })).out.acted.done, true);
+    assert.equal((await closeMatter({ area: 'release', action: { type: 'approve_override', request_id: 5 } })).out.acted.reason, 'request_not_open');
+    assert.equal((await closeMatter({ area: 'release', action: { type: 'approve_gate', pr: 1500 } })).out.acted.done, true);
+    assert.equal((await closeMatter({ area: 'release', action: { type: 'approve_gate', pr: 2 } })).out.acted.reason, 'pr_not_open');
+  }));
+  assert.deepEqual(calls[0], ['override', { requestId: 4, archonId: '42', decision: 'approve', note: 'A passed Release matter (matter 8) decided it.' }]);
+  assert.equal(calls[2][1].number, 1500);
+});
+
+test('a passed Treasury matter sets the limit through the same write as PATCH /builders/:id/budget', async () => {
+  const set = [];
+  const reward = seams.resolveOptional('reward');
+  const fake = { setBuilderMonthlyBudget: async (id, usd) => { set.push([id, usd]); return id === 404 ? null : { id, monthly_budget_usd: usd }; } };
+  await stub(seams, { resolveOptional: (name, fb) => (name === 'reward' ? fake : (reward && fb)) }, async () => {
+    assert.equal((await closeMatter({ area: 'treasury', action: { type: 'set_budget', builder_id: 7, monthly_usd: 50 } })).out.acted.done, true);
+    assert.equal((await closeMatter({ area: 'treasury', action: { type: 'set_budget', builder_id: 404, monthly_usd: null } })).out.acted.reason, 'builder_not_found');
+  });
+  assert.deepEqual(set, [[7, 50], [404, null]]);
+});
+
+test('an act that throws leaves the decision passed and says it did not run', async () => {
+  await stub(autoDb, { setFenceEnabled: async () => { throw new Error('db down'); } }, async () => {
+    const { out, events } = await closeMatter({ area: 'automation', action: { type: 'switch_on' } });
+    assert.equal(out.outcome, 'passed');
+    assert.deepEqual([out.acted.done, out.acted.reason], [false, 'act_failed']);
+    assert.equal(events.find(([n]) => n === 'board.matter.passed')[1].acted, false);
+  });
+});
+
+test('a stored act that no longer validates is not carried out', async () => {
+  let wrote = false;
+  await stub(autoDb, { allowGoal: async () => { wrote = true; } }, async () => {
+    const { out } = await closeMatter({ area: 'automation', action: { type: 'allow_goal', goal_id: -3 } });
+    assert.deepEqual([out.acted.done, out.acted.reason], [false, 'bad_action']);
+  });
+  assert.equal(wrote, false);
+});
+
+// ── the two desks' server halves ────────────────────────────────────────────
+
+test('Treasury desk: a row per builder, their limit as the fact, the other limits one tap each', () => {
+  const rows = buildersRoute.budgetDeskRows([{ id: 7, display_name: 'Ana', github_login: 'ana', monthly_budget_usd: '100.00' }, { id: 8, github_login: 'kai', monthly_budget_usd: null }]);
+  assert.equal(rows[0].fact, '$100 a month');
+  assert.deepEqual(rows[0].acts[0].options.map((o) => o.key), ['25', '50', '250', 'none']);
+  assert.ok(rows[0].acts[0].options.every((o) => o.label.length <= 16), 'every chip fits the line rule');
+  assert.equal(rows[1].fact, 'no limit');
+  assert.deepEqual(rows[1].acts[0].options.map((o) => o.key), ['25', '50', '100', '250']);
+  assert.deepEqual(rows[0].ref, { type: 'builder_budget', id: 7 });
+});
+
+test('Review desk: only signed-off promises, newest first, each undone with a one-tap reason', () => {
+  const rows = lifeDocket.signedDeskRows([
+    { id: 1, criterion_md: 'Old', satisfied: true, checked_at: '2026-09-01T00:00:00Z' },
+    { id: 2, criterion_md: 'New', satisfied: true, checked_at: '2026-10-02T00:00:00Z' },
+    { id: 3, criterion_md: 'Open', satisfied: false, checked_at: null },
+  ]);
+  assert.deepEqual(rows.map((r) => r.name), ['New', 'Old']);
+  assert.equal(rows[0].acts[0].key, 'unsign');
+  assert.ok(rows[0].acts[0].options.every((o) => o.label.length <= 16));
+});
+
+test('the desks are read under their routes\' own atoms, and the budget route is pinned', () => {
+  const desks = api.contributions('governor.docket').filter((c) => c && (c.desk === 'treasury.budgets' || c.desk === 'review.signed'));
+  const gates = Object.fromEntries(desks.map((c) => [c.desk, c.gate && c.gate.permission]));
+  assert.equal(gates['treasury.budgets'], 'builder.budget.set');
+  assert.equal(rrc.EXPECTED_RANKS['PATCH /builders/:id/budget'], 'perm:builder.budget.set');
+  const life = rrc.MODULE_EXPECTED_RANKS.lifecycle || Object.values(rrc.MODULE_EXPECTED_RANKS).find((m) => m['POST /done-when/:criterionId/unsatisfy']);
+  assert.equal(life['POST /done-when/:criterionId/unsatisfy'], 'perm:criterion.unsatisfy');
+});