@bongos/core 1.21.37 → 1.21.39

package/modules/government/board-withdraw.js

@@ -0,0 +1,38 @@
+'use strict';
+
+// modules/government/board-withdraw.js — a proposer withdraws their own open
+// board sitting before anyone has voted (task 1004564). Its own file because
+// board.js sits at the size ratchet's line cap; it reads and writes through the
+// same db slice and announces the close through board.js's own close event, so
+// the Discord mirror and every other listener see one shape for every close.
+
+const db = require('./db');
+const board = require('./board');
+
+// The proposer may take back a sitting they opened, but only while nobody has
+// voted on it: once a vote is cast the sitting belongs to the voters too, and
+// pulling it would erase their say. "Proposer" is the person who OPENED it
+// (opened_by) — a Full Idea's sitting opens itself on its grade, so it has no
+// proposer here and cannot be withdrawn this way. An item past its clock is
+// refused as well: the sweep is about to decide it (under consent, silence
+// passes it), and a withdraw then would dodge that outcome.
+//
+// Each refusal is read first so the caller gets a reason; the write itself
+// repeats every guard in its WHERE (db.withdrawBoardItem), so a vote that
+// arrives between the reads and the write leaves the sitting open
+// ('item_changed') rather than withdrawn over a cast vote.
+async function withdrawItem({ itemId, builderId } = {}) {
+  const item = await db.getBoardItemForVote(Number(itemId));
+  if (!item) return { ok: false, reason: 'item_not_found' };
+  if (item.closed_at) return { ok: false, reason: 'item_closed' };
+  if (item.opened_by == null || String(item.opened_by) !== String(builderId)) return { ok: false, reason: 'not_proposer' };
+  if (item.expired) return { ok: false, reason: 'vote_window_expired' };
+  const votes = await db.getVotesForItem(item.id);
+  if (votes.length > 0) return { ok: false, reason: 'votes_cast' };
+  const closed = await db.withdrawBoardItem({ itemId: item.id, builderId });
+  if (!closed) return { ok: false, reason: 'item_changed' };
+  await board.emitItemClosed(closed, { cause: 'withdrawn', votes: [] });
+  return { ok: true, item: closed };
+}
+
+module.exports = { withdrawItem };

package/modules/government/board.js

@@ -1486,6 +1486,7 @@ module.exports = {
   passPayload,
   closeItem,
   maybeCloseAfterVote,
+  emitItemClosed,
   latestRejectionForIdea,
   boardPassForIdea,
   boardPassedIdeaIds,

package/modules/government/db.js

@@ -393,6 +393,25 @@ async function getVotesForItem(itemId) {
   return rows;
 }
 
+// The withdraw write (task 1004564) — a proposer takes back their own open
+// sitting before anyone has voted. EVERY guard is in the WHERE, not only in
+// withdrawItem (board-withdraw.js)'s reads: still open, opened by this builder, and no vote
+// row on it. So a vote that lands between the caller's read and this write
+// makes it match nothing (null), and the sitting stays open — the same
+// single-winner shape as closeBoardItem.
+async function withdrawBoardItem({ itemId, builderId }) {
+  const { rows } = await pool.query(
+    `UPDATE government_board_items
+        SET closed_at = now(), outcome = 'withdrawn'
+      WHERE id = $1 AND closed_at IS NULL
+        AND opened_by = $2
+        AND NOT EXISTS (SELECT 1 FROM government_board_votes WHERE item_id = $1)
+      RETURNING *`,
+    [itemId, builderId],
+  );
+  return rows[0] || null;
+}
+
 // The close write — STRUCTURALLY SINGLE-WINNER: WHERE closed_at IS NULL means
 // two concurrent closers (a racing vote and the expiry sweep) write exactly one
 // outcome; the loser gets null and reads the winner's row back if it cares.
@@ -881,6 +900,7 @@ module.exports = {
   insertAuthorRatifyKarma,
   getVotesForItem,
   closeBoardItem,
+  withdrawBoardItem,
   getIdeaCompleteness,
   getExpiredOpenBoardItems,
   getLatestReturnedItemWithObjection,

package/modules/government/migrations/government_026_board_outcome_withdrawn.sql

@@ -0,0 +1,29 @@
+-- government_026_board_outcome_withdrawn.sql — a board sitting may also end
+-- 'withdrawn' or 'expired' (task 1004564, goal 1000125).
+--
+-- WHAT IT IS. government_003 limited government_board_items.outcome to 'passed'
+-- and 'returned'. A proposer may now withdraw their own open sitting before
+-- anyone has voted (POST /government/board/items/:itemId/withdraw), which closes
+-- it with outcome 'withdrawn'. 'expired' is added in the same statement because
+-- the docket already names it (modules/government/docket-floors.js
+-- OUTCOME_WORDS) — nothing writes it yet; allowing it now saves a second
+-- constraint swap later.
+--
+-- Additive only: the CHECK is WIDENED. Every row the old CHECK allowed ('passed',
+-- 'returned', NULL for an open item) is still allowed, so no row can fail it and
+-- no data changes. The closed-consistency CHECK (closed_at and outcome set
+-- together) is untouched.
+-- Idempotent: DROP CONSTRAINT IF EXISTS + ADD, the government_017/020 idiom.
+-- The constraint name is the one Postgres gave government_003's inline CHECK.
+-- Approved by the owner on 2026-10-04 — the only schema change that task carries.
+
+BEGIN;
+
+ALTER TABLE government_board_items
+  DROP CONSTRAINT IF EXISTS government_board_items_outcome_check;
+
+ALTER TABLE government_board_items
+  ADD CONSTRAINT government_board_items_outcome_check
+  CHECK (outcome IN ('passed', 'returned', 'withdrawn', 'expired'));
+
+COMMIT;

package/modules/government/routes/government.js

@@ -25,6 +25,7 @@ const db = require('../db');
 const sessionScopes = require('../session-scopes');
 const boardMembership = require('../board-membership');
 const board = require('../board');
+const boardWithdraw = require('../board-withdraw');
 const recommendations = require('../recommendations');
 const docket = require('../docket');
 // task 1003208: structured logging (pino via the doorway) — was console.*.
@@ -807,6 +808,31 @@ module.exports = function buildGovernmentRouter() {
     }
   });
 
+  // rank: perm board.item.open — withdraw your own open sitting (task 1004564).
+  // The same atom as putting one up: taking it back is the proposer's half of
+  // the same act. The atom is only the coarse gate; the walls are in
+  // board-withdraw.js and repeated in its write — only the builder who opened
+  // the sitting, only while it is open and inside its clock, and only before
+  // anyone has voted. It closes with outcome 'withdrawn' (government_026).
+  router.post('/government/board/items/:itemId/withdraw', api.requireBuilder, api.requirePermission('board.item.open'), async (req, res) => {
+    const itemId = parseId(req, res, { param: 'itemId', code: 'bad_item_id', positiveInt: true });
+    if (itemId === null) return;
+    try {
+      const out = await boardWithdraw.withdrawItem({ itemId, builderId: req.builder.id });
+      if (!out.ok) {
+        const status =
+          out.reason === 'item_not_found' ? 404 :
+          out.reason === 'not_proposer' ? 403 :
+          409; // item_closed / vote_window_expired / votes_cast / item_changed
+        return res.fail(out.reason, status, { item_id: itemId });
+      }
+      res.json({ ok: true, item_closed: true, outcome: out.item.outcome, item: out.item });
+    } catch (err) {
+      log.error('[gds] POST /government/board/items/:itemId/withdraw', err);
+      res.fail('withdraw_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
   // rank: perm board.vote.cast — cast a vote on an open board item (R08 of goal
   // 1000069, ADR 0175). The atom FLOORS AT XENOS deliberately (the R04 carry-
   // note): the permission is only the coarse gate, and the real wall is the

package/modules/hall-ui/public/street-card.js

@@ -325,6 +325,7 @@
     if (item.closed_at) {
       cv.readOnly = true;
       if (item.outcome === 'passed') cv.result = 'Passed ' + b.forN + '–' + b.againstN + '. In force from ' + str(item.closed_at).slice(0, 10) + '.';
+      else if (item.outcome === 'withdrawn') cv.result = b.isAuthor ? 'You withdrew it before anyone voted.' : 'Withdrawn by ' + (proposer || 'its author') + ' before anyone voted.';
       else if (b.isAuthor && cv.counsel && cv.counsel.revise) { cv.result = 'It came back to you.'; cv.readOnly = false; cv.reviseForm = { text: words, label: kind === 'matter' ? 'the matter, in your words' : 'why, in your words' }; }
       else cv.result = 'It went back to ' + (proposer || 'its author') + ' to revise.';
       return cv;
@@ -346,6 +347,16 @@
       cv.result = m.state === 'needs' ? 'Read the idea in the Board Room and vote there, with its sections in front of you.' : 'Not yours to vote on.';
       return cv;
     }
+    // task 1004564: the proposer may withdraw their own sitting until anyone has
+    // voted (POST .../withdraw; the server holds the same two walls). If they may
+    // also vote on it, withdraw takes the second place: an objection to your own
+    // proposal is a withdraw said the long way.
+    var withdrawable = b.isAuthor && !((item.votes || []).length);
+    if (withdrawable) {
+      cv.actions = b.youOpen ? [act('for', 'vote for', 'primary'), act('withdraw', 'withdraw', 'quiet')] : [act('withdraw', 'withdraw', 'quiet')];
+      cv.result = 'Yours. No one has voted yet, so you can still withdraw it.';
+      return cv;
+    }
     if (b.youOpen) {
       cv.actions = [act('for', 'vote for', 'primary'), act('object', 'object', 'quiet')];
       cv.textActions = [act('abstain', 'abstain', 'text')];
@@ -575,6 +586,7 @@
     if (s.itemId != null) {
       if (key === 'for') return post('/government/board/items/' + enc(s.itemId) + '/votes', { direction: 'yes' });
       if (key === 'object') return post('/government/board/items/' + enc(s.itemId) + '/votes', { direction: 'no', reason_md: str(inp.reason).trim(), section_key: str(inp.section) });
+      if (key === 'withdraw') return post('/government/board/items/' + enc(s.itemId) + '/withdraw', {});
       if (key === 'revise') {
         var text = str(inp.text).trim();
         if (s.kind === 'amendment') return post('/government/board/items', { subject_type: 'constitutional_amendment', proposal: s.proposed, rationale_md: text });
@@ -629,6 +641,7 @@
       return { toast: r.already_voted ? 'Your vote was already on the record.' : 'Your yes is on the record.', building: b, kind: 'light', close: false };
     }
     if (key === 'object') return { toast: r.item_closed ? 'Your objection is on the record. It goes back to its author to revise.' : 'Your objection is on the record.', building: b, kind: 'settle', close: false };
+    if (key === 'withdraw') return { toast: 'Withdrawn. The sitting is closed and nothing was decided.', building: b, kind: 'settle', close: true };
     if (key === 'abstain') return { toast: 'Noted. Nothing goes on the record, and it still waits for your vote until it closes.', building: null, kind: null, close: true };
     if (key === 'revise') return { toast: 'Revised. It sits again on the new wording.', building: b, kind: 'light', close: true };
     if (key === 'hold') return { toast: 'Held. It waits for you.', building: null, kind: null, close: true };
@@ -678,6 +691,9 @@
     backup_already_running: 'A backup is already running.',
     intent_conflict: 'Another core run is going. Try again when it settles.',
     criterion_needs_recording: 'This one needs a recording. Sign it off on its goal page.',
+    not_proposer: 'Only the person who put it up may withdraw it.',
+    votes_cast: 'Someone has voted on it, so it is the sitting\'s to decide now.',
+    item_changed: 'Someone voted just now, so it stays with the sitting.',
   };
   function refusal(status, body) {
     var e = body && body.error ? body.error : {};

package/modules/hall-ui/public/street-desk.js

@@ -119,6 +119,8 @@
     decide: 'decide', ratify: 'ratify', ratify_goal: 'make goal', up: 'move up', down: 'move down',
     // task 1004561: a builder's monthly limit, and a sign-off undone
     budget: 'set limit', unsign: 'undo',
+    // task 1004564: the proposer takes back their own sitting before any vote
+    withdraw: 'withdraw',
   });
   // What a row's chips ask, per act (a reason or an option is one tap, never text).
   const ASKS = Object.freeze({ budget: 'monthly limit', unsign: 'why', decide: 'pick one', ratify_goal: 'which version', check: 'check', take_core: 'move to', rot: 'stale after', module_off: 'sure', invite: 'their GitHub name', object: 'why', force: 'why', switch_off: 'why', pause: 'why', deactivate: 'why', signoff: 'confirm', allow: 'which goal', tier: 'which tier', give: 'to whom', take: 'from whom' });

package/modules/hall-ui/public/street-inside.js

@@ -34,8 +34,6 @@
 //    the seat is drawn empty and says so, and the rule is the building's own
 //    matters' rule, else the design's default, named as the default
 //    (holderOf()).
-//  * On the table here: the docket's matters at this building. Each row opens
-//    the short card (GovStreet.cardFor(); task 1004528 makes it act).
 //  * The record: the building's history (docket.history: rulings, amendments,
 //    sign-offs, releases, payouts) and its matters, filed by month, one drawer
 //    a month, newest first.
@@ -176,7 +174,7 @@
   //   key  one of the nine civic keys
   //   b    the building, in civicInfo()'s shape: { group, name, holds, seats,
   //        who, rule, how, cap, growth, floors: [{ name, line, count, status,
-  //        lines }], record: [{ label, items }], onFile, table: [rows], annex }
+  //        lines }], record: [{ label, items }], onFile, annex }
   //   st   { floor, drawer, picks, vacant, reviewHeld, evening }
   // Everything the prototype's template binds, as data, plus `selFloor` and
   // `selDrawer`. The geometry is the prototype's to the pixel.
@@ -261,7 +259,6 @@
         : { key: s, init: s, bg: T.seatFor.bg, fg: T.seatFor.fg, border: 'none' };
     const g = City.glyph(b.rule, 9, 9, 16);
     const pct = Math.round(occ / cap * 100);
-    const table = Array.isArray(b.table) ? b.table : [];
     const f = b.floors[selFloor];
     const quietWord = f && QUIET[f.status] !== undefined ? ' · ' + (f.status === 'proposed' ? 'proposed' : QUIET[f.status]) : '';
     return {
@@ -269,7 +266,6 @@
       seats: b.seats.map(seatOf), whoText: b.who, gf: g.fill, gl: g.line, howText: b.how,
       fill: pct, fillColor: pct >= 80 ? '#fb9569' : T.line,
       growth: (vacant ? 'Not built yet. ' : occ + ' of ' + cap + ' floors in use. ') + b.growth,
-      hasTable: table.length > 0, table: table,
       openKicker: 'floor ' + (selFloor + 1) + (f && f.status === 'pending' ? ' · being decided' : quietWord),
       sym: f ? Object.assign(symbolPath(floorSymbol(f.name)), { c: '#fb9569' }) : { d: '', f: '', c: 'none' },
       flipA: ((st.picks || 0) % 2) === 0, flipB: ((st.picks || 0) % 2) === 1,
@@ -528,11 +524,6 @@
       if (!vacant && spec[2] && spec[2].held) fl.name = spec[2].held;
       return fl;
     });
-    const order = { needs: 0, moving: 1, settled: 2 };
-    const table = matters.slice().sort((a, b) => order[stateOf(a)] - order[stateOf(b)]).map((m) => {
-      const s = stateOf(m), when = S.whenWord(m.deadline, c.now);
-      return { key: String(m.id), matter: String(m.id), label: String(m.title || m.short || ''), status: s === 'needs' ? 'needs you' + (when ? ' · ' + when : '') : s === 'moving' ? 'moving' + (when ? ' · ' + when : '') : (when || 'settled'), state: s, color: s === 'needs' ? 'accent' : 'ink' };
-    });
     const history = docket && Array.isArray(docket.history) ? docket.history.filter((x) => x && x.building === key) : [];
     const record = recordOf(matters, c.now, history);
     return {
@@ -541,7 +532,7 @@
       growth: vacant ? plan.vacantGrowth : plan.growth,
       floors: floors, record: record,
       onFile: !docket ? 'the docket could not be read just now' : matters.length ? matters.length + (matters.length === 1 ? ' matter' : ' matters') + ' on the docket' + (history.length ? ' · ' + history.length + ' on the record' : '') : history.length ? history.length + ' on the record' : 'nothing on file yet',
-      table: table, annex: !vacant && floors.length >= plan.cap ? plan.annex : null, vacant: vacant,
+      annex: !vacant && floors.length >= plan.cap ? plan.annex : null, vacant: vacant,
     };
   }
 
@@ -558,9 +549,8 @@
     const docket = o.docket && Array.isArray(o.docket.matters) ? o.docket : null;
     const evening = !!docket && !(docket.counts && Number(docket.counts.needs) > 0);
     const bv = buildingView(T, o.key, b, { floor: o.floor, drawer: o.drawer, picks: o.picks, vacant: b.vacant, reviewHeld: !b.vacant, evening: evening, cleared: o.cleared });
-    bv.table = bv.table.map((r) => Object.assign({}, r, { color: r.color === 'accent' ? T.accentText : T.ink }));
     bv.key = o.key; bv.mode = mode; bv.vacant = b.vacant;
-    bv.label = b.name + ' in section: ' + b.floors.length + ' of ' + bv.cap + ' floors in use' + (bv.hasTable ? ', ' + bv.table.length + ' on the table' : '') + '.';
+    bv.label = b.name + ' in section: ' + b.floors.length + ' of ' + bv.cap + ' floors in use.';
     return bv;
   }
 

package/modules/hall-ui/public/street.css

@@ -195,7 +195,7 @@ html[data-fullscreen="on"] .street-top { padding-right: 184px; }
    on the hall's tokens. Under 900 px the artboard gives way to a column: the
    drawing in its own sideways strip, the panel below it. */
 .inside { position: absolute; inset: 0; display: flex; overflow-x: auto; overflow-y: auto; background: var(--bg); }
-.inside[hidden], .inside-annex[hidden], .inside-dhead[hidden], .inside-legend[hidden], .inside-table[hidden], .inside-open[hidden], .inside-note[hidden], .inside-panel[hidden], .inside-more[hidden] { display: none; }
+.inside[hidden], .inside-annex[hidden], .inside-dhead[hidden], .inside-legend[hidden], .inside-open[hidden], .inside-note[hidden], .inside-panel[hidden], .inside-more[hidden] { display: none; }
 .inside-sizer { position: relative; margin: auto; flex: none; overflow: hidden; }
 .inside-board { position: absolute; left: 0; top: 0; width: 1440px; height: 708px; transform-origin: 0 0; transform: scale(var(--inside-scale, 1)); color: var(--ink); }
 .inside-head { position: absolute; left: 32px; top: 16px; display: flex; align-items: center; gap: 16px; z-index: 2; }
@@ -265,10 +265,6 @@ html[data-fullscreen="on"] .street-top { padding-right: 184px; }
 .inside-meter__fill { height: 6px; width: 0; background: color-mix(in srgb, var(--ink) 30%, var(--bg)); }
 .inside-meter__fill--full { background: var(--accent); }
 .inside-meter__line { font-size: 13px; color: var(--ink-soft); line-height: 1.45; }
-.inside-table { display: flex; flex-direction: column; gap: 8px; }
-.inside-row { display: flex; justify-content: space-between; align-items: center; gap: 12px; width: 100%; background: none; border: 0; border-top: 1px solid var(--street-rule); padding: 10px 0; cursor: pointer; font-family: var(--font-body); font-size: 15px; text-align: left; color: var(--ink); }
-.inside-row--needs { color: var(--street-accent-text); }
-.inside-row__status { font-size: 12.5px; color: var(--ink-faint); white-space: nowrap; }
 
 /* the chosen floor, its sign large; the block re-enters on every pick */
 .inside-open { display: flex; flex-direction: column; gap: 10px; }
@@ -362,7 +358,7 @@ html[data-fullscreen="on"] .street-top { padding-right: 184px; }
 .inside-ditem { display: flex; justify-content: space-between; gap: 14px; padding: 8px 0; border-top: 1px solid var(--street-rule); font-size: 14px; line-height: 1.4; }
 .inside-ditem__meta { color: var(--ink-faint); white-space: nowrap; }
 
-.inside-back:focus-visible, .inside-textbtn:focus-visible, .inside-row:focus-visible, .inside-drawer:focus-visible, .inside-item:focus-visible, .inside-more:focus-visible { outline: 2px solid var(--accent); outline-offset: 3px; }
+.inside-back:focus-visible, .inside-textbtn:focus-visible, .inside-drawer:focus-visible, .inside-item:focus-visible, .inside-more:focus-visible { outline: 2px solid var(--accent); outline-offset: 3px; }
 .inside-floor:focus-visible { outline: 2px solid var(--accent); outline-offset: -3px; }
 .inside-name:focus { outline: none; }
 .inside-name:focus-visible { outline: 2px solid var(--accent); outline-offset: 4px; }

package/modules/hall-ui/public/street.html

@@ -166,10 +166,6 @@
           <span class="inside-meter__line" id="insideGrowth"></span>
         </div>
       </div>
-      <div class="inside-table" id="insideTableWrap" hidden>
-        <span class="street-label">on the table here</span>
-        <div id="insideTable"></div>
-      </div>
       <div class="inside-open" id="insideOpenA"></div>
       <div class="inside-open" id="insideOpenB" hidden></div>
       <div class="inside-record">

package/modules/hall-ui/public/street.js

@@ -493,19 +493,6 @@
     var fill = $('insideFill');
     if (fill) { fill.style.width = bv.fill + '%'; fill.className = 'inside-meter__fill' + (bv.fill >= 80 ? ' inside-meter__fill--full' : ''); }
     setText('insideGrowth', bv.growth);
-    show('insideTableWrap', bv.hasTable);
-    var table = $('insideTable'); clear(table);
-    bv.table.forEach(function (r) {
-      var b = node('button', 'inside-row' + (r.state === 'needs' ? ' inside-row--needs' : ''));
-      b.setAttribute('type', 'button');
-      b.setAttribute('data-matter', r.matter);
-      b.setAttribute('aria-controls', 'streetCard');
-      b.setAttribute('aria-expanded', view.open === r.matter ? 'true' : 'false');
-      b.appendChild(node('span', 'inside-row__label', r.label));
-      b.appendChild(node('span', 'inside-row__status', r.status));
-      b.addEventListener('click', function () { openCard(r.matter, b); });
-      if (table) table.appendChild(b);
-    });
     // the chosen floor: two blocks that take turns, so the block re-enters on every pick
     var on = $(bv.flipA ? 'insideOpenA' : 'insideOpenB'), off = $(bv.flipA ? 'insideOpenB' : 'insideOpenA');
     if (off) { off.hidden = true; clear(off); }
@@ -751,7 +738,7 @@
     pause: 'paused', resume: 'resumed', tier: 'new tier', deactivate: 'deactivated', give: 'gave', take: 'took back',
     check: 'checked', rot: 'set', module_on: 'turned on', module_off: 'turned off', backup: 'backed up', invite: 'invited',
     decide: 'decided', ratify: 'ratified', ratify_goal: 'made a goal of',
-    budget: 'set the limit of', unsign: 'undid',
+    budget: 'set the limit of', unsign: 'undid', withdraw: 'withdrew',
   };
   // One act from a row: checked, sent through the card's own request (the
   // server's permission checks decide), then the row clears, the floor counts
@@ -1104,12 +1091,10 @@
     // The pins were redrawn, so focus goes back to the new button for the same matter.
     if (restore !== false && was && was.getAttribute) {
       var key = was.getAttribute('data-matter');
-      // the pins and the table rows were redrawn: focus the new control for the same matter
+      // the pins were redrawn: focus the new pin for the same matter
       // .children is an HTMLCollection, which concat does not spread: copy it first
       var list = function (id) { var el = $(id); return el && el.children ? Array.prototype.slice.call(el.children) : []; };
-      var pins = list('streetPins');
-      var rows = list('insideTable');
-      var pool = view.inside ? [].concat(rows, pins) : [].concat(pins, rows);
+      var pool = list('streetPins');
       for (var i = 0; i < pool.length; i++) {
         if (pool[i].getAttribute('data-matter') === key) { if (pool[i].focus) pool[i].focus(); break; }
       }

package/modules/hall-ui/records/governor-street.md

@@ -21,12 +21,12 @@ Built 1:1 on `buildingView()` and `districtView()` of the same prototype. The in
 Files: `street-inside.js` (`window.GovInside`, node-require-safe, pure): the prototype's `crown()`, `workItem()`, `floorSymbol()`, `symbolPath()` (all forty symbols) and the section drawing itself, verbatim, plus the real-data adapters. `street.js` builds the nodes; `street.css` carries the interior's styles under the `inside-` prefix.
 
 - **The building in section.** Every storey a real floor (slab, cut walls with glazing, three lamps, a partition with a doorway, the framed sign with the floor's symbol, its name and state lettered on the wall, its count, its level number), dark empty floors up to the building's capacity, the crown per building, the lift in its shaft, the orange frame and orange sign on the chosen floor, and the annex lot once the building is full. An unheld Review is the dashed ghost (`GovStreet.reviewHeldOf()`, so the street and the interior agree).
-- **The right panel.** Name and what it holds, who holds it (seat chips), how it decides (the rule glyph), **change how this works**, the fill meter with its growth line, on the table here, the chosen floor with its sign large, and the record as monthly filing drawers.
+- **The right panel.** Name and what it holds, who holds it (seat chips), how it decides (the rule glyph), **change how this works**, the fill meter with its growth line, the chosen floor with its sign large, and the record as monthly filing drawers.
 - **Floors are the prototype's structure; a number appears only when the docket holds it.** `GovInside.PLAN` keeps each building's floors, order and capacity. A floor bound to a docket source shows that source's open matters at this building (count, line, needs you, the lines); one bound to a reading shows its figure; Planning's Goals floor counts the open goals. Every other floor says "not recorded yet" on the wall, lettered faint, with no number. A source that is off, coming, not yours or unreadable says which, never a figure. Filling every floor with real data is task 1004527, through `floorFor()` and `PLAN`.
 - **Who holds it.** The docket names no holders yet (task 1004529), so the seat is an empty dashed chip and says "who holds it is not set on this project yet". The rule is the one the building's open matters are decided by, else the design's default, which the words call "by default". `holderOf()` reads a docket building's `holders` / `rule` / `who` first, so 1004529 lands without touching the drawing.
 - **The lift and the flip.** The lift is one node kept across draws, so picking a floor slides it by a CSS transform transition; the chosen floor's block is two blocks that take turns (`flipA` / `flipB`), so it re-enters on every pick. Both are dead under reduced motion.
 - **Change how this works** is present and honest: pressed, it says drafting an amendment from here is not built yet (task 1004530 wires it).
-- **On the table here** rows open the same short card a pin opens, through `openCard()`; Escape gives focus back to the row.
+- **No "on the table here" list.** The prototype's list of the building's open matters was removed on the owner's direction (task 1004565): the floor desks carry every matter as an actionable row, so the list was duplication. Inside a building a matter is its desk row; the short card opens from the street's pins.
 - **Districts.** The goal's tasks (`GET /tasks?goal_id=N`, read once per goal): shape from the discipline (tower engineer, studio artist, glass front UI, pavilion ideator; none is a tower), stage from the status (backlog and blocked a staked plot, ready a slab, active a scaffold, completed and confirmed built with a flag, shipped lit), label the kind; height from the estimate. Up to ten stand on the road, work in flight first; the rest are counted with a link to the goal. Each one opens its task.
 - **Narrow.** Under 900 px the board becomes a column: the drawing in its own sideways strip (never scaled under 0.6, so a floor stays a 24 px target), then the panel.
 

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.37",
+  "version": "1.21.39",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.21.37",
+      "version": "1.21.39",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.21.37",
+  "version": "1.21.39",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -8986,5 +8986,17 @@
       "id": "1004495",
       "text": "The hall now looks different in each craft mode. In Artistry, Ideating and Governing the mode button, the current sidebar tab and the top edge of the page take the mode's own colour (moonlight or night ink, gold, city blue), t"
     }
+  ],
+  "1.21.38": [
+    {
+      "id": "1004564",
+      "text": "If you put something up for a vote and nobody has voted yet, you can now withdraw it with one tap on your desk. Once anyone votes, it stays with the vote. A small database change makes \"withdrawn\" a valid way for a sitting to"
+    }
+  ],
+  "1.21.39": [
+    {
+      "id": "1004565",
+      "text": "Inside each building on the governor street, the separate \"on the table here\" list is gone. The floor desks already show every matter as a row you can act on, so the list only repeated them. The rest of the building panel look"
+    }
   ]
 }

package/src/bongos/route-rank-check.js

@@ -292,6 +292,10 @@ const GOVERNMENT_PINS = {
   // writes the table; neither route does.
   'POST /government/board/decision-rules': 'perm:board.item.open',
   'POST /government/board/matters': 'perm:board.item.open',
+  // task 1004564: a proposer withdraws their own open sitting before any vote —
+  // the proposer's half of putting one up, so the same atom. The proposer-only
+  // and no-votes walls are in withdrawItem (board-withdraw.js) and its write.
+  'POST /government/board/items/:itemId/withdraw': 'perm:board.item.open',
 };
 
 // Module-scoped privileged-rank pins: a privileged route that lives in a FEATURE

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.21.37'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.39'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('discord'); log.info('mounted');

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.