@bongos/core 1.21.166 → 1.21.168

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');
 });

package/tests/hall_city_living.mjs

@@ -181,7 +181,7 @@ test('salmon only for what waits on the viewer: on the floor whose seat it waits
   // a stranger: nothing waits on them, so nothing is salmon and the door is plain
   const s = city({ me: STRANGER });
   assert.equal(allPolys(s).filter((x) => /city-win--you/.test(x.p.cls || '')).length, 0);
-  assert.ok(s.pins.every((p) => p.state === 'moving' || p.state === 'settled'), 'no salmon pin');
+  assert.ok(s.pins.every((p) => p.state === 'moving' || p.state === 'settled' || p.state === 'switch'), 'no salmon pin (the switchboard marker is ink)');
   assert.deepEqual(s.cta, City.ctaFor(0));
   assert.equal(s.cta.label, 'start governing');
 });
@@ -249,7 +249,7 @@ test('quiet buildings sit darker; busy ones keep the prototype\'s recipe exactly
     if (b.quiet) assert.notDeepEqual(recipe, ref.map((p) => p.f), `${s[0]} is quiet: its faces are mixed toward the void`);
     else assert.deepEqual(recipe, ref.map((p) => p.f), `${s[0]} is busy: the recipe is untouched`);
   }
-  assert.deepEqual(m.civic.filter((c) => c.quiet).map((c) => c.key).sort(), ['people', 'rules'], 'no agent and no ask: Rules and People');
+  assert.deepEqual(m.civic.filter((c) => c.quiet).map((c) => c.key).sort(), ['automation', 'people', 'rules'], 'no agent and no ask: Automation (its switch is a standing state, not an ask), Rules and People');
   assert.equal(City.mixToward('#808080', '#000000', 0.5), '#404040');
   assert.equal(City.mixToward('rgba(255,255,255,0.4)', '#000000', 0.5), 'rgba(255,255,255,0.2)', 'a line thins out');
 });
@@ -323,7 +323,7 @@ test('the card: who holds it, one fact, its count, two doors (its first ask is t
   assert.equal(p.enter_href, '/builders/street#building=planning');
   for (const c of m.civic) assert.deepEqual(Object.keys(c.card).sort(), ['agents', 'deck_href', 'enter_href', 'fact', 'key', 'lead', 'name', 'on_others', 'on_you', 'open', 'plate'], c.key + ': every answer is the deck\'s');
   assert.equal(civicOf(m, 'charter').card.plate, 'owner', 'an unseated building is the owner\'s');
-  assert.equal(civicOf(m, 'automation').card.fact.text, 'unattended off', 'the real fence');
+  assert.equal(civicOf(m, 'automation').card.fact.text, 'AI building: off', 'the real fence');
   assert.equal(civicOf(m, 'release').card.fact.text, '2 agents working');
 });
 
@@ -341,7 +341,7 @@ test('the door is "decide N in a row" to the deck; the line counts you, others a
   const m = city();
   const c = m.counts;
   assert.ok(c.on_you > 0 && c.on_others > 0);
-  assert.deepEqual([m.cta.label, m.cta.href], ['decide ' + c.on_you + ' in a row', '/builders/street#deck']);
+  assert.deepEqual([m.cta.label, m.cta.href], ['decide ' + c.on_you + ' in a row', '#decide']);
   assert.equal(m.line, c.on_you + ' to do · ' + c.on_others + ' wait on others · 5 agents working');
   assert.equal(City.livingLine(1, 0, 1), '1 to do · 1 agent working');
   assert.equal(City.livingLine(0, 3, 0), 'nothing to do · 3 wait on others');
@@ -390,7 +390,7 @@ test('motion is CSS, long, inside the budget, with a still frame on every moving
 
 test('salmon is spent only on what waits on you (and the door, the focus ring)', () => {
   const css = read('city.css').replace(/\/\*[\s\S]*?\*\//g, '');
-  const ALLOWED = /city-win--you|city-pin--(urgent|needs)|city-pin__ring|city-pin__age|city-start|city-card__go--you|city-ask--you|city-plaque__tile\[data-key="you"\]|city-card__count--you|focus-visible|body\[data-page="city"\]\s*$/;
+  const ALLOWED = /city-win--you|city-pin--(urgent|needs)|city-pin__ring|city-pin__age|city-start|city-card__go--you|city-ask--you|city-plaque__tile\[data-key="you"\]|city-card__count--you|city-card--you|ask-crab|decide__yours|decide-ask--you|decide__tr--you|focus-visible|body\[data-page="city"\]\s*$/;
   let checked = 0;
   for (const r of css.matchAll(/([^{}]+)\{([^{}]*)\}/g)) {
     if (!/var\(--accent(-deep|-lift)?\)/.test(r[2])) continue;
@@ -507,7 +507,7 @@ async function bootLiving({ asks = false, answer = null } = {}) {
   vm.runInContext(read('city-draw.js'), ctx);
   assert.ok(window.GovLiving && window.GovCity);
   // the deck's card and sender, as city.html loads them (task 1004702)
-  for (const f of ['street-draw.js', 'street-card.js', 'street-inside.js', 'street-desk.js', 'street-deck.js']) vm.runInContext(read(f), ctx);
+  for (const f of ['street-draw.js', 'street-card.js', 'street-inside.js', 'street-desk.js', 'street-deck.js', 'city-decide.js', 'city-switchboard.js']) vm.runInContext(read(f), ctx);
   assert.ok(window.GovDeck && window.GovDesk, 'the deck\'s scripts are on the page');
   vm.runInContext(read('city.js'), ctx);
   await window.GovCityPage.ready;
@@ -529,7 +529,7 @@ test('the page reads the living feeds and draws the sky, the plates, the plaque
   const m = city();
   const start = p.byId.get('cityStart');
   assert.equal(start.textContent, m.cta.label);
-  assert.equal(start.attrs.href, '/builders/street#deck');
+  assert.equal(start.attrs.href, '#decide');
   assert.equal(p.byId.get('cityLine').textContent, m.line);
   for (const id of ['cityBlds', 'citySky', 'cityPins', 'cityPlaque']) assert.equal(findAll(p.byId.get(id), (n) => 'data-proto' in n.attrs).length, 0, id + ': nothing marked prototype');
   assert.doesNotMatch(read('city.html'), /cityKey|cityToast|data-proto/, 'the page has no prototype key and no in-place answer toast');
@@ -543,17 +543,38 @@ test('a building opens its card in place: who holds it, one fact, what waits, it
   assert.equal(card.attrs.hidden, undefined);
   assert.equal(card.attrs['data-building'], 'planning');
   assert.match(card.textContent, /Planning/);
-  // the viewer (builder 2012) leads Planning: "Your seat." (task 1004702: the card speaks to you)
-  assert.match(card.textContent, /Your seat\./);
+  // the viewer (builder 2012) leads Planning: "Your seat." rides the name as a hint, not a line
+  const nameEl = findAll(card, (x) => /\bcity-card__name\b/.test(String(x.className)))[0];
+  assert.equal(nameEl.attrs.title, 'Your seat.');
+  assert.doesNotMatch(card.textContent, /Your seat\./, 'no subtitle line');
   const n = civicOf(city(), 'planning').on_you;
-  assert.match(card.textContent, new RegExp(n + ' wait on you\\.'));
+  const total = civicOf(city(), 'planning').open;
+  assert.match(card.textContent, new RegExp('Total ' + total + ' / Yours ' + n));
+  assert.ok(/\bcity-card--you\b/.test(card.className), 'a building on you wears the project colour');
+  assert.doesNotMatch(card.textContent, /Only you can answer/, 'the glow says it, not a line');
   assert.ok(/\bgov-glass\b/.test(card.className), 'the card is glass');
-  const doors = findAll(card, (x) => x.tagName === 'a' && /city-card__(go|enter)/.test(String(x.className)));
-  assert.deepEqual(doors.map((a) => [a.textContent, a.attrs.href]), [['decide all ' + n + ' in a row', '/builders/street#deck=planning'], ['go inside', '/builders/street#building=planning']], 'two doors');
+  assert.equal(findAll(card, (x) => x.tagName === 'a' && /city-card__enter/.test(String(x.className))).length, 0, 'no door to the street');
+  const go = findAll(card, (x) => /\bcity-card__go\b/.test(String(x.className)));
+  assert.deepEqual(go.map((b) => b.textContent), ['decide all ' + n], 'one decide button, in place');
+  assert.equal(findAll(card, (x) => /\bcity-card__arrow\b/.test(String(x.className))).length, 2, 'arrows to flip between buildings');
+  card.fire('keydown', { key: 'ArrowRight', preventDefault() {} });
+  assert.notEqual(p.byId.get('cityCard').attrs['data-building'], 'planning', 'the right arrow flips to the next building');
+  card.fire('keydown', { key: 'ArrowLeft', preventDefault() {} });
+  assert.equal(p.byId.get('cityCard').attrs['data-building'], 'planning', 'and the left arrow flips back');
   // the building's first ask stands in place, as the deck draws it
   const ask = findAll(card, (x) => /\bcity-ask\b/.test(String(x.className)));
   assert.equal(ask.length, 1, 'its first ask, in place');
   assert.ok(/\bask--here\b/.test(ask[0].className));
+  // answered in the card: the desk row's own acts are its answers, never "answer it on its desk"
+  assert.ok(findAll(card, (x) => /\bask__opt\b/.test(String(x.className))).length > 0, 'the card carries its answers');
+  assert.doesNotMatch(card.textContent, /Answer it on its desk/);
+  // Tab steps to the building's next item, Shift+Tab back
+  const stepN = () => findAll(p.byId.get('cityCard'), (x) => /\bcity-card__stepn\b/.test(String(x.className)))[0].textContent;
+  assert.equal(stepN(), '1 of ' + n);
+  p.byId.get('cityCard').fire('keydown', { key: 'Tab', preventDefault() {} });
+  assert.equal(stepN(), '2 of ' + n);
+  p.byId.get('cityCard').fire('keydown', { key: 'Tab', shiftKey: true, preventDefault() {} });
+  assert.equal(stepN(), '1 of ' + n);
   card.fire('keydown', { key: 'Escape', preventDefault() {} });
   assert.equal(card.attrs.hidden, '', 'Escape closes it');
   const again = p.byId.get('cityHits').children.find((b) => b.attrs['data-building'] === 'planning');
@@ -574,6 +595,10 @@ test('the city card answers its building\'s first ask in place, through the same
   const Kd = p.window.GovDeck;
   const op = opts[1];
   const key = op.attrs['data-key'];
+  // the first press picks that answer and sends nothing; the same number again confirms it
+  card.fire('keydown', { key: op.attrs['data-n'], preventDefault() {} });
+  await new Promise((r) => setTimeout(r, 20));
+  assert.equal(p.sent.length, 0, 'one press only picks');
   card.fire('keydown', { key: op.attrs['data-n'], preventDefault() {} });
   await new Promise((r) => setTimeout(r, 20));
   assert.equal(p.sent.length, 1, 'one request');
@@ -615,3 +640,84 @@ test('Planning stands behind nothing taller, so its lit floor shows', () => {
   for (const o of front) assert.ok(o.roof < planning.roof, 'planning stands behind the taller ' + o.key);
   assert.deepEqual(City.CIVIC_SLOTS.find((s) => s[0] === 'charter').slice(1), [5, 5], 'the Charter rises from the back corner');
 });
+
+// ── the decide view and the switchboard, through the real page (task 1004784) ──
+
+test('the decide view: one by one with Tab inside a building and arrows across, number keys pick then confirm', async () => {
+  const p = await bootLiving({ asks: true });
+  const d = p.window.GovCityPage.openDecide(null);
+  const view = p.byId.get('cityDecide');
+  assert.ok(view && view.attrs.hidden === undefined, 'the view opens over the city');
+  const pos = () => findAll(view, (x) => /\bdecide__pos-n\b/.test(String(x.className)))[0].textContent;
+  const first = pos();
+  const building = first.replace(/ \d+ of \d+$/, '');
+  view.fire('keydown', { key: 'ArrowRight', preventDefault() {}, stopPropagation() {} });
+  assert.notEqual(pos().replace(/ \d+ of \d+$/, ''), building, 'right goes to the next building');
+  view.fire('keydown', { key: 'ArrowLeft', preventDefault() {}, stopPropagation() {} });
+  assert.equal(pos(), first, 'left comes back to the first item of the first building');
+  const n = Number(/of (\d+)$/.exec(first)[1]);
+  if (n > 1) {
+    view.fire('keydown', { key: 'Tab', preventDefault() {}, stopPropagation() {} });
+    assert.equal(pos(), building + ' 2 of ' + n, 'Tab is the next item in the same building');
+    view.fire('keydown', { key: 'Tab', shiftKey: true, preventDefault() {}, stopPropagation() {} });
+  }
+  // walk to a card with answers, then pick and confirm
+  const live = () => { const o = findAll(view, (x) => /\bask__opt\b/.test(String(x.className))); return o.length && !/ask__opt--off/.test(o[0].className); };
+  const k = (key) => view.fire('keydown', { key, preventDefault() {}, stopPropagation() {} });
+  for (let b = 0; b < 12 && !live(); b++) { for (let i = 0; i < 30 && !live(); i++) k('Tab'); if (!live()) k('ArrowRight'); }
+  assert.ok(live(), 'some card answers in place');
+  const askId = () => (findAll(view, (x) => x.attrs && x.attrs['data-ask'])[0] || { attrs: {} }).attrs['data-ask'];
+  const was = askId();
+  const before = p.sent.length;
+  view.fire('keydown', { key: '1', preventDefault() {}, stopPropagation() {} });
+  await new Promise((r) => setTimeout(r, 10));
+  assert.equal(p.sent.length, before, 'the first press only picks');
+  assert.equal(askId(), was, 'and stays on the same card');
+  assert.deepEqual(JSON.parse(JSON.stringify(view.__armed)), { id: was, n: 1 }, 'the pick is held, waiting for its confirm');
+  view.fire('keydown', { key: '1', preventDefault() {}, stopPropagation() {} });
+  await new Promise((r) => setTimeout(r, 30));
+  assert.notEqual(askId(), was, 'the second press of the same number answers it, and the next card comes up');
+  assert.ok(d && d.isOpen());
+});
+
+test('the decide table: one row per open ask, and the bulk bar answers every ticked row through its own route', async () => {
+  const p = await bootLiving({ asks: true });
+  p.window.GovCityPage.openDecide(null, 'table');
+  const view = p.byId.get('cityDecide');
+  const rows = () => findAll(view, (x) => x.tagName === 'tr' && x.parentNode && x.parentNode.tagName === 'tbody');
+  const all = rows();
+  assert.ok(all.length > 1, 'rows are drawn');
+  const answerable = all.filter((r) => findAll(r, (x) => /\bdecide__opt\b/.test(String(x.className)) && !('disabled' in x.attrs)).length);
+  assert.ok(answerable.length >= 1, 'a row answers in place');
+  const box = findAll(answerable[0], (x) => /\bdecide__row-box\b/.test(String(x.className)))[0];
+  box.checked = true;
+  box.fire('change');
+  const bulk = findAll(view, (x) => /\bdecide__bulk-btn\b/.test(String(x.className)));
+  assert.ok(bulk.length >= 1, 'a ticked row offers its answers in the bulk bar');
+  const before = p.sent.length;
+  bulk[0].fire('click');
+  await new Promise((r) => setTimeout(r, 30));
+  assert.equal(p.sent.length, before + 1, 'one request per ticked row');
+  assert.match(p.sent[p.sent.length - 1].url, /^\/api\/bongos\//);
+});
+
+test('Automation opens as a switchboard through the page, and a flip sends the switch\'s own request', async () => {
+  const p = await bootLiving();
+  p.window.GovCityPage.openCard('automation');
+  const card = p.byId.get('cityCard');
+  assert.ok(/\bcity-card--board\b/.test(card.className), 'the card is a switchboard');
+  assert.equal(findAll(card, (x) => String(x.className).split(' ').includes('ask')).length, 0, 'no ask is drawn on it');
+  const toggles = findAll(card, (x) => /\bswb__toggle\b/.test(String(x.className)));
+  const none = findAll(card, (x) => /\bswb__none\b/.test(String(x.className)));
+  assert.ok(toggles.length || none.length, 'it draws the viewer\'s switches, or says they hold none');
+  if (toggles.length) {
+    const plain = toggles.find((t) => !findAll(t.parentNode.parentNode, (x) => /\bswb__why\b/.test(String(x.className))).length) || toggles[0];
+    const before = p.sent.length;
+    plain.fire('click');
+    await new Promise((r) => setTimeout(r, 20));
+    const sentNow = p.sent.length - before;
+    const opened = findAll(card, (x) => /\bswb__why\b/.test(String(x.className)) && !('hidden' in x.attrs)).length;
+    assert.ok(sentNow === 1 || opened === 1, 'a flip sends one request, or asks why first');
+    if (sentNow) assert.match(p.sent[p.sent.length - 1].url, /\/api\/bongos\/autonomy\//);
+  }
+});