@bongos/core 1.21.167 → 1.21.169

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\//);
+  }
+});

package/tests/hall_city_rewording.mjs

@@ -0,0 +1,51 @@
+// tests/hall_city_rewording.mjs — a matter sent for a rewrite (the "?", owner
+// 2026-10-23) leaves the to-do until its new words land, and is counted apart
+// as "Rewording", building by building.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const PUB = path.join(ROOT, 'modules/hall-ui/public');
+
+function boot() {
+  const ctx = { console, document: {} };
+  ctx.window = ctx;
+  vm.createContext(ctx);
+  vm.runInContext(fs.readFileSync(path.join(PUB, 'city-decide.js'), 'utf8'), ctx);
+  return ctx.window.GovCityDecide;
+}
+const DOCKET = { matters: [
+  { id: 'blockers:1', building: 'planning', unclear: { times: 1 } },
+  { id: 'blockers:2', building: 'planning' },
+  { id: 'redteam_reports:3', building: 'disputes', unclear: { times: 2 } },
+] };
+
+test('a flagged matter is left out of the queue as if answered, and the answered stay out too', () => {
+  const G = boot();
+  const done = JSON.parse(JSON.stringify(G.withoutReworded({ 'blockers:9': true }, DOCKET)));
+  assert.deepEqual(Object.keys(done).sort(), ['blockers:1', 'blockers:9', 'redteam_reports:3']);
+  assert.equal(done['blockers:2'], undefined, 'an unflagged matter stays in the queue');
+});
+
+test('Rewording counts per building, and everywhere', () => {
+  const G = boot();
+  assert.equal(G.rewordingCount(DOCKET, 'planning'), 1);
+  assert.equal(G.rewordingCount(DOCKET, 'disputes'), 1);
+  assert.equal(G.rewordingCount(DOCKET, 'treasury'), 0);
+  assert.equal(G.rewordingCount(DOCKET, null), 2);
+  assert.equal(G.rewordingCount({ matters: [] }, null), 0);
+});
+
+test('the "?" asks before it sends: the send lives behind a confirm button', () => {
+  const src = fs.readFileSync(path.join(PUB, 'city-decide.js'), 'utf8');
+  const fn = src.split('function unclearButton')[1].split('\n  }\n')[0];
+  const send = fn.indexOf("on.send({ method: 'POST'");
+  const confirm = fn.indexOf("go.addEventListener('click'");
+  assert.ok(send > 0 && confirm > 0 && send > confirm, 'the request is sent only from the confirm button');
+  assert.match(fn, /Send this to Claude to rewrite\?/);
+  assert.match(fn, /Nothing is decided or changed/);
+});

package/tests/hall_city_switchboard.mjs

@@ -0,0 +1,63 @@
+// tests/hall_city_switchboard.mjs — Automation as a switchboard (owner, 2026-10-23).
+// The board draws only the switches the docket hands THIS viewer, every flip
+// sends the desk row's own request, and the fence is never a to-do.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const PUB = path.join(ROOT, 'modules/hall-ui/public');
+const require = createRequire(import.meta.url);
+const autoDocket = require(path.join(ROOT, 'modules/autonomy/governor-docket.js'));
+const FIXTURE = JSON.parse(fs.readFileSync(path.join(ROOT, 'scripts/hall-preview/fixtures/government__docket.json'), 'utf8'));
+const DOCKET = FIXTURE.body || FIXTURE;
+
+function boot() {
+  const ctx = { console };
+  ctx.window = ctx;
+  vm.createContext(ctx);
+  for (const f of ['street-draw.js', 'street-card.js', 'street-inside.js', 'street-desk.js', 'city-switchboard.js']) vm.runInContext(fs.readFileSync(path.join(PUB, f), 'utf8'), ctx);
+  return ctx;
+}
+const j = (v) => JSON.parse(JSON.stringify(v));
+const GOALS = [{ id: '1000089', title: 'Working area 3', status: 'open' }];
+
+test('the fence is a standing state, never a to-do', () => {
+  for (const mayManage of [true, false]) {
+    for (const p of [{ enabled: false, goals: [] }, { enabled: true, goals: [] }]) {
+      assert.equal(autoDocket.fenceDocketMatters(p, mayManage)[0].state, 'settled');
+    }
+  }
+  assert.deepEqual(autoDocket.switchDeskRows({ enabled: false, goals: [] })[0].acts, [{ key: 'switch_on' }], 'off: the master row switches it on');
+  assert.equal(autoDocket.switchDeskRows({ enabled: true, goals: [] })[0].acts[0].key, 'switch_off', 'on, even with no goal: the master row switches it off');
+});
+
+test('the board draws the viewer\'s switches, and each flip is the desk row\'s request', () => {
+  const w = boot();
+  const m = j(w.GovCitySwitchboard.model(DOCKET, { now: Date.parse('2026-10-09T15:00:00Z'), goals: GOALS }));
+  assert.deepEqual(m.groups.map((g) => g.title), ['AI builds on its own (Autobongos)', 'Goals the AI may work on', 'Computers doing the building']);
+  const master = m.groups[0].switches[0];
+  assert.equal(master.on, false);
+  const live = w.GovCitySwitchboard.model(DOCKET, { now: Date.parse('2026-10-09T15:00:00Z'), goals: GOALS });
+  const flip = live.groups[0].switches[0].flip;
+  assert.deepEqual(j(w.GovMatterCard.request(flip.row.card, flip.key, flip.input)), { method: 'POST', url: '/api/bongos/autonomy/fence', body: { enabled: true } });
+  const goal = live.groups[1].switches[0];
+  assert.equal(goal.on, false, 'an open goal not yet allowed is an off switch');
+  assert.deepEqual(j(w.GovMatterCard.request(goal.flip.row.card, goal.flip.key, goal.flip.input)).body, { goal_id: 1000089 });
+  const runner = live.groups[2].switches[0];
+  assert.equal(runner.on, true);
+  assert.ok(runner.flip.reasons.length > 0, 'pausing a runner asks why, in one tap');
+});
+
+test('a viewer handed no Automation desks gets no switches', () => {
+  const w = boot();
+  const bare = j(DOCKET);
+  bare.desks = bare.desks.filter((d) => !/^automation\./.test(d.key));
+  const m = j(w.GovCitySwitchboard.model(bare, { goals: GOALS }));
+  assert.equal(m.any, false);
+  assert.deepEqual(m.groups, []);
+});

package/tests/hall_gov_real_site.mjs

@@ -555,9 +555,9 @@ test('a Lead the government appointed stands on their building on a real site; e
     assert.match(hit('planning').attrs['aria-label'], new RegExp('led by ' + A_REAL_LEAD));
     assert.match(hit('release').attrs['aria-label'], /held by the owner/);
     hit('planning').fire('click');
-    assert.match(city.byId.get('cityCard').textContent, new RegExp('Led by ' + A_REAL_LEAD + '\\.'));
+    assert.match(city.byId.get('cityCard').children[0].children[0].attrs.title, new RegExp('Led by ' + A_REAL_LEAD + '\\.'));
     hit('treasury').fire('click');
-    assert.match(city.byId.get('cityCard').textContent, /hold(s)? it until a Lead is seated\./);
+    assert.match(city.byId.get('cityCard').children[0].children[0].attrs.title, /hold(s)? it until a Lead is seated\./);
     noPrototype(city, 'city card with real Leads', { seatsRead: true });
     const street = await bootStreet('', false);
     assert.ok(street.calls.includes('/api/bongos/government/leads'), 'the street reads it too');

package/tests/hall_street_deck.mjs

@@ -141,7 +141,6 @@ test('a real answer is the desk row\'s own request, to the route the desk uses',
     'redteam_reports:confirm': 'POST /api/bongos/security/reports/N/confirm',
     'redteam_reports:dispute': 'POST /api/bongos/security/reports/N/dispute',
     'override_requests:release': 'POST /api/bongos/override-requests/N/decide',
-    'autobongos_fence:switch_on': 'POST /api/bongos/autonomy/fence',
     'treasury_spending:answer': 'POST /api/bongos/government/treasury/borrows/N/answer',
   });
   // a blocker's option is its own chip, so its words are the resolution note
@@ -151,8 +150,11 @@ test('a real answer is the desk row\'s own request, to the route the desk uses',
   const cr = K.cardView(lv.city.asks.find((x) => x.id === 'criteria_uat:1000184'), c);
   assert.deepEqual(cr.options.map((o) => o.plan.mode), ['record', 'send', 'note']);
   assert.equal(cr.options[0].plan.id, '1000184');
-  const fence = K.cardView(lv.city.asks.find((x) => x.id === 'autobongos_fence:fence'), c);
-  assert.deepEqual(fence.options.map((o) => o.plan.mode), ['send', 'note']);
+  // the fence is a standing state on the Automation switchboard, never a to-do
+  // (task 1004784): its matter is settled and carries no act, so the switch is
+  // flipped from the switchboard's desk row, not from a card
+  const fence = lv.city.asks.find((x) => x.id === 'autobongos_fence:fence');
+  assert.ok(!fence || fence.state !== 'needs', 'the fence never waits on anyone');
 });
 
 test('a viewer the server hands no acts gets answers marked not from here, never a send', () => {
@@ -492,7 +494,7 @@ test('the page: #deck draws the top card over the street; a key answers it throu
   assert.equal(next.getAttribute('data-ask'), 'blockers:1000143');
   assert.match(next.className, /\bask--rise\b/, 'the next one rises');
   assert.equal(p.cls(p.deck(), 'deck-dock__of')[0].textContent, ' of 8 to do');
-  assert.equal(p.byId.get('hudNeeds').textContent, '37', 'the street\'s header moves with the deck');
+  assert.equal(p.byId.get('hudNeeds').textContent, '36', 'the street\'s header moves with the deck');
 });
 
 test('the page: a refusal keeps the card and counts nothing; S skips to the back', async () => {

package/tests/hall_street_depth.mjs

@@ -276,7 +276,7 @@ test('what needs you lights salmon windows on the floor that holds it, with a ri
   assert.ok(d.windows.some((w) => w.building === 'planning'), 'the viewer leads Planning');
   assert.ok(!d.windows.some((w) => ['review', 'release', 'treasury'].includes(w.building)), 'what waits on another Lead lights nothing');
   // the hub as it is (no Lead read, everything on the owner seat): every docket need is the viewer's own
-  assert.deepEqual(street({ leads: null, docket: fx('government__docket') }).depth.windows.map((w) => w.key), ['needs:automation:0', 'needs:disputes:0', 'needs:planning:2', 'needs:release:0', 'needs:review:1', 'needs:treasury:4']);
+  assert.deepEqual(street({ leads: null, docket: fx('government__docket') }).depth.windows.map((w) => w.key), ['needs:disputes:0', 'needs:planning:2', 'needs:release:0', 'needs:review:1', 'needs:treasury:4']);
   // moving and settled light nothing; nor does a source no floor holds
   const doc2 = clone(doc);
   doc2.matters.forEach((m) => { m.state = 'moving'; });

package/tests/hall_street_desk.mjs

@@ -404,7 +404,8 @@ function actedDocket({ longWords = false, force = true } = {}) {
     desk('people.builders', 'people', buildersRoute.builderDeskRows([{ id: 7, display_name: t('Ana Ruiz'), github_login: 'ana', rank: 'thetes' }, { id: 95, display_name: 'Me', rank: 'archon' }], { viewerId: '95', mayRank: true, mayStop: true, ranks: LADDER })),
     desk('people.ranks', 'people', govFloors.rankDeskRows([{ rank_key: 'tester', label: t('Tester'), is_system: false }, { rank_key: 'archon', label: 'Archon', is_system: true }], [{ builder_id: 7, display_name: 'Ana Ruiz', rank_key: 'tester' }, { builder_id: 8, github_login: 'kai', rank_key: 'metic' }])),
     desk('disputes.confirmed', 'disputes', [reportsRoute.confirmedDeskRow({ id: 3, title: t('token leak'), severity: 'low', confirmed_at: '2026-09-28T10:00:00.000Z' })]),
-    desk('automation.switch', 'automation', autoDocket.switchDeskRows(project)),
+    // the switch is a standing row in either position (the fence matter is settled, never a to-do)
+    desk('automation.switch', 'automation', autoDocket.switchDeskRows({ enabled: false, paused_reason: 'payments touched', goals: [] }).map((r) => ({ ...r, id: 'switch-off' })).concat(autoDocket.switchDeskRows(project))),
     desk('automation.goals', 'automation', autoDocket.goalDeskRows(project)),
     desk('automation.runners', 'automation', autoDocket.runnerDeskRows([{ builder_id: 7, display_name: t('Ana Ruiz'), runners: [{ working_task_id: 12 }] }, { builder_id: 8, owner_paused: true, owner_paused_reason: 'spending too much', runners: [] }], NOW, healthy)),
   ];
@@ -469,10 +470,11 @@ test('Disputes: a report is confirmed or disputed, a confirmed one marked fixed,
 test('Automation: switch on and off, allow a goal from the open goals, first in line, disallow, pause and resume a runner', () => {
   const dk = actedDocket();
   const sw = actedRows(dk, 'automation', 0);
-  const off = sw.find((r) => r.source === 'autobongos_fence');
+  assert.ok(!sw.some((r) => r.source === 'autobongos_fence'), 'the switch is not a to-do: its matter is settled');
+  const off = sw.find((r) => r.actions.some((a) => a.key === 'switch_on'));
   assert.deepEqual(off.actions.map((a) => a.label), ['switch on']);
   assert.deepEqual(j(C.request(off.card, 'switch_on')), { method: 'POST', url: '/api/bongos/autonomy/fence', body: { enabled: true } });
-  const on = sw.find((r) => r.desk);
+  const on = sw.find((r) => r.actions.some((a) => a.key === 'switch_off'));
   assert.deepEqual(j(C.request(on.card, 'switch_off', on.choices.switch_off.options[0].input)).body, { enabled: false, reason: 'pause for now' });
   const goals = actedRows(dk, 'automation', 1);
   const first = goals.find((r) => r.name === 'Governor city');

package/tests/hall_tweak_editor.mjs

@@ -805,6 +805,32 @@ try {
     assert.equal(b.el('tw-frame').hidden, true);
   });
 
+  // task 1004776: a guarded line shows what it must still say under it, and the
+  // note turns to a warning while the artist types words that drop it.
+  await test('a guarded line shows its must-still-say note, and warns as the artist types it away', async () => {
+    const guarded = require('../modules/copy-desk/guarded-lines.js');
+    guarded._setList({ lines: [{ page_id: 'landing:index', file: 'modules/public-landing/public/index.html', must_contain: ['ship the code'], must_still_say: 'Agents ship the code.' }] });
+    try {
+      const ed = editorRead({ draftLines: null });
+      const b = bootEditor({ answers: { 'GET /copy-desk/pages/landing:index/draft': ok(ed) } });
+      await b.settle();
+      assert.equal(b.el('tw-L0004-note').textContent, 'must still say: Agents ship the code.');
+      assert.match(b.el('tw-L0004-note').className, /tw-note--guarded/);
+      b.type('L0004', 'Agents claim the tasks.');
+      assert.equal(b.el('tw-L0004-note').textContent, 'this no longer says what it must · must still say: Agents ship the code.');
+      b.type('L0004', 'Our agents ship the code.');
+      assert.equal(b.el('tw-L0004-note').textContent, 'must still say: Agents ship the code.');
+    } finally {
+      guarded._setList(null);
+    }
+  });
+
+  await test('the submit warning is plain words the editor shows after sending', () => {
+    assert.deepEqual(lib.submitWarningHtml([{ key: 'L0004', must_still_say: 'Agents ship the code.' }]),
+      ['A line you changed no longer says what it must: Agents ship the code. It was sent anyway; the person approving it will see this.']);
+    assert.deepEqual(lib.submitWarningHtml(undefined), []);
+  });
+
   await test('the page writes only the copy-desk routes it names', () => {
     const js = read('tweak-editor.js');
     const writes = [...js.matchAll(/api\.request\('(POST|PUT|PATCH|DELETE)', ([^,]+),/g)].map((m) => `${m[1]} ${m[2]}`);

package/tests/module_channel_install.mjs

@@ -0,0 +1,112 @@
+// tests/module_channel_install.mjs — install and update honour the channel a
+// project is on (task 1003805, ADR 0344 D1/D2, ADR 0338 D2).
+//
+// WHY. The channels exist (core_276) and new versions land on tester (task
+// 1003803), but until acquire reads them, every project got the newest version
+// whatever its channel. These pin the rule: a tester project gets the newest on
+// tester or general, everyone else the newest on general, nobody a withdrawn one,
+// and `bongos upgrade` reports the same version update would hand over. Run
+// against a fake pg client; the routes are pinned in their source.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+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 { servedChannels, resolveAcquirable, latestVersions } = require('../src/bongos/module-store.js');
+const { testsVersionsOf } = require('../src/bongos/module-testing.js');
+
+const row = (version, channel) => ({ id: 1, module_key: 'weather', version, channel, core_version: '^1.0.0', tarball_sha256: 'a'.repeat(64), tree_sha256: 'b'.repeat(64), tarball_bytes: 10, artifact_path: `weather/weather-${version}.tgz` });
+
+function fakeDb(versions) {
+  return {
+    async query(sql) {
+      if (sql.includes('FROM store_modules ')) return { rows: [{ module_key: 'weather', status: 'listed' }] };
+      if (sql.includes('FROM store_module_versions')) return { rows: versions };
+      if (sql.includes('FROM store_module_prices')) return { rows: [] };
+      throw new Error(`unhandled: ${sql}`);
+    },
+  };
+}
+const SHELF = [row('1.0.0', 'general'), row('1.1.0', 'general'), row('1.2.0', 'tester'), row('2.0.0', 'withdrawn')];
+const GENERAL = servedChannels(false);
+const TESTER = servedChannels(true);
+
+test('a tester project takes tester and general versions, everyone else general, nobody withdrawn', () => {
+  assert.deepEqual(TESTER, ['tester', 'general']);
+  assert.deepEqual(GENERAL, ['general']);
+  for (const c of [TESTER, GENERAL]) assert.ok(!c.includes('withdrawn'));
+});
+
+test('"general only" keeps a tester project on general for that one module', () => {
+  const testing = { tester: true, general_only: ['weather'] };
+  assert.deepEqual(servedChannels(testsVersionsOf(testing, 'weather')), GENERAL);
+  assert.deepEqual(servedChannels(testsVersionsOf(testing, 'clock')), TESTER);
+  assert.deepEqual(servedChannels(testsVersionsOf(null, 'clock')), GENERAL, 'an unreadable choice is not a tester');
+});
+
+test('with no version asked for, each project gets the newest on its own channels', async () => {
+  const general = await resolveAcquirable('weather', { channels: GENERAL, db: fakeDb(SHELF) });
+  assert.equal(general.version.version, '1.1.0');
+  assert.equal(general.version.channel, 'general');
+  const tester = await resolveAcquirable('weather', { channels: TESTER, db: fakeDb(SHELF) });
+  assert.equal(tester.version.version, '1.2.0', 'the newer withdrawn 2.0.0 is never handed out');
+  assert.equal(tester.version.channel, 'tester');
+});
+
+test('an exact version off the project\'s channels is refused, never handed over', async () => {
+  const early = await resolveAcquirable('weather', { version: '1.2.0', channels: GENERAL, db: fakeDb(SHELF) });
+  assert.equal(early.ok, false);
+  assert.equal(early.code, 'version_not_on_channel');
+  assert.match(early.message, /testers/);
+  const gone = await resolveAcquirable('weather', { version: '2.0.0', channels: TESTER, db: fakeDb(SHELF) });
+  assert.equal(gone.code, 'version_not_on_channel');
+  assert.match(gone.message, /withdrawn/);
+  assert.equal((await resolveAcquirable('weather', { version: '1.0.0', channels: GENERAL, db: fakeDb(SHELF) })).ok, true);
+});
+
+test('a module whose only version is still with testers has nothing for a general project yet', async () => {
+  const r = await resolveAcquirable('weather', { channels: GENERAL, db: fakeDb([row('1.0.0', 'tester')]) });
+  assert.equal(r.code, 'no_versions_on_channel');
+  assert.equal(r.status, 404);
+  assert.match(r.message, /testers/);
+  const gone = await resolveAcquirable('weather', { channels: TESTER, db: fakeDb([row('1.0.0', 'withdrawn')]) });
+  assert.equal(gone.code, 'no_versions_on_channel');
+  assert.match(gone.message, /withdrawn/);
+});
+
+test('no channels means no channel check — recording a version already placed', async () => {
+  const r = await resolveAcquirable('weather', { version: '2.0.0', db: fakeDb(SHELF) });
+  assert.equal(r.ok, true);
+});
+
+test('upgrade reports the newest version on the channels this project takes', async () => {
+  const db = { async query() { return { rows: SHELF.map((r) => ({ ...r, status: 'listed' })) }; } };
+  const general = await latestVersions(['weather'], { db, channelsFor: () => GENERAL });
+  assert.equal(general.weather.version, '1.1.0');
+  const tester = await latestVersions(['weather'], { db, channelsFor: () => TESTER });
+  assert.equal(tester.weather.version, '1.2.0');
+  assert.equal(tester.weather.channel, 'tester');
+  const none = await latestVersions(['weather'], { db, channelsFor: () => ['nothing'] });
+  assert.deepEqual(none, {});
+});
+
+test('the acquire, download and latest routes ask the project\'s channels; recording does not', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'src/bongos/routes/modules.js'), 'utf8');
+  const route = (decl) => {
+    const start = src.indexOf(decl);
+    assert.ok(start !== -1, decl);
+    return src.slice(start, src.indexOf('}));', start));
+  };
+  const acquire = route("router.post('/store/modules/:key/acquire'");
+  assert.match(acquire, /resolveAcquirable\(key, \{ version: wanted \|\| null, channels: \(await projectChannels\(\)\)\(key\) \}\)/);
+  assert.match(acquire, /channel: v\.channel,/);
+  assert.doesNotMatch(acquire, /channel: 'general'/);
+  assert.match(route("router.get('/store/modules/:key/versions/:version/tarball'"), /channels: \(await projectChannels\(\)\)\(key\)/);
+  assert.match(route("router.get('/store/modules/latest'"), /latestVersions\(keys, \{ channelsFor: await projectChannels\(\) \}\)/);
+  assert.doesNotMatch(route("router.post('/store/modules/:key/acquired'"), /channels/);
+});