@bongos/core 1.21.167 → 1.21.169

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.167'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.169'; // 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/src/platform-server.js

@@ -420,6 +420,11 @@ if (require.main === module) {
       // starts the pollers never writes the tally or spawns the sender.
       try { startErrorTally(); startErrorReports(); }
       catch (e) { logger.warn({ err: e.message }, 'module error tally did not start; module error counts are not kept'); }
+      // The store's promotion gate (task 1003804): an hourly sweep moves tester-channel
+      // versions to general, or holds them, by ADR 0344 D3's rule. Here, not in
+      // startBackgroundServices(), so a test that starts the pollers writes no channel row.
+      try { const { start: startPromotionSweep } = require('./bongos/module-promotion'); startPromotionSweep(); }
+      catch (e) { logger.warn({ err: e.message }, 'module promotion sweep did not start; tester versions will not move to general'); }
     });
   })().catch((err) => {
     // THE AWAIT ABOVE MUST NOT SOFTEN A FATAL BOOT (task 1002857, caught by

package/tests/claim_gate_ci_unblock.mjs

@@ -13,6 +13,10 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
+// task 1004788: fixable strands gate only at REBASE_GATE_LIMIT (default 3). This
+// suite's fake builder owes ONE, and what it pins is the P1-infra exemption from
+// a gate that IS shut, so the limit is set to 1 to keep the gate shut.
+process.env.REBASE_GATE_LIMIT = '1';
 
 let passed = 0;
 let failed = 0;

package/tests/claim_gate_rebase.mjs

@@ -14,6 +14,9 @@ import { strict as assert } from 'node:assert';
 const require = createRequire(import.meta.url);
 const { Pool } = require('pg');
 
+// Cases 1-7 predate task 1004788 and pin the gate's original single-strand shape,
+// so they run with the limit at 1; cases 8-10 move it back to the default (3).
+process.env.REBASE_GATE_LIMIT = '1';
 const pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
 try {
   await pool.query('SELECT 1');
@@ -32,13 +35,16 @@ const VER = 'ZZZ-CG', WORKER = 90000201, STALLED = 90000201, FRESH = 90000202;
 const AGED = 90000203, FRESH2 = 90000204, AGED_OTHER = 90000205;
 // task 1004370 — the CI-unblock exemption.
 const CIFIX = 90000206;
+// task 1004788 — the set-aside and the limit.
+const GUARDED = 90000207, FRESH3 = 90000208, FIX1 = 90000209, FIX2 = 90000210, FIX3 = 90000211;
+const ALL_IDS = [90000201, 90000202, 90000203, 90000204, 90000205, 90000206, 90000207, 90000208, 90000209, 90000210, 90000211];
 const q = (sql, params) => pool.query(sql, params).then((r) => r.rows);
 
 async function cleanup() {
   await q(`DELETE FROM builder_achievements WHERE builder_id=$1`, [WORKER]).catch(() => {});
-  await q(`DELETE FROM credit_log WHERE builder_id=$1 OR task_id = ANY($2::bigint[])`, [WORKER, [STALLED, FRESH, AGED, FRESH2, AGED_OTHER, CIFIX]]).catch(() => {});
-  await q(`DELETE FROM claims WHERE task_id = ANY($1::bigint[])`, [[STALLED, FRESH, AGED, FRESH2, AGED_OTHER, CIFIX]]).catch(() => {});
-  await q(`DELETE FROM tasks WHERE id = ANY($1::bigint[])`, [[STALLED, FRESH, AGED, FRESH2, AGED_OTHER, CIFIX]]).catch(() => {});
+  await q(`DELETE FROM credit_log WHERE builder_id=$1 OR task_id = ANY($2::bigint[])`, [WORKER, ALL_IDS]).catch(() => {});
+  await q(`DELETE FROM claims WHERE task_id = ANY($1::bigint[])`, [ALL_IDS]).catch(() => {});
+  await q(`DELETE FROM tasks WHERE id = ANY($1::bigint[])`, [ALL_IDS]).catch(() => {});
   await q(`DELETE FROM builders WHERE id=$1`, [WORKER]).catch(() => {});
   await q(`DELETE FROM versions WHERE id=$1`, [VER]).catch(() => {});
 }
@@ -151,6 +157,53 @@ try {
   ok((await db.needsRebaseTasksForBuilder(String(WORKER))).some((t) => Number(t.id) === AGED_OTHER),
     'and the owed rebase is still reported: the exemption lets one claim through, it clears nothing');
 
+  // ---------------------------------------------------------------------------
+  // task 1004788 — one stuck land must not block every claim. A strand parked on
+  // a SERVER-SIDE guard is set aside (never gates, still reported); fixable
+  // strands gate only once REBASE_GATE_LIMIT pile up; and the batch dry run and
+  // the batch claim ask the same question as claimTask.
+  // ---------------------------------------------------------------------------
+  // 8) Limit still 1, AGED_OTHER (fixable) cleared: a server-guard strand alone does not gate.
+  await q(`UPDATE tasks SET status='shipped', needs_rebase=false WHERE id=$1`, [AGED_OTHER]);
+  await q(`UPDATE claims SET released_at = now() WHERE task_id = ANY($1::bigint[]) AND released_at IS NULL`, [[CIFIX]]);
+  await seedStrand(GUARDED, 'strand:branch_modifies_executed_code:.gitattributes', 1);
+  await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind) VALUES ($1,$2,'fresh3','ready',10,'feature')`, [FRESH3, VER]);
+  const claim3 = await db.claimTask({ taskId: String(FRESH3), builderId: String(WORKER), worktreeName: 'cg-fresh3' });
+  ok(claim3 && Number(claim3.task_id) === FRESH3, 'a confirmed task parked on a server-side guard does not refuse a new claim');
+  ok((await db.needsRebaseTasksForBuilder(String(WORKER))).some((t) => Number(t.id) === GUARDED),
+    'the set-aside task is still reported as owed, never dropped');
+  await q(`UPDATE claims SET released_at = now() WHERE task_id = $1 AND released_at IS NULL`, [FRESH3]);
+  await q(`UPDATE tasks SET status='ready' WHERE id=$1`, [FRESH3]);
+
+  // 9) Default limit (3): one and two fixable strands do not gate; the third does.
+  delete process.env.REBASE_GATE_LIMIT;
+  await seedStrand(FIX1, 'strand:unresolvable_conflict:docs/x.json', 1);
+  await seedStrand(FIX2, 'strand:pr_not_landed', 1);
+  const v2 = await db.validateClaimBatch({ taskIds: [FRESH3], builderId: String(WORKER) });
+  ok(!JSON.stringify(v2).includes('REBASE_REQUIRED'), 'two fixable strands (+ one set aside) do not gate the dry run');
+  const claim4 = await db.claimTask({ taskId: String(FRESH3), builderId: String(WORKER), worktreeName: 'cg-fresh3b' });
+  ok(claim4 && Number(claim4.task_id) === FRESH3, 'two fixable strands do not refuse a claim');
+  await q(`UPDATE claims SET released_at = now() WHERE task_id = $1 AND released_at IS NULL`, [FRESH3]);
+  await q(`UPDATE tasks SET status='ready' WHERE id=$1`, [FRESH3]);
+
+  await seedStrand(FIX3, 'strand:pr_not_landed', 1);
+  let threw3 = null;
+  try { await db.claimTask({ taskId: String(FRESH3), builderId: String(WORKER), worktreeName: 'cg-fresh3c' }); } catch (e) { threw3 = e; }
+  ok(threw3 && threw3.code === 'REBASE_REQUIRED', 'fixable strands at the limit still refuse');
+  const named = (threw3.rebaseTasks || []);
+  ok(named.filter((t) => !t.waiting).map((t) => Number(t.id)).sort().join() === [FIX1, FIX2, FIX3].sort().join(),
+    'the refusal names exactly the fixable tasks as gating');
+  ok(named.some((t) => t.waiting && Number(t.id) === GUARDED && /server-side guard/.test(t.waits_on)),
+    'and lists the set-aside one as waiting, with what it waits on');
+
+  // 10) The batch dry run and the batch claim agree with claimTask.
+  const v3 = await db.validateClaimBatch({ taskIds: [FRESH3], builderId: String(WORKER) });
+  ok(JSON.stringify(v3).includes('REBASE_REQUIRED'), 'the batch dry run refuses exactly when claimTask does');
+  let batchOut = null, batchErr = null;
+  try { batchOut = await db.claimTasksBatch({ taskIds: [FRESH3], builderId: String(WORKER), worktreePrefix: 'cg-b' }); } catch (e) { batchErr = e; }
+  ok(JSON.stringify(batchOut || batchErr).includes('REBASE_REQUIRED'), 'the batch claim refuses too');
+  ok((await q(`SELECT status FROM tasks WHERE id=$1`, [FRESH3]))[0].status === 'ready', 'and claims nothing');
+
   console.log(`\nclaim_gate_rebase (ADR 0120 part 3): ${pass} passed, 0 failed`);
 } catch (e) {
   console.error('claim_gate_rebase.mjs FAILED:', e.stack || e.message);

package/tests/copy_desk_page_editor.mjs

@@ -104,7 +104,7 @@ try {
       ['L0004', 'greeting', 'Your desk is quiet today', 'engineer'],
       ['L0005', 'footer', 'Resume where you left off', null],
     ]);
-    assert.deepEqual(r.body.notes, { shared: 'changes this on every page', engineer: 'goes to an engineer' });
+    assert.deepEqual(r.body.notes, { shared: 'changes this on every page', engineer: 'goes to an engineer', guarded: 'must still say' });
     assert.equal(r.body.round, null);
     assert.equal(r.body.draft, null);
     assert.deepEqual(r.body.counter, { changed: 0, total: 5 });

package/tests/copy_desk_page_submit.mjs

@@ -318,6 +318,48 @@ try {
     assert.match(eng.description, /take it out/);
     assert.deepEqual([eng.status, eng.discipline], ['backlog', 'engineer']);
   });
+  // Task 1004776: a line that must keep its meaning. The real editor read marks
+  // it and says what it must still say; the real submit WARNS (never refuses)
+  // when the new text drops it, and the warning rides in the frozen batch to the
+  // Approval queue.
+  await test('a guarded line: the editor read marks it, the submit warns and still submits, the batch carries it', async () => {
+    const guarded = require('../modules/copy-desk/guarded-lines.js');
+    guarded._setList({ lines: [{
+      page_id: 'status:explore', file: 'modules/status-ui/public/explore.html',
+      must_contain: ['hidden from everyone'], must_still_say: 'A private project is hidden from everyone.', guarded_by: 'tests/x.mjs',
+    }] });
+    try {
+      const EXPLORE = '/copy-desk/pages/status:explore';
+      const LINES = [
+        L('L0001', 'list', 'Explore projects', 'placed', { file: 'modules/status-ui/public/explore.html', line: 3, string_id: 'ex0001' }),
+        L('L0002', 'list', 'A private project is hidden from everyone.', 'placed', { file: 'modules/status-ui/public/explore.html', line: 4, string_id: 'ex0002' }),
+      ];
+      const r0 = readingsWith({ hash: 'studio-h1', lines: STUDIO_LINES }, { hash: 'index-h2', lines: INDEX_LINES });
+      r0.pages.push({ id: 'status:explore', reading_hash: 'ex-h1', lines: LINES });
+      writeReadings(r0);
+      assert.equal((await call('POST', `${EXPLORE}/claim`, ALICE)).status, 201);
+
+      const read = await call('GET', `${EXPLORE}/draft`, ALICE);
+      assert.equal(read.status, 200, JSON.stringify(read.body));
+      const [plain, held] = read.body.reading.lines;
+      assert.equal(plain.note, null);
+      assert.equal(held.note, 'guarded', 'a third note kind beside shared and engineer');
+      assert.equal(held.must_still_say, 'A private project is hidden from everyone.');
+      assert.equal(read.body.notes.guarded, 'must still say');
+
+      const saved = await call('PUT', `${EXPLORE}/draft`, ALICE, { reading_hash: 'ex-h1', lines: [{ key: 'L0001', after: 'Explore' }, { key: 'L0002', after: 'you are a ninja.' }] });
+      assert.equal(saved.status, 200, JSON.stringify(saved.body));
+      const r = await call('POST', `${EXPLORE}/submit`, ALICE);
+      assert.equal(r.status, 200, 'warned, not refused');
+      assert.equal(r.body.outcome, 'submitted');
+      assert.deepEqual(r.body.warnings, [{ key: 'L0002', must_still_say: 'A private project is hidden from everyone.', missing: ['hidden from everyone'], guarded_by: 'tests/x.mjs' }]);
+      const round = db.tasks.find((t) => t.source_ref === 'page-tweak/status:explore/r1');
+      const batch = pages.parseBatchBlock(round.description).batch;
+      assert.deepEqual(batch.warnings.map((w) => w.key), ['L0002'], 'the warning rides in the frozen batch');
+    } finally {
+      guarded._setList(null);
+    }
+  });
 } finally {
   server.close();
   pageData._setRoot(null);

package/tests/copy_guarded_lines.mjs

@@ -0,0 +1,54 @@
+// tests/copy_guarded_lines.mjs — the guarded-lines list stays honest (task 1004776).
+//
+// modules/copy-desk/guarded-lines.json names page lines that must keep their
+// meaning. Every entry must still find exactly ONE line on its page in the
+// committed docs/page-readings.json; a rewrite that drops the line (or a phrase
+// that now matches two lines) reds here, so the list cannot rot into guarding
+// nothing. Plus the pure warning rule.
+//
+// Run:  node tests/copy_guarded_lines.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { makeRunner } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const guarded = require('../modules/copy-desk/guarded-lines.js');
+const { test, summary } = makeRunner();
+const readings = JSON.parse(fs.readFileSync(path.join(ROOT, 'docs/page-readings.json'), 'utf8'));
+
+await test('every guarded line still exists, exactly once, in the page readings', () => {
+  const list = guarded.loadList();
+  assert.ok(list.lines.length >= 1, 'seeded with the Account page Private line');
+  assert.deepEqual(guarded.checkList(readings), []);
+});
+
+await test('each entry names the test that guards its meaning, and that test exists', () => {
+  for (const e of guarded.loadList().lines) {
+    assert.ok(e.guarded_by && fs.existsSync(path.join(ROOT, e.guarded_by)), `${e.page_id}: guarded_by ${e.guarded_by}`);
+  }
+});
+
+await test('the honesty check reds a line that is gone, and one that matches twice', () => {
+  const page = { id: 'landing:x', lines: [{ key: 'L1', text: 'Hidden from everyone.', file: 'a.html' }, { key: 'L2', text: 'Also hidden from everyone!', file: 'a.html' }] };
+  const gone = { lines: [{ page_id: 'landing:x', file: 'a.html', must_contain: ['never shown'], must_still_say: 's' }] };
+  const twice = { lines: [{ page_id: 'landing:x', file: 'a.html', must_contain: ['hidden from everyone'], must_still_say: 's' }] };
+  assert.match(guarded.checkList({ pages: [page] }, gone)[0].problem, /matches 0/);
+  assert.match(guarded.checkList({ pages: [page] }, twice)[0].problem, /matches 2/);
+  assert.match(guarded.checkList({ pages: [] }, gone)[0].problem, /no such page/);
+});
+
+await test('a submit is warned when a guarded line drops a phrase or is removed, not when it keeps them', () => {
+  const list = { lines: [{ page_id: 'landing:account', file: 'a.html', must_contain: ['hides the page from everyone', 'including you'], must_still_say: 'Private hides it from everyone, you included.' }] };
+  const readingPage = { lines: [{ key: 'L0049', text: 'Private hides the page from everyone — including you.', file: 'a.html' }, { key: 'L0050', text: 'Other', file: 'a.html' }] };
+  const w = guarded.guardWarnings({ pageId: 'landing:account', readingPage, lines: [{ key: 'L0049', after: 'you are a ninja.' }, { key: 'L0050', after: 'x' }] }, list);
+  assert.deepEqual(w.map((x) => [x.key, x.missing]), [['L0049', ['hides the page from everyone', 'including you']]]);
+  assert.deepEqual(guarded.guardWarnings({ pageId: 'landing:account', readingPage, lines: [{ key: 'L0049', after: 'Ninja mode: Private HIDES THE PAGE FROM EVERYONE, including you.' }] }, list), []);
+  assert.equal(guarded.guardWarnings({ pageId: 'landing:account', readingPage, lines: [{ key: 'L0049', remove: true }] }, list).length, 1);
+});
+
+summary();

package/tests/copy_stuck_page_tweaks.mjs

@@ -0,0 +1,118 @@
+// tests/copy_stuck_page_tweaks.mjs — a page tweak that sits too long tells
+// someone (task 1004777): a Needs-attention line on Home for the person it waits
+// on, and a once-a-day Discord digest. Driven through the REAL composer
+// (page-status.js stuckPageTweaks, the Studio's in-flight list and stuck rule),
+// the REAL needs roster (builder-needs.computeNeeds) and the REAL digest
+// (stuck-tweaks.runDigest). A page that is not stuck produces nothing.
+//
+// Run:  node tests/copy_stuck_page_tweaks.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { makeRunner } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const pages = require('../modules/copy-desk/pages.js');
+const status = require('../modules/copy-desk/page-status.js');
+const stuckTweaks = require('../modules/copy-desk/stuck-tweaks.js');
+const needs = require('../modules/builder-settings/builder-needs.js');
+const { test, summary } = makeRunner();
+
+const NOW = new Date('2026-10-23T12:00:00.000Z');
+const ago = (d) => new Date(NOW.getTime() - d * 86400000).toISOString();
+const pg = (id, title = id) => ({ id, surface: id.split(':')[0], title, path: '/', files: [] });
+const PAGES = [pg('landing:index', '{{productName}}: {{tagline}}'), pg('landing:account', 'Account'), pg('builders:studio', 'Studio'), pg('landing:projects', 'Projects')];
+const INVENTORY = { surfaces: [{ id: 'landing' }, { id: 'builders' }], pages: PAGES };
+const batch = (id) => pages.composeBatchBlock({ page_id: id, reading_hash: 'h', submitted_at: ago(9), lines: [] });
+const round = (n, id, extra) => ({ id: String(n), source: 'page-tweak', source_ref: pages.roundSourceRef(id, 1), description: pages.roundTaskBody(pg(id), 1), artist_id: '7', ...extra });
+const ARTIST = '7';
+const TASKS = [
+  // submitted 26 days ago and never applied: stuck, waits on the appliers
+  round(1, 'landing:index', { status: 'ready', description: `${pages.roundTaskBody(pg('landing:index'), 1)}\n\n${batch('landing:index')}`, updated_at: ago(26) }),
+  // held for its artist 5 days: stuck, waits on the artist
+  round(2, 'landing:account', { status: 'completed', grade_passed: true, updated_at: ago(5) }),
+  // submitted yesterday: NOT stuck
+  round(3, 'builders:studio', { status: 'ready', description: `${pages.roundTaskBody(pg('builders:studio'), 1)}\n\n${batch('builders:studio')}`, updated_at: ago(1) }),
+  // being written for a month: a draft is never stuck
+  round(4, 'landing:projects', { status: 'active', holder_id: '7', holder_worktree: false, updated_at: ago(30) }),
+];
+const stuck = () => status.stuckPageTweaks({ inventory: INVENTORY, tasks: TASKS, now: NOW });
+
+await test('the composer: only stuck pages, each with where it sits, how long, and who it waits on', () => {
+  assert.deepEqual(stuck().map((s) => [s.page_id, s.state, s.days, s.waits_on]), [
+    ['landing:index', 'submitted', 26, 'appliers'],
+    ['landing:account', 'waiting_for_artist', 5, 'artist'],
+  ]);
+});
+
+await test('Home: the artist sees their own review; a Metic+ builder sees what waits to be applied', () => {
+  const forArtist = status.stuckPageTweaksFor({ builderId: ARTIST, rank: 'thetes', stuck: stuck() });
+  assert.deepEqual(forArtist.map((s) => s.page_id), ['landing:account']);
+  const forMetic = status.stuckPageTweaksFor({ builderId: '99', rank: 'metic', stuck: stuck() });
+  assert.deepEqual(forMetic.map((s) => s.page_id), ['landing:index']);
+  assert.deepEqual(status.stuckPageTweaksFor({ builderId: '99', rank: 'thetes', stuck: stuck() }), [], 'nobody else is told');
+});
+
+await test('the real needs roster: one Needs-attention line per page, where and how long, linking to the Studio', () => {
+  const r = needs.computeNeeds({ rank: 'archon', ownKeySet: true, stuckPageTweaks: status.stuckPageTweaksFor({ builderId: ARTIST, rank: 'archon', stuck: stuck() }) });
+  const lines = r.items.filter((n) => n.id.startsWith('page_tweak_stuck:'));
+  assert.deepEqual(lines.map((n) => [n.id, n.title, n.message, n.state, n.action.href]), [
+    ['page_tweak_stuck:landing:index', 'Page tweak stuck: landing:index', 'Submitted, waiting to be applied for 26 days.', 'action_needed', '/studio'],
+    ['page_tweak_stuck:landing:account', 'Page tweak stuck: Account', 'Waiting for your review for 5 days.', 'action_needed', '/studio'],
+  ]);
+});
+
+await test('a page that is not stuck produces nothing: no line, no digest', async () => {
+  const fresh = TASKS.filter((t) => t.id === '3' || t.id === '4');
+  const none = status.stuckPageTweaks({ inventory: INVENTORY, tasks: fresh, now: NOW });
+  assert.deepEqual(none, []);
+  assert.equal(needs.computeNeeds({ rank: 'archon', ownKeySet: true, stuckPageTweaks: none }).items.filter((n) => n.id.startsWith('page_tweak_stuck:')).length, 0);
+  const posts = [];
+  const r = await stuckTweaks.runDigest({ nowMs: NOW.getTime(), state: { lastDay: null }, post: async (m) => { posts.push(m); return { posted: true }; }, readStuckImpl: async () => none });
+  assert.deepEqual([r.posted, r.reason, posts.length], [false, 'nothing_stuck', 0]);
+});
+
+await test('the real digest: page names only, never copy, to the ship channel, at most once a day', async () => {
+  const posts = [];
+  const post = async (m) => { posts.push(m); return { posted: true }; };
+  const readStuckImpl = async ({ now }) => status.stuckPageTweaks({ inventory: INVENTORY, tasks: TASKS, now });
+  const state = { lastDay: null };
+  const r = await stuckTweaks.runDigest({ nowMs: NOW.getTime(), state, post, readStuckImpl });
+  assert.equal(r.posted, true);
+  assert.equal(posts[0].channel, 'ship_feed');
+  assert.equal(posts[0].text, [
+    'Page tweaks stuck (2). Open the Studio to move them:',
+    '- landing:index: submitted, waiting to be applied, 26 days',
+    '- Account: waiting for your review, 5 days',
+  ].join('\n'));
+  const again = await stuckTweaks.runDigest({ nowMs: NOW.getTime() + 3600_000, state, post, readStuckImpl });
+  assert.deepEqual([again.posted, again.reason, posts.length], [false, 'not_due', 1], 'once a day');
+  const early = await stuckTweaks.runDigest({ nowMs: Date.parse('2026-10-24T03:00:00Z'), state, post, readStuckImpl });
+  assert.equal(early.reason, 'not_due', 'not before the digest hour');
+  const next = await stuckTweaks.runDigest({ nowMs: Date.parse('2026-10-24T10:00:00Z'), state, post, readStuckImpl });
+  assert.equal(next.posted, true, 'the next day posts again');
+});
+
+await test('the Home read is shared: one ledger read per minute across every builder and request', async () => {
+  stuckTweaks._resetCache();
+  let reads = 0;
+  const read = async ({ now }) => { reads++; return status.stuckPageTweaks({ inventory: INVENTORY, tasks: TASKS, now }); };
+  const t0 = NOW.getTime();
+  const [a, b] = await Promise.all([
+    stuckTweaks.readStuckCached({ nowMs: t0, read }),
+    stuckTweaks.readStuckCached({ nowMs: t0 + 10, read }),
+  ]);
+  await stuckTweaks.readStuckCached({ nowMs: t0 + stuckTweaks.CACHE_MS - 1, read });
+  assert.equal(reads, 1, 'concurrent and repeat callers share one read');
+  assert.equal(a, b);
+  await stuckTweaks.readStuckCached({ nowMs: t0 + stuckTweaks.CACHE_MS, read });
+  assert.equal(reads, 2, 'and it refreshes after the window');
+  stuckTweaks._resetCache();
+});
+
+await test('no Discord on the instance: no post, no error', async () => {
+  const r = await stuckTweaks.runDigest({ nowMs: NOW.getTime(), state: { lastDay: null }, post: null, readStuckImpl: async () => stuck() });
+  assert.equal(r.posted, false);
+});
+
+summary();

package/tests/government_ask_flags.mjs

@@ -0,0 +1,80 @@
+// tests/government_ask_flags.mjs — the reword list (owner, 2026-10-23): the "?"
+// on a city card flags a matter as unclear, an AI session reads the open flags
+// and writes the matter a standard ask, and that write closes the flag.
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const require = createRequire(import.meta.url);
+const docket = require(path.join(ROOT, 'modules', 'government', 'docket.js'));
+const rrc = require(path.join(ROOT, 'src', 'bongos', 'route-rank-check.js'));
+const read = (p) => fs.readFileSync(path.join(ROOT, p), 'utf8');
+
+const VIEWER = { id: 42, rank: 'metic' };
+const NOW = Date.parse('2026-10-23T12:00:00Z');
+function contributions(rows) {
+  return {
+    sources: new Map([
+      ['blockers', { source: 'blockers', building: 'planning', gate: { anyBuilder: true }, read: async () => rows.blockers || [] }],
+      ['override_requests', { source: 'override_requests', building: 'release', gate: { permission: 'override_request.decide' }, read: async () => rows.overrides || [] }],
+    ]),
+    readings: new Map(), floors: new Map(), histories: new Map(), desks: new Map(),
+  };
+}
+const ROWS = {
+  blockers: [{ id: 7, title: 'Pick a host', state: 'needs', rule: 'decide' }, { id: 8, title: 'Clear already', state: 'needs', rule: 'decide' }],
+  overrides: [{ id: 5, title: 'Merge without review', state: 'needs', rule: 'decide' }],
+};
+const FLAG = { flagged_at: '2026-10-23T11:00:00.000Z', note: null, times: 1 };
+
+test('the docket marks a flagged matter unclear, only among the matters the viewer sees', async () => {
+  const asked = [];
+  const readFlags = async (ids) => { asked.push(...ids); return new Map([['blockers:7', FLAG], ['override_requests:5', FLAG]]); };
+  const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: contributions(ROWS), now: NOW, readFlags });
+  const by = new Map(d.matters.map((m) => [m.id, m]));
+  assert.deepEqual(by.get('blockers:7').unclear, FLAG);
+  assert.equal(by.get('blockers:8').unclear, undefined, 'an unflagged matter carries nothing');
+  assert.ok(!asked.includes('override_requests:5'), 'a gated-out matter is never asked about');
+  const broken = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: contributions(ROWS), now: NOW, readFlags: async () => { throw new Error('db down'); } });
+  assert.ok(broken.matters.length > 0 && broken.matters.every((m) => m.unclear === undefined), 'an unreadable list marks nothing and the docket still stands');
+});
+
+test('both routes ride the docket\'s atom, and the flag route checks the matter is visible', () => {
+  const src = read('modules/government/routes/government.js');
+  for (const r of ["router.post('/government/asks/:matterId/unclear'", "router.get('/government/asks/unclear'"]) {
+    const line = src.split('\n').find((l) => l.includes(r));
+    assert.ok(line, r);
+    assert.match(line, /api\.requireBuilder, api\.requirePermission\('board\.vote\.cast'\)/, r + ': gated');
+  }
+  const body = src.split("router.post('/government/asks/:matterId/unclear'")[1].split('router.')[0];
+  assert.match(body, /docket\.findMatterFor\(req\.builder, matterId\)/, 'a flag is never put on a matter its flagger cannot see');
+  assert.match(body, /matter_not_found/);
+  const pins = rrc.GOVERNMENT_PINS || {};
+  const all = JSON.stringify(pins) + read('src/bongos/route-rank-check.js');
+  for (const k of ['POST /government/asks/:matterId/unclear', 'GET /government/asks/unclear']) assert.ok(all.includes(`'${k}': 'perm:board.vote.cast'`), k + ' pinned');
+});
+
+test('a rewrite closes the flag; passing the ask to another seat keeps it open', () => {
+  const db = read('modules/government/asks-db.js');
+  const save = db.split('async function saveAsk')[1].split('\n}\n')[0];
+  assert.match(save, /resolveFlag = true/);
+  assert.match(save, /if \(resolveFlag\) await pool\.query\('UPDATE government_ask_flags SET resolved_at = now\(\) WHERE matter_id = \$1 AND resolved_at IS NULL'/);
+  const routes = read('modules/government/routes/government.js');
+  const pass = routes.split("router.post('/government/asks/:matterId/pass'")[1].split('router.')[0];
+  assert.match(pass, /resolveFlag: false/, 'a pass keeps the words, so it keeps the flag');
+  const flag = db.split('async function flagUnclear')[1].split('\n}\n')[0];
+  assert.match(flag, /resolved_at = NULL/, 'flagging again reopens a closed flag');
+  assert.match(flag, /times = government_ask_flags\.times \+ 1/);
+});
+
+test('the table: one row per matter, the docket id grammar, a bounded note, nothing seeded', () => {
+  const sql = read('modules/government/migrations/government_032_ask_flags.sql');
+  assert.match(sql, /CREATE TABLE IF NOT EXISTS government_ask_flags/);
+  assert.match(sql, /matter_id\s+text\s+PRIMARY KEY/);
+  assert.match(sql, /char_length\(note\) <= 500/);
+  assert.doesNotMatch(sql, /\bINSERT INTO\b/);
+});

package/tests/government_seed.mjs

@@ -51,6 +51,7 @@ const NON_GRANT_MIGRATIONS = new Set([
   'government_029_leads.sql',                      // the Lead of each building, seated by a passed People matter (task 1004709)
   'government_030_buildouts.sql',                  // a Lead's build-outs, on the record at once or by a passed vote (task 1004711)
   'government_031_treasury.sql',                   // the treasury: a pot per goal and the loans a dry pot asks the reserve for (task 1004712)
+  'government_032_ask_flags.sql',                  // the reword list: matters a reader flagged as unclear (owner 2026-10-23)
 ]);
 
 // Permission keys RENAMED after the grant migrations that first granted them.

package/tests/government_treasury.mjs

@@ -85,6 +85,7 @@ function project({ pots = [], borrows = [], cap = null, spend = {}, lastMonth =
       st.asks.set(params[0], row);
       return { rows: [row] };
     }
+    if (/^UPDATE government_ask_flags SET resolved_at/.test(s)) return { rows: [], rowCount: 0 };
     if (/FROM government_asks WHERE matter_id = ANY/.test(s)) return { rows: params[0].map((id) => st.asks.get(id)).filter(Boolean) };
     if (/FROM government_pot_borrows b JOIN goals g ON g\.id = b\.goal_id WHERE b\.state = 'open'/.test(s)) {
       return { rows: st.borrows.filter((b) => b.state === 'open').map((b) => ({ ...b, title: st.goals.find((g) => String(g.id) === String(b.goal_id)).title })) };

package/tests/governor_docket.mjs

@@ -428,7 +428,7 @@ test('the fence: a matter only when it needs a governor, and only a fence manage
   assert.equal(off[0].where, 'automation · the switch', 'the kicker is building · floor only (task 1004568)');
   assert.equal(off[0].detail, 'payments touched', 'the reason rides in detail: the fact, and the more');
   assert.equal(autonomyDocket.fenceDocketMatters({ enabled: false, goals: [] }, true)[0].detail, undefined, 'no reason, no detail');
-  assert.equal(off[0].state, 'needs');
+  assert.equal(off[0].state, 'settled', 'the switch is a standing state on the switchboard, never a to-do');
   assert.equal(autonomyDocket.fenceDocketMatters({ enabled: false, goals: [] }, false)[0].state, 'settled');
   assert.equal(autonomyDocket.fenceDocketMatters({ enabled: true, goals: [] }, true)[0].title, 'Unattended building is on, but no goal is allowed');
 });

package/tests/hall_approval_queue.mjs

@@ -396,4 +396,19 @@ await test('a line whose old words a test still checks says so, through the real
   assert.equal(lib.lineRow(line, 'after').pinned, 'A test still checks the old words: tests/landing_page.mjs. It needs updating when this ships.');
 });
 
+// task 1004776: a submit warning on a guarded line is shown on that line.
+await test('a guarded line the rewrite dropped says so in the queue, through the real composer', () => {
+  const description = [
+    pages.composeBatchBlock({ page_id: 'landing:index', reading_hash: 'h', submitted_at: '2026-09-19T00:00:00Z', lines: [
+      { key: 'L0003', section: 'hero', before: 'Private hides the page from everyone — including you.', after: 'you are a ninja.', placement: 'placed', file: 'x.html', line: 1, string_id: 'a' },
+    ], warnings: [{ key: 'L0003', must_still_say: 'Private hides the page from everyone, including its owner.', missing: ['including you'] }] }),
+    pages.composeAppliedBlock({ page_id: 'landing:index', applied_at: '2026-09-21T00:00:00Z', reading_hash_after: 'h2', lines_after: ['you are a ninja.'], refused: [] }),
+  ].join('\n\n');
+  const tasks = [{ id: 52, status: 'completed', grade_passed: true, description, source_ref: pages.roundSourceRef('landing:index', 1), holder_id: null, artist_id: ME, artist_login: 'me' }];
+  const q = pageStatus.composeApprovals({ inventory: INVENTORY, tasks, builderId: ME, crafts: ['artist'] });
+  const line = q.queue[0].lines[0];
+  assert.equal(line.must_still_say, 'Private hides the page from everyone, including its owner.');
+  assert.equal(lib.lineRow(line, 'after').guarded, 'This line no longer says what it must: Private hides the page from everyone, including its owner.');
+});
+
 summary();

package/tests/hall_city.mjs

@@ -267,8 +267,9 @@ test('the page holds only the wordmark, the switch, the city, one button and one
   assert.equal((html.match(/<header\b/g) || []).length, 1);
   assert.equal((html.match(/<main\b/g) || []).length, 1);
   assert.equal((html.match(/<h1\b/g) || []).length, 1);
-  assert.match(html, /<a class="city-start" id="cityStart" href="\/builders\/street"/);
-  assert.equal((html.match(/<a\b/g) || []).length, 1, 'one door');
+  assert.match(html, /<a class="city-start" id="cityStart" href="#decide"/);
+  assert.equal((html.match(/<a\b/g) || []).length, 3, 'one door, and the two faint archived links to the street');
+  assert.ok(html.includes('<p class="city-archived">Archived: <a href="/builders/street">Street</a> &amp; <a href="/builders/street#building=charter">Building Level Views</a>.</p>'), 'the street is archived behind two faint links');
   assert.equal((html.match(/<button\b/g) || []).length, 1, 'one switch');
   assert.match(html, /class="city-mark">\{\{productName\}\}</);
   assert.equal(City.STREET_HREF, '/builders/street');
@@ -287,7 +288,7 @@ test('the city sits in the hall chrome, behind the shell\'s full-screen switch',
   // task 1004685 (the living city): gov-living.js, the model under the drawing, and
   // gov-feeds.js, its one reader per page (shared with the shell's tally), load before it
   // task 1004702: the card answers its first ask in place, so the deck's card and sender (and the desk rows under them) load before the page
-  assert.deepEqual(scripts, ['shell-trail', 'craft-mode', 'shell', 'palette', 'gov-living', 'gov-feeds', 'city-draw', 'street-draw', 'street-card', 'street-inside', 'street-desk', 'street-deck', 'city'], 'the shell first, as on every hall page');
+  assert.deepEqual(scripts, ['shell-trail', 'craft-mode', 'shell', 'palette', 'gov-living', 'gov-feeds', 'city-draw', 'hall-kit', 'street-draw', 'street-card', 'street-inside', 'street-desk', 'street-deck', 'city-decide', 'city-switchboard', 'city'], 'the shell first, as on every hall page');
   const css = read('city.css').replace(/\/\*[\s\S]*?\*\//g, '');
   assert.match(css, /\.city-main \{ position: fixed; top: var\(--topbar-h, 56px\); left: var\(--sidebar-w-rail, 64px\);[^}]*contain: layout paint;/);
   assert.match(css, /html\[data-fullscreen="on"\] \.city-main \{ top: 0; left: 0; \}/);
@@ -398,7 +399,7 @@ test('the page reads the three feeds and draws the docket\'s pins and line', asy
   assert.ok(!moving.children[0].children.some((c) => c.className === 'city-pin__ring'), 'a moving pin only bobs');
   assert.equal(pins.find((s) => s.className.includes('settled')).children[0].children.length, 0, 'a settled pin is a plain dot');
   assert.equal(p.byId.get('cityLine').textContent, '2 matters wait on you · 1 moving');
-  assert.equal(p.byId.get('cityStart').attrs.href, '/builders/street');
+  assert.equal(p.byId.get('cityStart').attrs.href, '#decide', 'the door opens the decide view in place; the street is archived');
   assert.ok(p.byId.get('cityBlds').children.length > 9, 'the civic quarter and the district are drawn');
   assert.ok(p.byId.get('cityParcels').children.some((s) => /offset/.test(Object.keys(s.style).join(' '))), 'parcels carry an offset-path');
 });