@bongos/core 1.21.36 → 1.21.38

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/government_board_withdraw.mjs

@@ -0,0 +1,144 @@
+// tests/government_board_withdraw.mjs — a proposer withdraws their own open
+// sitting before anyone has voted (task 1004564, goal 1000125).
+//
+// WHAT IT GUARDS.
+//   1. THE TWO WALLS IN withdrawItem (board-withdraw.js) — only the builder who OPENED the
+//      sitting, and only while no vote is on it. Each refusal asserts the write
+//      was never reached, so deleting either guard reds a test here (the stub
+//      write would otherwise "succeed").
+//   2. THE SAME WALLS IN THE WRITE ITSELF — db.withdrawBoardItem's WHERE repeats
+//      open + proposer + no vote, so a vote landing between the reads and the
+//      write cannot be withdrawn over. Checked on the SQL the db actually sends.
+//   3. THE MIGRATION — government_026 widens the outcome CHECK to carry
+//      'withdrawn' and 'expired', is idempotent, and never narrows it.
+//
+// DB-free: the db functions (and, for 2, the pool's query) are monkeypatched,
+// the sibling board tests' idiom.
+//
+// Run:  node --test tests/government_board_withdraw.mjs
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+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 db = require(path.join(GOV, 'db.js'));
+const { withdrawItem } = require(path.join(GOV, 'board-withdraw.js'));
+
+const CONSENT = { membership: 'rank:metic', pass_rule: 'consent', window_minutes: 1440, close_early_on_full_turnout: true };
+const openItem = (over = {}) => ({
+  id: '21', subject_type: 'constitutional_amendment', subject_id: '4', opened_by: '42',
+  closed_at: null, outcome: null, expired: false, constitution: CONSENT, ...over,
+});
+
+async function withDb(stubs, fn) {
+  const originals = {};
+  for (const [k, v] of Object.entries(stubs)) { originals[k] = db[k]; db[k] = v; }
+  try { return await fn(); }
+  finally { for (const [k, v] of Object.entries(originals)) db[k] = v; }
+}
+
+// A stub set whose write records whether it was reached.
+function stubs(item, votes = []) {
+  const calls = { write: null };
+  return {
+    calls,
+    db: {
+      getBoardItemForVote: async () => item,
+      getVotesForItem: async () => votes,
+      withdrawBoardItem: async (args) => { calls.write = args; return { ...item, closed_at: '2026-10-04T10:00:00Z', outcome: 'withdrawn' }; },
+    },
+  };
+}
+
+// ── 1. the walls in withdrawItem (board-withdraw.js) ───────────────────────────────────────
+
+test('the proposer withdraws their own open sitting before any vote: closed, outcome withdrawn', async () => {
+  const s = stubs(openItem());
+  const out = await withDb(s.db, () => withdrawItem({ itemId: 21, builderId: 42 }));
+  assert.equal(out.ok, true);
+  assert.equal(out.item.outcome, 'withdrawn');
+  assert.deepEqual(s.calls.write, { itemId: '21', builderId: 42 }, 'the write carries the proposer, so its WHERE can check them too');
+});
+
+test('PROPOSER ONLY: anyone else is refused not_proposer, and the write is never reached', async () => {
+  const s = stubs(openItem({ opened_by: '42' }));
+  const out = await withDb(s.db, () => withdrawItem({ itemId: 21, builderId: 7 }));
+  assert.deepEqual(out, { ok: false, reason: 'not_proposer' });
+  assert.equal(s.calls.write, null, 'a refused withdraw writes nothing');
+});
+
+test('PROPOSER ONLY: a sitting nobody opened (a Full Idea\'s, opened by its grade) cannot be withdrawn', async () => {
+  const s = stubs(openItem({ subject_type: 'full_idea', opened_by: null }));
+  const out = await withDb(s.db, () => withdrawItem({ itemId: 21, builderId: 42 }));
+  assert.deepEqual(out, { ok: false, reason: 'not_proposer' });
+  assert.equal(s.calls.write, null);
+});
+
+test('NO VOTES: once anyone has voted — even the proposer — it is refused votes_cast, and the write is never reached', async () => {
+  for (const voter of ['7', '42']) {
+    const s = stubs(openItem(), [{ id: '1', item_id: '21', voter_id: voter, direction: 'yes' }]);
+    const out = await withDb(s.db, () => withdrawItem({ itemId: 21, builderId: 42 }));
+    assert.deepEqual(out, { ok: false, reason: 'votes_cast' }, `a vote by ${voter} holds the sitting`);
+    assert.equal(s.calls.write, null);
+  }
+});
+
+test('closed, past its clock, missing, or a vote racing the write: each refused with its own reason', async () => {
+  const cases = [
+    [null, 'item_not_found'],
+    [openItem({ closed_at: '2026-10-01T00:00:00Z', outcome: 'returned' }), 'item_closed'],
+    [openItem({ expired: true }), 'vote_window_expired'],
+  ];
+  for (const [item, reason] of cases) {
+    const s = stubs(item);
+    const out = await withDb(s.db, () => withdrawItem({ itemId: 21, builderId: 42 }));
+    assert.deepEqual(out, { ok: false, reason });
+    assert.equal(s.calls.write, null, `${reason} writes nothing`);
+  }
+  // the write's own WHERE matched nothing — a vote landed after the reads
+  const s = stubs(openItem());
+  s.db.withdrawBoardItem = async () => null;
+  const out = await withDb(s.db, () => withdrawItem({ itemId: 21, builderId: 42 }));
+  assert.deepEqual(out, { ok: false, reason: 'item_changed' });
+});
+
+// ── 2. the same walls in the write ───────────────────────────────────────────
+
+test('the write repeats every wall in its WHERE: open, opened by this builder, no vote row', async () => {
+  const { pool } = require(path.join(ROOT, 'src', 'bongos', 'pool'));
+  const original = pool.query;
+  let sent = null;
+  pool.query = async (sql, params) => { sent = { sql: String(sql).replace(/\s+/g, ' '), params }; return { rows: [] }; };
+  try {
+    const out = await db.withdrawBoardItem({ itemId: 21, builderId: 42 });
+    assert.equal(out, null, 'no row matched → null, the sitting untouched');
+  } finally { pool.query = original; }
+  assert.match(sent.sql, /UPDATE government_board_items SET closed_at = now\(\), outcome = 'withdrawn'/);
+  assert.match(sent.sql, /closed_at IS NULL/);
+  assert.match(sent.sql, /opened_by = \$2/);
+  assert.match(sent.sql, /NOT EXISTS \(SELECT 1 FROM government_board_votes WHERE item_id = \$1\)/);
+  assert.deepEqual(sent.params, [21, 42]);
+});
+
+// ── 3. the migration ─────────────────────────────────────────────────────────
+
+test('government_026 widens the outcome CHECK to withdrawn and expired, idempotently, never narrowing it', () => {
+  const sql = fs.readFileSync(path.join(GOV, 'migrations', 'government_026_board_outcome_withdrawn.sql'), 'utf8');
+  const original = fs.readFileSync(path.join(GOV, 'migrations', 'government_003_board_tables.sql'), 'utf8');
+  assert.match(original, /outcome\s+text\s+CHECK \(outcome IN \('passed', 'returned'\)\)/, 'sanity: government_003 is the CHECK being widened');
+  assert.match(sql, /DROP CONSTRAINT IF EXISTS government_board_items_outcome_check;/, 'idempotent: safe to run twice');
+  const check = /ADD CONSTRAINT government_board_items_outcome_check\s+CHECK \(outcome IN \(([^)]*)\)\)/.exec(sql);
+  assert.ok(check, 'the widened CHECK is re-added under the same name');
+  const words = check[1].split(',').map((w) => w.trim().replace(/'/g, ''));
+  assert.deepEqual(words.sort(), ['expired', 'passed', 'returned', 'withdrawn']);
+  // the docket already names both new outcomes, so the CHECK and its words agree
+  const floors = fs.readFileSync(path.join(GOV, 'docket-floors.js'), 'utf8');
+  for (const w of words) assert.match(floors, new RegExp(`\\b${w}:`), `docket-floors OUTCOME_WORDS names '${w}'`);
+  // additive only: nothing in it rewrites a row or drops anything else
+  assert.doesNotMatch(sql.replace(/--.*$/gm, ''), /\b(UPDATE|DELETE|DROP TABLE|DROP COLUMN)\b/i);
+});

package/tests/government_seed.mjs

@@ -45,6 +45,7 @@ const NON_GRANT_MIGRATIONS = new Set([
   'government_018_passed_items_index.sql',         // BV2.R17 passed-item lookup index (task 1004096)
   'government_020_genesis_stage_subject.sql',      // BV2.PS04 genesis_stage board subject CHECK (task 1004429)
   'government_023_decision_rules.sql',             // who decides what: the decision-rules table, matters (task 1004529)
+  'government_026_board_outcome_withdrawn.sql',    // board outcome CHECK widened: withdrawn, expired (task 1004564)
 ]);
 
 // Permission keys RENAMED after the grant migrations that first granted them.

package/tests/hall_street_desk.mjs

@@ -202,6 +202,43 @@ test('a row\'s buttons are the card\'s acts under the board\'s words, and send t
   assert.equal(D.rowsFor('charter', 0, dk, { now: NOW })[0].wait, 'reading…');
 });
 
+// task 1004564: the proposer's own sitting, before anyone has voted, is one row
+// with one button — withdraw — sent to the withdraw route. A vote takes it away.
+test('your own sitting with no vote on it: one row, withdraw, sent to its route; a vote or another viewer takes it away', () => {
+  const ms = [matter({ id: 'board:1', source: 'board', building: 'charter', state: 'moving', ref: { type: 'board_item', id: '1' } })];
+  const dk = docket(ms);
+  const room = (votes) => ({ open: [{ id: '1', subject_type: 'constitutional_amendment', subject: { title: LONG, author_id: '95' }, votes }], closed: [] });
+  const mine = D.rowsFor('charter', 0, dk, { room: room([]), now: NOW, viewerId: '95' })[0];
+  assert.deepEqual(mine.actions.map((a) => [a.key, a.label]), [['withdraw', 'withdraw']]);
+  assert.equal(mine.chips, null, 'withdraw asks nothing: no chips');
+  assert.deepEqual(j(C.request(mine.card, 'withdraw')), { method: 'POST', url: '/api/bongos/government/board/items/1/withdraw', body: {} });
+  assert.match(C.answer(mine.card, 'withdraw', { item_closed: true, outcome: 'withdrawn' }).toast, /^Withdrawn/);
+  assert.equal(C.refusal(409, { error: { code: 'votes_cast' } }), 'Someone has voted on it, so it is the sitting\'s to decide now.');
+  // one vote — anyone's — and the row is the sitting's again
+  const voted = D.rowsFor('charter', 0, dk, { room: room([{ voter_id: '7', direction: 'yes', name: 'Ana' }]), now: NOW, viewerId: '95' })[0];
+  assert.ok(!voted.actions.some((a) => a.key === 'withdraw'), 'no withdraw once a vote is cast');
+  // someone else's sitting never offers it
+  const theirs = D.rowsFor('charter', 0, dk, { room: room([]), now: NOW, viewerId: '7' })[0];
+  assert.ok(!theirs.actions.some((a) => a.key === 'withdraw'), 'only the proposer sees withdraw');
+  // a proposer who may also vote keeps yes first, withdraw second — still two buttons
+  const needs = D.rowsFor('charter', 0, docket([{ ...ms[0], state: 'needs' }]), { room: room([]), now: NOW, viewerId: '95' })[0];
+  assert.deepEqual(needs.actions.map((a) => a.key), ['for', 'withdraw']);
+  // and the line rule holds on every floor with the proposer looking
+  const own = { ...ROOM, open: ROOM.open.map((it) => it.subject_type === 'full_idea' ? it : { ...it, subject: { ...it.subject, author_id: '95' } }) };
+  const desks = everyDesk(docket(longMatters()), { room: own });
+  assert.ok(desks.flatMap((d) => d.rows).some((r) => r.actions.some((a) => a.key === 'withdraw')), 'the stress docket reached a withdraw row');
+  assert.deepEqual(desks.flatMap((d) => D.breaks(d)), []);
+});
+
+test('a withdrawn sitting reads as withdrawn on the card, never as sent back to revise', () => {
+  const dk = docket([matter({ id: 'board:1', source: 'board', building: 'charter', state: 'settled', ref: { type: 'board_item', id: '1' } })]);
+  const room = { open: [], closed: [{ id: '1', subject_type: 'constitutional_amendment', subject: { title: 'Shorter windows', author_id: '95' }, votes: [], closed_at: '2026-10-03T10:00:00.000Z', outcome: 'withdrawn' }] };
+  const cv = (viewerId) => C.model({ docket: dk, key: 'board:1', room, now: NOW, viewerId });
+  assert.equal(cv('95').result, 'You withdrew it before anyone voted.');
+  assert.match(cv('7').result, /^Withdrawn by .* before anyone voted\.$/);
+  assert.equal(cv('95').readOnly, true);
+});
+
 // ── the page: the desk acts in place, and the game layer answers ──────────────
 
 function fakeDom() {

package/tests/hall_tweak_editor.mjs

@@ -635,7 +635,7 @@ try {
     assert.match(HTML, /<body data-page="tweak-editor"[^>]*data-fullscreen-switch/);
     assert.equal((HTML.match(/<h1\b/g) || []).length, 1);
     assert.ok(HTML.indexOf('tweak-editor-lib.js') < HTML.indexOf('tweak-editor.js?'), 'the lib loads first');
-    assert.match(HTML, /shell\.js\?v=2026-10-03-nav/);
+    assert.match(HTML, /shell\.js\?v=2026-10-03-looks/);
     assert.equal(/fonts\.googleapis\.com\/css/.test(HTML), false);
     for (const id of ['tw-bar', 'tw-counter', 'tw-open', 'tw-open-more', 'tw-divider', 'tw-openwrap', 'tw-open-menu', 'tw-open-tab', 'tw-open-split', 'tw-frame', 'tw-frame-view', 'tw-split-close', 'tw-download', 'tw-upload', 'tw-file', 'tw-submit', 'tw-paper', 'tw-doc', 'tw-notice', 'tw-done', 'tw-take', 'tw-pick', 'tw-picks', 'tw-refused', 'tw-refused-title', 'tw-refused-list', 'tw-refused-next', 'tw-refused-download', 'tw-refused-close']) {
       assert.ok(new RegExp(`id="${id}"`).test(HTML), `#${id} is in the markup`);