@bongos/core 1.21.166 → 1.21.168

package/modules/government/docket.js

@@ -532,6 +532,23 @@ function registeredContributions() {
 // the matters this viewer already sees, so an ask is never more visible than its
 // matter. A read that fails or is slow attaches none: the city still stands, and
 // each matter keeps its own words.
+//
+// The reword flags (government_032, owner 2026-10-23) ride the same way: a
+// matter someone pressed "?" on carries `unclear` { flagged_at, note, times }.
+async function attachFlags(matters, readFlags, timeoutMs) {
+  if (typeof readFlags !== 'function' || !matters.length) return;
+  try {
+    const found = await withTimeout(Promise.resolve(readFlags(matters.map((m) => m.id))), timeoutMs);
+    if (!found || typeof found.get !== 'function') return;
+    for (const m of matters) {
+      const flag = found.get(m.id);
+      if (flag) m.unclear = flag;
+    }
+  } catch (err) {
+    log.warn({ err: err && err.message }, 'governor docket: reword flags unreadable');
+  }
+}
+
 async function attachAsks(matters, readAsks, timeoutMs) {
   if (typeof readAsks !== 'function' || !matters.length) return;
   try {
@@ -561,7 +578,7 @@ async function attachAsks(matters, readAsks, timeoutMs) {
 // `seats` is who sits in each seat (loadSeats below: Leads in office, the owner
 // seat, each building's holders); given, every matter carries `route` (routing.js,
 // task 1004705) and the docket says `routed: true`. null routes nothing.
-async function buildDocket({ viewer, permissions, contributions = registeredContributions(), now = Date.now(), timeoutMs = SOURCE_TIMEOUT_MS, decisions = null, government = null, readAsks = null, seats = null } = {}) {
+async function buildDocket({ viewer, permissions, contributions = registeredContributions(), now = Date.now(), timeoutMs = SOURCE_TIMEOUT_MS, decisions = null, government = null, readAsks = null, readFlags = null, seats = null } = {}) {
   const held = new Set(permissions || []);
   const ctx = Object.freeze({
     builderId: String(viewer.id),
@@ -614,6 +631,7 @@ async function buildDocket({ viewer, permissions, contributions = registeredCont
   sourceStatus.sort((a, b) => order.indexOf(a.source) - order.indexOf(b.source));
   matters.sort(compareMatters);
   await attachAsks(matters, readAsks, timeoutMs);
+  await attachFlags(matters, readFlags, timeoutMs);
   // THE DIRECTION DESK (task 1004705): who each matter waits on, from real seats.
   const yours = seats ? routing.routeAll(matters, ctx.builderId, seats, now) : null;
 
@@ -813,7 +831,7 @@ async function docketFor(builder) {
   });
   const government = permissions.includes(GOVERNMENT_GATE.permission) ? await loadGovernment({ decisions }) : null;
   const seats = government ? await loadSeats(government) : null;
-  return buildDocket({ viewer: builder, permissions, decisions, government, readAsks: asksDb.asksFor, seats });
+  return buildDocket({ viewer: builder, permissions, decisions, government, readAsks: asksDb.asksFor, readFlags: asksDb.unclearFor, seats });
 }
 
 // Who sits in each seat now (task 1004705), read per request, uncached (ADR

package/modules/government/migrations/government_032_ask_flags.sql

@@ -0,0 +1,35 @@
+-- government_032_ask_flags.sql — THE REWORD LIST: a reader says a card does not
+-- make sense (owner, 2026-10-23: the "?" on every city card).
+--
+-- WHAT THIS ADDS
+--
+--   government_ask_flags — ONE ROW PER DOCKET MATTER someone flagged as unclear,
+--   keyed by the matter's docket id (`blockers:12`), the same key as
+--   government_asks. An AI session works the open rows (GET
+--   /government/asks/unclear), writes the matter a proper ask (PUT
+--   /government/asks/:matter, the standard short card), and that write closes
+--   the flag (resolved_at). Flagging again after a rewrite reopens it.
+--
+--   A flag is a request, not a verdict: it grants nothing and changes nothing a
+--   person decides. `note` is the reader's optional words on what confused them.
+--
+-- Additive and idempotent: a new table (IF NOT EXISTS) and one index. No row is
+-- seeded.
+
+BEGIN;
+
+CREATE TABLE IF NOT EXISTS government_ask_flags (
+  matter_id    text        PRIMARY KEY
+               CHECK (matter_id ~ '^[a-z][a-z_]{1,39}:[A-Za-z0-9._-]{1,64}$'),
+  flagged_by   bigint      NULL,
+  flagged_at   timestamptz NOT NULL DEFAULT now(),
+  note         text        NULL CHECK (note IS NULL OR char_length(note) <= 500),
+  times        integer     NOT NULL DEFAULT 1 CHECK (times >= 1),
+  resolved_at  timestamptz NULL
+);
+
+-- the open reword list, oldest first
+CREATE INDEX IF NOT EXISTS government_ask_flags_open_idx
+  ON government_ask_flags (flagged_at) WHERE resolved_at IS NULL;
+
+COMMIT;

package/modules/government/routes/government.js

@@ -826,6 +826,48 @@ module.exports = function buildGovernmentRouter() {
     }
   });
 
+  // rank: perm board.vote.cast — "I DON'T UNDERSTAND THIS" (the "?" on a city
+  // card, owner 2026-10-23): puts a matter the flagger can see on the reword
+  // list (government_032). An AI session works that list and writes the matter
+  // a standard ask (PUT above), which closes the flag. A flag changes nothing a
+  // person decides; it only asks for better words.
+  //
+  // Body: { note? } (≤ 500 chars, what confused them)  → 200 { ok, matter_id, flag }
+  router.post('/government/asks/:matterId/unclear', api.requireBuilder, api.requirePermission('board.vote.cast'), async (req, res) => {
+    const matterId = String(req.params.matterId || '');
+    if (!asks.isMatterId(matterId)) return res.fail('bad_matter_id', { status: 400, message: 'Name the matter by its docket id, like blockers:12.' });
+    if (validateOrRespond(req, res, { note: { type: 'string', maxLength: 500 } })) return;
+    try {
+      const found = await docket.findMatterFor(req.builder, matterId);
+      if (!found.matter) {
+        if (found.reason === 'unavailable') return res.fail('matter_unavailable', { status: 503, message: 'That matter could not be read just now, so nothing was flagged. Try again.' });
+        return res.fail('matter_not_found', { status: 404, message: 'No open matter by that id that you can see.' });
+      }
+      const flag = await asksDb.flagUnclear({ matterId, builderId: req.builder.id, note: req.body && req.body.note });
+      res.json({ ok: true, matter_id: matterId, flag });
+    } catch (err) {
+      log.error('[gds] POST /government/asks/:matterId/unclear', err);
+      res.fail('flag_save_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
+  // rank: perm board.vote.cast — THE REWORD LIST: the open matters this viewer
+  // can see that someone flagged as unclear, oldest flag first, each with its
+  // words as they stand (title, detail, stored ask) so a session can rewrite it.
+  // → 200 { ok, matters: [{ id, building, source, title, detail, ask, flag }] }
+  router.get('/government/asks/unclear', api.requireBuilder, api.requirePermission('board.vote.cast'), async (req, res) => {
+    try {
+      const d = await docket.docketFor(req.builder);
+      const list = (d.matters || []).filter((m) => m.unclear)
+        .sort((a, b) => String(a.unclear.flagged_at).localeCompare(String(b.unclear.flagged_at)))
+        .map((m) => ({ id: m.id, building: m.building, source: m.source, title: m.title, detail: m.detail || null, ask: m.ask || null, flag: m.unclear }));
+      res.json({ ok: true, matters: list });
+    } catch (err) {
+      log.error('[gds] GET /government/asks/unclear', err);
+      res.fail('flags_read_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
   // rank: perm board.vote.cast — PASS AN ASK ON to another seat (task 1004705,
   // the direction desk). Only whoever the ask waits on today may hand it on
   // (routing.passRefusal, from real seats: its Lead, the owner seat, a board's
@@ -847,7 +889,7 @@ module.exports = function buildGovernmentRouter() {
       }
       const refused = routing.passRefusal(found.matter, req.builder.id, seat, found.seats);
       if (refused) return res.fail(refused.code, { status: refused.status, message: refused.message });
-      const ask = await asksDb.saveAsk({ matterId, ask: { ...found.matter.ask, waits_on: seat }, builderId: req.builder.id });
+      const ask = await asksDb.saveAsk({ matterId, ask: { ...found.matter.ask, waits_on: seat }, builderId: req.builder.id, resolveFlag: false });
       const route = routing.routeMatter({ ...found.matter, ask }, req.builder.id, found.seats);
       res.json({ ok: true, matter_id: matterId, ask, route });
     } catch (err) {

package/modules/hall-ui/public/approval-queue-lib.js

@@ -120,6 +120,10 @@
       aside: line.refused ? refusedWords(line.refused) : (after ? `was: ${line.before}` : `becomes: ${line.after}`),
       refused: !!line.refused,
       // task 1004775: a test still asserts the old words, so it fails once this lands.
+      // task 1004776: the rewrite dropped what this line must still say.
+      ...(!line.refused && line.must_still_say
+        ? { guarded: `This line no longer says what it must: ${line.must_still_say}` }
+        : {}),
       ...(!line.refused && Array.isArray(line.pinned_by) && line.pinned_by.length
         ? { pinned: `A test still checks the old words: ${line.pinned_by.join(', ')}. It needs updating when this ships.` }
         : {}),

package/modules/hall-ui/public/approval-queue.js

@@ -152,6 +152,7 @@
           ${r.section ? `<span class="aq-line__section">${esc(r.section)}</span>` : ''}
           <span class="aq-line__text">${r.marked ? `<mark class="aq-mark">${words(r.text)}</mark>` : words(r.text)}</span>
           <span class="aq-line__aside">${words(r.aside)}</span>
+          ${r.guarded ? `<span class="aq-line__pinned">${esc(r.guarded)}</span>` : ''}
           ${r.pinned ? `<span class="aq-line__pinned">${esc(r.pinned)}</span>` : ''}
         </li>`).join('')}</ol>`;
     }

package/modules/hall-ui/public/brand-apply.js

@@ -100,8 +100,11 @@
     var s = task && task.status;
     return s === 'confirmed' || s === 'shipped';
   }
+  // task 1004782 — an abandoned (or merged-away) task earns nothing and is
+  // owed nothing, so it is worth 0 wherever a total adds it up.
   function taskCreditValue(task) {
     if (!task) return null;
+    if (task.status === 'abandoned' || task.merged_into_task_id != null) return 0;
     if (taskSettled(task)) {
       var awarded = Number(task.credits_awarded);
       // Settled with a real ledger payout → show it. If a settled task has no