@bongos/core 1.21.113 → 1.21.114

package/src/bongos/routes/me.js

@@ -122,7 +122,9 @@ const discordIsLinked = (builderId) =>
 // `idea.triage` (task 1004231): the sky's panel draws "nod — make it claimable"
 // on a thought awaiting a nod only for a builder who may triage ideas; the nod
 // itself runs the existing POST /tasks/:id/promote, which stays the wall.
-const NAV_PERMISSION_ATOMS = Object.freeze(['board.vote.cast', 'core.pin.move', 'idea.triage']);
+// `board.item.open` (task 1004714): My agents offers 'Make it a law' — a laws vote,
+// POST /government/board/laws — only to a builder who may open a board item.
+const NAV_PERMISSION_ATOMS = Object.freeze(['board.vote.cast', 'core.pin.move', 'idea.triage', 'board.item.open']);
 
 // navPermissionsFor(builderId) → { '<atom>': boolean } over NAV_PERMISSION_ATOMS,
 // or null when authority could not be established (government off, port missing,
@@ -187,7 +189,7 @@ module.exports = function buildMeRouter() {
       recentGrades, builderAvg, onboardingRow, shipCount, recentKarma, karma30d, discordLink, cliAuthed,
       behaviorPrefs, geminiKeyRow, needsRebaseTasks, foundingBuilder, helpRequestCount,
       taskRecommendationCount, boardVotesPending, socialMode, mingleIntroductionCount,
-      navPermissions, foundingMode,
+      navPermissions, foundingMode, sessionLaws, govPositions,
     ] = await Promise.all([
       db.getBuilderById(req.builder.id),
       lc().getActiveClaimsForBuilder(req.builder.id),
@@ -318,7 +320,44 @@ module.exports = function buildMeRouter() {
           return await onboarding.foundingModeFor();
         } catch (_) { return null; }
       })(),
+      // task 1004707: the project's LAWS — what every AI session on the project
+      // reads, via the `government` port (core imports no module, ADR 0093).
+      // Read per request, uncached, so a law passed a moment ago is in the next
+      // session. null when the module is off or the read failed: the session then
+      // gets no laws block, and the settings slices resolve without locks.
+      (async () => {
+        try {
+          const government = seams.resolveOptional('government');
+          if (!government || typeof government.lawsForSession !== 'function') return null;
+          return await government.lawsForSession();
+        } catch (err) {
+          log.error({ err: err && err.message }, 'GET /me laws');
+          return null;
+        }
+      })(),
+      // task 1004713: the government POSITIONS this builder holds (owner, Lead,
+      // a building's sitting, the board), via the `government` port. Read per
+      // request, uncached. null when the module is off or a read failed.
+      (async () => {
+        try {
+          const government = seams.resolveOptional('government');
+          if (!government || typeof government.positionsFor !== 'function') return null;
+          return await government.positionsFor(req.builder.id);
+        } catch (err) {
+          log.error({ err: err && err.message }, 'GET /me positions');
+          return null;
+        }
+      })(),
     ]);
+    // task 1004707: a law's LOCKS bite on the three settings slices below
+    // (interaction, wandering, model allocation): their effective values and
+    // injected contracts are resolved with every lock applied, server-side —
+    // the builder-settings port's describeWithLaws is the SSOT. A builder's own
+    // stored choice is still reported as theirs.
+    const instanceModels = (() => { try { return branding().models || {}; } catch { return {}; } })();
+    const lawed = settings && typeof settings.describeWithLaws === 'function'
+      ? settings.describeWithLaws(behaviorPrefs, (sessionLaws && sessionLaws.laws) || [], { rank: builder && builder.rank, instanceModels })
+      : null;
     // V3.R84 (#302), criterion C3: the builder's month-to-date spend vs their
     // monthly budget. Surfaced here so the CLI (session-start ping) and the hall
     // profile banner read it without a follow-up call; the ship + art-pipeline
@@ -401,6 +440,14 @@ module.exports = function buildMeRouter() {
       // floor. null when authority could not be established, which the shell
       // reads as nothing-visible. Cosmetic only — ADR 0016, the server enforces.
       permissions: navPermissions,
+      // task 1004713 (owner ruling 2026-10-09: governance is a HELD POSITION, not a
+      // picked craft): { held: [{ kind, seat, building, title }], title,
+      // has_position, from } — the seats this builder holds, resolved server-side
+      // (modules/government/positions.js). The hall shows the governing surfaces
+      // and names the Governing mode by `title` only for a holder. null when it
+      // could not be read, which the hall reads as unknown (today's nav), never
+      // "holds none". Cosmetic only — every governing page keeps its own gate.
+      positions: govPositions,
       unlocked,
       locked_with_progress: lockedWithProgress,
       streak: {
@@ -469,13 +516,27 @@ module.exports = function buildMeRouter() {
       // level (clamped by rank) + its behavior contract. The Conductor + the
       // /settings UI read this; the builder-settings port's describeWandering is
       // the SSOT (BV1.R80). null when the prefs module is off.
-      wandering: settings ? settings.describeWandering(behaviorPrefs, builder.rank) : null,
+      wandering: lawed ? lawed.wandering : (settings ? settings.describeWandering(behaviorPrefs, builder.rank) : null),
       // task 2010: the per-builder interaction profile (tone / technical level /
       // toolchain familiarity), resolved to an effective profile + an injectable
       // contract. The old §2 "The Prompter" owner-defaults, now per-builder. The
       // session-start injection + /settings UI read this; describeInteraction is
       // the SSOT (builder-settings port). null when the prefs module is off.
-      interaction: settings && settings.describeInteraction ? settings.describeInteraction(behaviorPrefs) : null,
+      interaction: lawed ? lawed.interaction : (settings && settings.describeInteraction ? settings.describeInteraction(behaviorPrefs) : null),
+      // task 1004707: the project's LAWS, read into every AI session. The
+      // Conductor hook relays `contract` verbatim beside the interaction profile
+      // (inject:false, and no block, when no law is in force). `laws` is the book
+      // as the session reads it, numbered; `locks` is what each law's lock did to
+      // THIS builder's settings ({ setting, law_id, enforced, from, to } — a lock on
+      // a setting no table holds yet is enforced:false, its law's words still
+      // apply). The server writes all of it; nothing local can change it. null when
+      // the laws could not be read.
+      laws: sessionLaws ? {
+        inject: !!sessionLaws.inject,
+        contract: sessionLaws.contract || '',
+        laws: Array.isArray(sessionLaws.laws) ? sessionLaws.laws : [],
+        locks: lawed ? lawed.locks : [],
+      } : null,
       // task 1003855: the builder's ACTIVE specialities, one per craft at most
       // (the speciality_adoptions partial unique index enforces that). Each entry
       // carries its own injectable contract; the Conductor picks the one matching
@@ -491,9 +552,9 @@ module.exports = function buildMeRouter() {
       // task 2011: the resolved subagent model allocation (main + subagent tiers),
       // builder override → instance default (branding.models) → code default. The
       // agent consults `effective` when spawning subagents; §2 links here.
-      model_allocation: settings && settings.describeModelAllocation
-        ? settings.describeModelAllocation(behaviorPrefs, (() => { try { return branding().models || {}; } catch { return {}; } })())
-        : null,
+      model_allocation: lawed ? lawed.model_allocation : (settings && settings.describeModelAllocation
+        ? settings.describeModelAllocation(behaviorPrefs, instanceModels)
+        : null),
       // task 1279: the per-builder "render widgets" knob (shares behavior_prefs).
       // { widgets_enabled } tells the start/claim/ship CLIs whether to emit the
       // rich HTML card or the cheap text fallback. No rank cap (cost/taste, not

package/src/bongos/serve-internal.js

@@ -1245,8 +1245,12 @@ function mountInternalSurfaces(app) {
   // task 1004473: `commands`, the Commands page — every skill and every bongos CLI
   // verb. Both reads behind it are requireBuilder, so it sits on this tier;
   // reading the list grants nothing (ADR 0310 §1).
+  // task 1004685 (the living-city prototype): `my-agents` — how the viewer's own
+  // Claude works for them. Every read behind it is the viewer's own and
+  // requireBuilder (GET /me and its /me/* prefs, /specialities), so sign-in is the
+  // whole gate; the governing reads it adds are gated by their own routes.
   const SIGNEDIN_BUILDERS_PAGE_RE =
-    /^\/builders\/(?:work|settings|atlas|modules|goals|goal-map|roadmap|copy-desk|studio|tweak-editor|ideas|thinking|collab|task|idea|primer(?:\.md)?|diagrams|commands)(?:\.html)?\/?$/;
+    /^\/builders\/(?:work|settings|atlas|modules|goals|goal-map|roadmap|copy-desk|studio|tweak-editor|ideas|thinking|collab|task|idea|primer(?:\.md)?|diagrams|my-agents|commands)(?:\.html)?\/?$/;
   // The diagram image assets under /builders/diagrams/ ride the same tier as the
   // page that embeds them.
   const SIGNEDIN_BUILDERS_PREFIX_RE = /^\/builders\/diagrams\//;

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.113'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.21.114'; // 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');
@@ -473,6 +473,12 @@ module.exports = {
     get SHIP_MODES() { return require('./bongos/project-settings').SHIP_MODES; },
     get parseShipMode() { return require('./bongos/project-settings').parseShipMode; },
     get resolveShipMode() { return require('./bongos/project-settings').resolveShipMode; },
+    // The spend cap (task 1004712, ADR 0379): off by default (no limit, the owner's
+    // ruling). The treasury reads it; PATCH /project-settings/spend-cap writes it.
+    get parseSpendCap() { return require('./bongos/project-settings').parseSpendCap; },
+    get resolveSpendCap() { return require('./bongos/project-settings').resolveSpendCap; },
+    get setSpendCap() { return require('./bongos/project-settings').setSpendCap; },
+    get describeSpendCap() { return require('./bongos/project-settings').describeSpendCap; },
     get describeShipMode() { return require('./bongos/project-settings').describeShipMode; },
     // Tweak auto-pickup (task 1004677, ADR 0371 D3/D5): the switch and the monthly cap.
     get AUTOPICKUP_MODES() { return require('./bongos/project-settings').AUTOPICKUP_MODES; },

package/src/platform-server.js

@@ -316,6 +316,16 @@ function buildPlatformApp() {
     if (!html) return next();
     res.type('html').send(html);
   });
+  // THE CONNECTIONS PAGE (task 1004278, ADR 0337 D5.4): the hub is the primary
+  // home for connections — your connections across every project, the requests
+  // in both directions, and "Builders you may know". Hub-only for the /account
+  // reason: every read and write it makes is a platform-identity route.
+  app.get('/connections', (req, res, next) => {
+    if (!isApexHost(req) || !isModuleEnabled('platform-identity')) return next();
+    const html = landingPage('connections.html');
+    if (!html) return next();
+    res.type('html').send(html);
+  });
   // THE GUILD PAGE (task 1002301, R25; ADR 0336 D4/D6): /g/<slug>, the namespace
   // D6 reserved. Hub-only for the /account reason — every read it makes is a
   // platform-identity route. ONE shell for every slug: the page reads the public

package/tests/application_lifecycle.mjs

@@ -310,12 +310,12 @@ const pool = {
 
     // A vouched re-application taking over an unvouched pending row (ADR 0333 D4).
     // The SET list is matched exactly, like the resolve's below.
-    if ((m = /^UPDATE access_requests SET display_name = \$2, note = \$3, applicant_github_id = \$4, applicant_handle = \$5, vouched_at = \$6 WHERE (.+?)$/.exec(sql))) {
+    if ((m = /^UPDATE access_requests SET display_name = \$2, note = \$3, applicant_github_id = \$4, applicant_handle = \$5, vouched_at = \$6 WHERE (.+?) RETURNING id, github_login, status, created_at$/.exec(sql))) {
       const hit = rows.filter(predicateFor(m[1], params));
       for (const r of hit) {
         [r.display_name, r.note, r.applicant_github_id, r.applicant_handle, r.vouched_at] = params.slice(1, 6);
       }
-      return { rows: [], rowCount: hit.length };
+      return { rows: hit.map((r) => ({ id: r.id, github_login: r.github_login, status: r.status, created_at: r.created_at })), rowCount: hit.length };
     }
 
     // The resolve — one UPDATE, one WHERE, and that WHERE is the whole rule.
@@ -354,11 +354,13 @@ const poolPath = require.resolve('../src/bongos/pool.js');
 require.cache[poolPath] = { id: poolPath, filename: poolPath, loaded: true, exports: { pool } };
 
 // Discord broadcast is fire-and-forget on the public write; stubbed so the suite
-// is hermetic (it is best-effort in production and never affects the queue).
+// is hermetic (it is best-effort in production and never affects the queue), and
+// recorded so a test can see which #member-approvals lines would have gone out.
+let broadcasts = [];
 const broadcastPath = require.resolve('../modules/onboarding/approval-broadcast.js');
 require.cache[broadcastPath] = {
   id: broadcastPath, filename: broadcastPath, loaded: true,
-  exports: { postMemberApprovalRequest: async () => ({ posted: false, skipped: 'test' }) },
+  exports: { postMemberApprovalRequest: async (request) => { broadcasts.push(request); return { posted: false, skipped: 'test' }; } },
 };
 
 // The hub's side of the vouch, for real: a generated Ed25519 keypair, the real
@@ -452,7 +454,7 @@ function call(method, pathname, body, extraHeaders = {}) {
     req.end(payload);
   });
 }
-const reset = (rank = 'archon') => { seed(); actingRank = rank; actingId = 42; notices = []; hubViews = {}; hubAsked = []; };
+const reset = (rank = 'archon') => { seed(); actingRank = rank; actingId = 42; notices = []; hubViews = {}; hubAsked = []; broadcasts = []; };
 
 // ===========================================================================
 // The interpreter is the instrument, so it is calibrated first
@@ -618,6 +620,19 @@ test('a vouched re-application takes over an UNVOUCHED pending row for its own l
   assert.equal(row(1).status, 'pending', 'and it decides nothing');
 });
 
+// The first #member-approvals line still quotes the words the row held before the
+// takeover, and a webhook cannot edit it; so the takeover posts the row's words now.
+test('a vouched takeover re-posts the #member-approvals line with the words the row holds now', async () => {
+  reset();
+  await applyAs('ada', { [VOUCH_HEADER]: vouchFor('ada', { githubId: 8001, handle: 'ada-h' }) });
+  assert.equal(broadcasts.length, 1, 'one line, for the takeover — the duplicate INSERT posts nothing');
+  const [line] = broadcasts;
+  assert.equal(line.id, 1, 'the same request, so a 👍 on either line resolves the one row');
+  assert.equal(line.refiled, true);
+  assert.equal(line.display_name, 'New');
+  assert.match(line.note, /via platform My Projects/);
+});
+
 test('a re-application never re-stamps an ALREADY vouched row, and an unvouched one changes nothing', async () => {
   reset();
   const bo = { ...row(2) };
@@ -626,6 +641,33 @@ test('a re-application never re-stamps an ALREADY vouched row, and an unvouched
   const ada = { ...row(1) };
   await applyAs('ada');
   assert.deepEqual(row(1), ada, 'an unvouched re-apply is the idempotent success it always was');
+  assert.deepEqual(broadcasts, [], 'and neither re-posts a line: nothing on the row changed');
+});
+
+// END TO END: a row written by the REAL vouch writer is the row the queue resolves
+// from the hub. The profile tests below seed their vouched rows; this one proves the
+// link between the two halves — the id the writer stores is the id the read asks for.
+test('list-pending: the real vouch writer’s row resolves its profile and guild from the hub', async () => {
+  reset();
+  const profile = { view: 'public', account: { handle: 'newcomer-h', bio: 'hi' }, cross_project: null };
+  hubViews['7001'] = { profile, guild: { slug: 'lantern-works', name: 'Lantern Works' } };
+  await applyAs('Newcomer', { [VOUCH_HEADER]: vouchFor('newcomer') });
+  const r = await call('GET', '/api/gds/access-requests');
+  const got = r.json.requests.find((x) => x.github_login === 'Newcomer');
+  assert.ok(hubAsked.includes('7001'), 'the hub was asked about the id the vouch carried');
+  assert.deepEqual(got.profile, profile);
+  assert.deepEqual(got.guild, { slug: 'lantern-works', name: 'Lantern Works' });
+});
+
+test('list-pending: a vouched TAKEOVER resolves the vouched applicant, not whoever filed first', async () => {
+  reset();
+  hubViews['8001'] = { profile: { view: 'sliver', sliver: { disciplines: ['engineer'] } }, guild: null };
+  await applyAs('ada', { [VOUCH_HEADER]: vouchFor('ada', { githubId: 8001, handle: 'ada-h' }) });
+  const r = await call('GET', '/api/gds/access-requests');
+  const ada = r.json.requests.find((x) => x.github_login === 'ada');
+  assert.equal(ada.vouched, true);
+  assert.deepEqual(ada.profile, hubViews['8001'].profile);
+  assert.ok(hubAsked.includes('8001'));
 });
 
 test('list-pending: the queue carries the handle the vouch brought, beside the vouch mark', async () => {

package/tests/conductor_main_e2e.mjs

@@ -128,4 +128,25 @@ await test('outside any claimed worktree no craft is guessed', async () => {
   assert.ok(r.out.includes(INTERACTION), 'and the rest of the hook still runs');
 });
 
+// task 1004707: the project's LAWS, built by the SERVER's own helper (what the
+// government port hands GET /me), run through the real hook.
+const lawsLib = require('../modules/government/laws.js');
+const LAW_BOOK = lawsLib.forSession([
+  { id: 11, text: 'Ask like a human', effect_on_ai: 'One short card with tap answers.', locks: [{ setting: 'verbosity', value: 'concise' }], repealed_at: null },
+]);
+
+await test('a session on a project with laws is told the laws, first, in the server\'s own words', async () => {
+  const r = await runHook({ ...mePayload(), laws: { inject: LAW_BOOK.inject, contract: LAW_BOOK.contract, laws: LAW_BOOK.laws, locks: [] } });
+  assert.equal(r.code, 0);
+  assert.ok(r.out.includes('1. Ask like a human — One short card with tap answers.'), `the law reaches the session; stdout was: ${JSON.stringify(r.out.slice(0, 400))}`);
+  assert.ok(r.out.indexOf('Project laws') < r.out.indexOf(INTERACTION), 'ahead of the builder\'s own profile');
+});
+
+await test('a project with no laws sends no laws block', async () => {
+  const none = lawsLib.forSession([]);
+  const r = await runHook({ ...mePayload(), laws: { inject: none.inject, contract: none.contract, laws: [], locks: [] } });
+  assert.ok(!r.out.includes('Project laws'));
+  assert.ok(r.out.includes(INTERACTION), 'and the rest of the hook still runs');
+});
+
 summary();

package/tests/connections_api.mjs

@@ -309,6 +309,24 @@ test('list: my connections, the count IS the array length, and paging is real',
     "…and applying the PUBLIC predicate here would erase your own connections from your own list");
 });
 
+test('list: ?here=1 is the project cut — the same read, narrowed to this instance’s active builders', async () => {
+  expect(meActive(), result([]));
+  await call('GET', '/api/bongos/connections?here=1&limit=2&offset=4');
+  assert.ok(calls[1].text.includes(conn.HERE_SQL),
+    'the hall tab’s cut (ADR 0337 D5.4): connections who also build on this project, joined on github_id');
+  assert.match(conn.HERE_SQL, /b\.status = 'active'/, 'a deactivated seat is not building here');
+  assert.deepEqual(calls[1].params, [ME.github_id, 2, 4],
+    'a literal term with no new parameter — paging and the FANOUT_1 cap are the full list’s');
+  assert.match(calls[1].text, /\(pa\.profile_state = 'active' AND pa\.terms_accepted_at IS NOT NULL\)/,
+    'still own scope on the consent floor — the cut narrows, it never swaps the predicate');
+
+  for (const q of ['', '?here=0', '?here=true', '?here=']) {
+    expect(meActive(), result([]));
+    await call('GET', `/api/bongos/connections${q}`);
+    assert.doesNotMatch(calls[1].text, /\bbuilders\b/, `"${q}" is the full list, unchanged`);
+  }
+});
+
 test('list: the limit is clamped to FANOUT_1 however large a caller asks', async () => {
   expect(meActive(), result([]));
   await call('GET', '/api/bongos/connections?limit=999999');

package/tests/craft_mode_nav.mjs

@@ -128,8 +128,10 @@ const CRAFTS = ['building', 'artistry', 'ideating', 'governing'];
 
 test('THE ALWAYS-PRESENT LIST: one shared list, Builders first, then Collab and Profile, inside every mode', () => {
   const { craft } = boot();
-  assert.deepEqual([...craft.ALWAYS_TABS], ['roster', 'collab', 'profile'],
-    'Builders (NAV id roster) heads the list (owner, 2026-10-01); Collab and Profile join it (owner, 2026-10-03)');
+  // task 1004685 (the living-city prototype): My agents joins as a PROPOSAL for the
+  // owner — every craft has agents, and round-3 board 6 pairs it with the city.
+  assert.deepEqual([...craft.ALWAYS_TABS], ['roster', 'collab', 'profile', 'my-agents'],
+    'Builders (NAV id roster) heads the list (owner, 2026-10-01); Collab and Profile join it (owner, 2026-10-03); My agents (prototype, task 1004685)');
   for (const m of CRAFTS) {
     const tabs = craft.tabsFor(m);
     assert.ok(Array.isArray(tabs), `${m} has a named tab list`);
@@ -187,7 +189,7 @@ test('a mode never shows a tab the gate hid, and a later gate pass keeps the mod
   p.signIn('thetes');
   assert.ok(!p.showing().includes('watch'), 'a thetes in Governing does not get the metic-floored Watch tab');
   assert.ok(!p.headShowing('government'), 'nor its group head');
-  assert.deepEqual(p.showing(), ['blockers', 'board-room', 'city', 'profile', 'collab', 'roster'], 'what a thetes board member in Governing sees');
+  assert.deepEqual(p.showing(), ['blockers', 'board-room', 'city', 'profile', 'my-agents', 'collab', 'roster'], 'what a thetes board member in Governing sees');
   p.signIn('archon');
   assert.ok(p.showing().includes('watch'), 'promoted, the gate lets it through and the mode keeps it');
   assert.ok(p.headShowing('government'), 'and its group head comes back with it, which only a mode pass after the gate can know');

package/tests/craft_mode_tallies.mjs

@@ -1,11 +1,15 @@
 // tests/craft_mode_tallies.mjs — Governing mode's header tallies (task 1004563, goal
-// 1000095 WA6): "needs you N · moving M" beside the eyebrow.
+// 1000095 WA6): "to do N · moving M" beside the eyebrow, on the city and the
+// street only (task 1004701, owner ruling 2026-10-09).
 //
 // Runs the REAL craft-mode.js over a small DOM with a stubbed fetch, and the REAL
 // server count (modules/lifecycle/moving.js) over a fake pool, so the two halves are
 // pinned where they actually decide: which statuses "moving" counts (owner decision
 // 2026-10-08: active + confirmed), and that a figure the page could not read is left
-// out rather than drawn as a zero that says nothing waits on you.
+// out rather than drawn as a zero that says nothing waits on you. Since the living
+// city (task 1004685) both figures are the city's own (gov-living.js countsOf over
+// gov-feeds.js), so the real gov-living.js and gov-feeds.js run beside it here;
+// tests/hall_gov_counts.mjs holds the tally equal to every other surface.
 import assert from 'node:assert/strict';
 import { test } from 'node:test';
 import fs from 'node:fs';
@@ -16,6 +20,8 @@ import { fileURLToPath } from 'node:url';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const CRAFT = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/craft-mode.js'), 'utf8');
+const LIVING = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/gov-living.js'), 'utf8');
+const FEEDS = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/gov-feeds.js'), 'utf8');
 const require = createRequire(import.meta.url);
 process.env.NODE_ENV = 'test';
 const { countMoving, movingHandler, MOVING_STATUSES } = require('../modules/lifecycle/moving.js');
@@ -44,7 +50,8 @@ function node(tag, id, cls) {
 function all(root) { return root.children.flatMap((c) => [c, ...all(c)]); }
 
 // answers: path → JSON body, or a number (an HTTP failure status), or 'throw'.
-function boot(mode, answers) {
+// page: the body's data-page (the tally stands on the city and the street only)
+function boot(mode, answers, page = 'city') {
   const sidebar = node('NAV', 'app-sidebar');
   sidebar.appendChild(node('DIV', '', 'app-sidebar__brand'));
   const topbar = node('DIV', 'app-topbar');
@@ -52,7 +59,7 @@ function boot(mode, answers) {
   const root = node('HTML');
   const asked = [];
   const document = {
-    documentElement: root, body: node('BODY'), activeElement: null,
+    documentElement: root, body: (() => { const b = node('BODY'); if (page) b.setAttribute('data-page', page); return b; })(), activeElement: null,
     getElementById: (id) => [sidebar, topbar, ...all(sidebar), ...all(topbar)].find((n) => n.id === id) || null,
     querySelectorAll: () => [],
     createElement: (t) => node(t.toUpperCase()),
@@ -68,20 +75,34 @@ function boot(mode, answers) {
     if (typeof a === 'number') return Promise.resolve({ ok: false, status: a, json: () => Promise.resolve({}) });
     return Promise.resolve({ ok: true, status: 200, json: () => Promise.resolve(a) });
   };
-  const sandbox = { window, document, fetch, CustomEvent: class { constructor(t, i) { this.type = t; Object.assign(this, i); } } };
+  window.fetch = fetch;
+  const sandbox = { window, document, fetch, Date, CustomEvent: class { constructor(t, i) { this.type = t; Object.assign(this, i); } } };
   vm.createContext(sandbox);
+  // the living city's one counter and one reader, as the city and the street carry them
+  // (task 1004685): the tally prints their numbers, read through gov-feeds.js
+  vm.runInContext(LIVING, sandbox, { filename: 'gov-living.js' });
+  vm.runInContext(FEEDS, sandbox, { filename: 'gov-feeds.js' });
   vm.runInContext(CRAFT, sandbox, { filename: 'craft-mode.js' });
   const craft = window.OTBCraftMode;
   craft.mount();
   const box = () => all(topbar).find((n) => n.id === 'craft-tallies') || null;
   return { craft, topbar, asked, box };
 }
-const settle = () => new Promise((r) => setImmediate(r));
+const settle = async () => { for (let i = 0; i < 20; i++) await new Promise((r) => setImmediate(r)); };
 const text = (html) => html.replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim();
 
-const BOTH = { '/blockers?limit=1': { blockers: [{ id: 1 }], page: { limit: 1, offset: 0, total: 3 } }, '/moving': { moving: 12, active: 9, confirmed: 3 } };
+// Since the living city (task 1004685) the tally prints the city's own counts:
+// gov-living.js countsOf over gov-feeds.js COUNT_FEEDS, and since task 1004716 those
+// stand on ONE server read, GET /government/counts. Here three matters on the
+// viewer, no agent at work, twelve moving.
+const COUNTS = { viewer: { id: '1' }, on_you: 3, on_others: 0, open: 3, agents_at_work: 0, moving: 12, routed: true, yours: ['b:1', 'b:2', 'b:3'], others: [] };
+const BOTH = {
+  '/government/counts': COUNTS,
+  '/me': { builder: { id: '1', github_login: 'builder-1', rank: 'archon' } },
+};
+const COUNT_PATHS = ['/government/counts', '/me'];
 
-test('Governing reads both counts and draws "needs you 3 · moving 12" right after the eyebrow', async () => {
+test('Governing reads the city\'s counts and draws "to do 3 · moving 12" right after the eyebrow', async () => {
   const { topbar, box, asked } = boot('governing', BOTH);
   await settle();
   const b = box();
@@ -89,24 +110,25 @@ test('Governing reads both counts and draws "needs you 3 · moving 12" right aft
   const eyebrow = all(topbar).find((n) => n.id === 'craft-eyebrow');
   assert.equal(eyebrow.nextSibling, b, 'they sit directly after the mode words');
   assert.equal(b.getAttribute('hidden'), null);
-  assert.equal(text(b.innerHTML), 'needs you 3 · moving 12');
+  assert.equal(text(b.innerHTML), 'to do 3 · moving 12');
   assert.match(b.innerHTML, /craft-tally craft-tally--due/, 'something waits, so needs-you carries the warm dot');
-  assert.deepEqual(asked.map((u) => u.replace('/api/bongos', '')).sort(), ['/blockers?limit=1', '/moving'], 'one page of one blocker for the total, one count — never a task list');
+  assert.deepEqual(asked.map((u) => u.replace('/api/bongos', '')).sort(), COUNT_PATHS,
+    'one server count, once, beside the viewer the shell already reads — never a task list');
 });
 
-test('nothing waiting draws "needs you 0" without the dot', async () => {
-  const { box } = boot('governing', { ...BOTH, '/blockers?limit=1': { blockers: [], page: { limit: 1, offset: 0, total: 0 } } });
+test('nothing waiting draws "to do 0" without the dot', async () => {
+  const { box } = boot('governing', { ...BOTH, '/government/counts': { ...COUNTS, on_you: 0, open: 0, yours: [] } });
   await settle();
-  assert.equal(text(box().innerHTML), 'needs you 0 · moving 12');
+  assert.equal(text(box().innerHTML), 'to do 0 · moving 12');
   assert.doesNotMatch(box().innerHTML, /craft-tally--due/);
 });
 
 test('a count that cannot be read is LEFT OUT, never drawn as zero', async () => {
-  const noMoving = boot('governing', { ...BOTH, '/moving': 401 });
+  const noMoving = boot('governing', { ...BOTH, '/government/counts': { ...COUNTS, moving: null } });
   await settle();
-  assert.equal(text(noMoving.box().innerHTML), 'needs you 3', 'a signed-out or failed /moving drops only its own figure');
+  assert.equal(text(noMoving.box().innerHTML), 'to do 3', 'a moving count the server could not read drops only its own figure');
 
-  const offline = boot('governing', { '/blockers?limit=1': 'throw', '/moving': { moving: 'lots' } });
+  const offline = boot('governing', { '/government/counts': 'throw' });
   await settle();
   assert.equal(offline.box().getAttribute('hidden'), '', 'nothing readable: the slot stays hidden, no zeros');
   assert.equal(offline.box().innerHTML, '');
@@ -126,6 +148,20 @@ test('only Governing wears the tallies, and leaving it removes them', async () =
   assert.equal(box(), null, 'switching away takes them down');
 });
 
+test('the top bar carries the tally on the city and the street only (owner ruling, task 1004701)', async () => {
+  for (const page of ['city', 'street']) {
+    const { box } = boot('governing', BOTH, page);
+    await settle();
+    assert.ok(box(), `${page} carries the tally`);
+  }
+  for (const page of ['my-agents', 'board', 'home', null]) {
+    const { box, asked } = boot('governing', BOTH, page);
+    await settle();
+    assert.equal(box(), null, `${page || 'a page with no name'} draws no tally`);
+    assert.deepEqual(asked, [], `${page || 'a page with no name'} asks the server for nothing`);
+  }
+});
+
 test('the server counts active + confirmed only, and sums them', async () => {
   assert.deepEqual([...MOVING_STATUSES], ['active', 'confirmed']);
   let seen;

package/tests/discord_approvals.mjs

@@ -72,6 +72,17 @@ await t('memberApprovalLine round-trips through parseApprovalMarker', () => {
   assert.deepEqual(ap.parseApprovalMarker(line), { kind: 'member', id: 99 });
 });
 
+// A vouched takeover (ADR 0333 D4) re-posts the request with the row's words now; it
+// must still lead with the SAME marker, or a 👍 on it would resolve nothing.
+await t('the refiled line carries the new words and round-trips to the same request', () => {
+  const line = bcast.memberApprovalLine({ id: 99, github_login: 'carol', display_name: 'Carol', note: 'the real me', refiled: true });
+  assert.deepEqual(ap.parseApprovalMarker(line), { kind: 'member', id: 99 });
+  assert.match(line, /Carol/);
+  assert.match(line, /the real me/);
+  assert.match(line, /replace the earlier line for #99/);
+  assert.doesNotMatch(bcast.memberApprovalLine({ id: 99, github_login: 'carol' }), /replace/, 'a first line says nothing about replacing');
+});
+
 // ---- recordApprovalReaction (orchestration via fakes) ----------------------
 const GOOD_ID = '123456789012345678';
 const archon = { id: 1, rank: 'archon', github_login: 'example-owner' };

package/tests/discord_channels.mjs

@@ -361,6 +361,26 @@ await t('the real config declares the board-room channel, visible to every build
   assert.ok(board.topic && board.topic.length > 0, 'board-room needs a topic');
 });
 
+// task 1002536: the AI-news feed is the ZERO-CODE form the owner chose at the
+// 2026-07-29 triage — an off-the-shelf RSS service posts into one channel, and
+// nothing on our host polls anything. The channel is the whole repo surface, so
+// pin it: builders-only by INHERITING the BUILDERS category (spelling `view`
+// out would repeat the category and drift), and a topic that names #ideas,
+// because pasting a link there is the article → idea path (the inbound handler
+// reads only typed text, never a forwarded post, so Forward files no link).
+await t('the real config declares ai-news, builders-only, pointing readers at #ideas', () => {
+  const cfg = ch.loadConfig();
+  const cat = cfg.categories.find((c) => (c.channels || []).some((x) => x.key === 'ai-news'));
+  assert.ok(cat, 'expected a channel keyed ai-news');
+  const news = cat.channels.find((x) => x.key === 'ai-news');
+  assert.equal(ch.slugify(news.name), 'ai-news', 'the name must slug to its key, or apply creates a duplicate');
+  assert.equal(cat.name, 'BUILDERS');
+  assert.equal(news.view, undefined, 'ai-news must inherit, not repeat, its category view');
+  assert.equal(cat.view, 'xenos', 'so every builder, and only builders, can read it');
+  assert.ok(news.topic && news.topic.length <= 1024, 'Discord refuses a topic over 1024 characters');
+  assert.match(news.topic, /#ideas/, 'the topic must say where an article becomes an idea');
+});
+
 await t('the real config plans cleanly against an empty guild and never deletes', () => {
   const cfg = ch.loadConfig();
   const { ops } = ch.planChannelReconcile({ categories: [], channels: [] }, cfg, CTX_BOT);

package/tests/fixtures/gov-seated.mjs

@@ -0,0 +1,64 @@
+// tests/fixtures/gov-seated.mjs — A SEATED GOVERNMENT, as test data for the
+// hall's living-city tests (task 1004717). The hub has seated no Lead and built
+// nothing, so the harness fixtures alone cannot show a Lead's floor, a build-out
+// going up or one waiting on its vote. This builds them in the exact shapes the
+// routes answer — GET /government/leads with five Leads appointed by People votes,
+// Review's Testers room standing, a floor going up at Release and an annex
+// waiting on its sitting at Treasury — and routes the docket to those seats by
+// the server's own rule (modules/government/routing.js). The hall never reads it.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const routing = require(path.join(ROOT, 'modules', 'government', 'routing.js'));
+const fx = (name) => JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts', 'hall-preview', 'fixtures', name + '.json'), 'utf8'));
+
+// five Leads (the fixture's viewer, 1000025, leads Planning)
+export const SEATED = Object.freeze([
+  { building: 'planning', lead: '1000025', since: '2026-09-12', scope: 'Goals, priorities, the order of work.' },
+  { building: 'release', lead: '1000027', since: '2026-09-05', scope: 'Release floors and the path to going live.' },
+  { building: 'review', lead: '1000095', since: '2026-09-20', scope: 'Who checks finished work, and how.' },
+  { building: 'treasury', lead: '1000094', since: '2026-09-28', scope: 'Pots and the reserve.' },
+  { building: 'people', lead: '1000070', since: '2026-10-02', scope: 'Who joins, and the ranks they hold.' },
+]);
+
+// GET /government/leads with them in office and the three build-outs on the record
+export function leadsRead() {
+  const r = fx('government__leads');
+  const roster = fx('builders__roster').builders;
+  const at = (k) => r.buildings.find((b) => b.building === k);
+  for (const l of SEATED) {
+    const p = roster.find((x) => String(x.id) === l.lead) || { id: l.lead };
+    at(l.building).lead = { id: 'L' + l.building, building: l.building, builder: { id: String(p.id), login: p.github_login || null, name: p.display_name || null }, charter: l.scope, since: l.since, appointed_by: { item_id: '1' } };
+    at(l.building).answers = { seat: 'lead:' + l.building, builder_ids: [String(p.id)], fell_to_owner: false };
+  }
+  at('review').structure = { standing: [{ id: 2, capsule: 'committee', name: 'Testers', line: 'Who checks finished work.', state: 'built', progress: 1 }], proposed: [] };
+  at('release').structure = { standing: [{ id: 1, capsule: 'floor', name: 'Staging floor', line: '', state: 'building', progress: 0.55, allowed: { path: 'at_once', why: 'Its holder builds it out at once.' } }], proposed: [] };
+  at('treasury').structure = { standing: [], proposed: [{ capsule: 'annex', name: 'Investments arm', line: 'A wing for the reserve.', docket_id: 'board:77', item_id: '77' }] };
+  return r;
+}
+
+// the annex's sitting, open on the docket: nobody has voted yet
+function sitting(seats) {
+  return {
+    id: 'board:77', source: 'board', building: 'treasury', rule: 'majority', state: 'moving', title: 'Add an annex to Treasury: Investments arm', short: 'an annex',
+    opened_at: '2026-10-08T10:00:00.000Z', deadline: null, tally: { for: 0, against: 0, open: seats }, ref: { type: 'board_item', id: '77' }, acts: [],
+  };
+}
+
+// GET /government/docket with the sitting, every matter routed to those seats
+export function docketRouted() {
+  const d = fx('government__docket');
+  d.matters.push(sitting(d.buildings.find((b) => b.key === 'charter').holders.length));
+  const read = leadsRead();
+  const seats = { leads: read.buildings.filter((b) => b.lead).map((b) => ({ building: b.building, builder_id: b.lead.builder.id })), owner: read.owner, holders: {} };
+  d.matters.forEach((m) => {
+    const { route, ...bare } = m;
+    m.route = routing.routeMatter(bare, d.viewer.id, seats, Date.parse(d.generated_at));
+  });
+  return d;
+}