@bongos/core 1.21.113 → 1.21.115

package/tests/hall_matter_card.mjs

@@ -276,7 +276,7 @@ async function bootPage({ feeds, posts = {} }) {
   };
   const ctx = vm.createContext({ window, document, fetch, Promise, Math, String, Number, Array, Object, JSON, Date, console, encodeURIComponent, decodeURIComponent, isNaN, isFinite });
   ctx.globalThis = ctx;
-  for (const f of ['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street-desk.js', 'street.js']) vm.runInContext(read(f), ctx);
+  for (const f of ['city-draw.js', 'street-draw.js', 'street-card.js', 'street-inside.js', 'street-depth.js', 'street-desk.js', 'street.js']) vm.runInContext(read(f), ctx);
   await window.GovStreetPage.ready;
   return { window, byId, calls, focused };
 }
@@ -409,6 +409,8 @@ const SOURCE_FIXTURES = () => {
     { id: 'gate_approvals:88', source: 'gate_approvals', building: 'release', rule: 'decide', state: 'needs', title: 'PR 88 waits at the gate', href: '/gate', ref: { type: 'pull_request', id: '88' } },
     { id: 'autobongos_fence:project', source: 'autobongos_fence', building: 'automation', rule: 'decide', state: 'needs', title: 'Unattended building is off', href: '/autobongos', ref: { type: 'autonomy_fence', id: 'project' }, acts: [{ key: 'switch_on' }] },
     { id: 'module_rechecks:7', source: 'module_rechecks', building: 'release', rule: 'rule', state: 'needs', title: 'image-tools 1.2.0 failed its security check', href: '/modules', ref: { type: 'module_version', id: 'image-tools@1.2.0' }, acts: [{ key: 'recheck', options: [{ key: 'fixed', label: 'fixed since' }] }] },
+    // task 1004712: a dry pot's borrow from the reserve
+    { id: 'treasury_spending:5', source: 'treasury_spending', building: 'treasury', rule: 'decide', state: 'needs', title: 'Sign-up: its pot is dry', href: '/goal/7', ref: { type: 'pot_borrow', id: '5' }, acts: [{ key: 'answer', options: [{ key: 'lend', label: 'Lend $400' }, { key: 'half', label: 'Lend $200' }, { key: 'no', label: 'Say no' }] }] },
   ];
   const d = docket(ms);
   d.desks = [{ key: 'release.core', building: 'release', status: 'live', rows: [{ id: 'release.core:41', desk: 'release.core', building: 'release', name: 'Core 1.21.20', fact: 'not checked yet', facts: [], over: 'core_update', ref: { type: 'core_pin', id: '41' }, acts: [{ key: 'check', options: [{ key: '1.21.20', label: '1.21.20' }] }] }] }];
@@ -444,6 +446,9 @@ test('every docket source kind opens a card with the desk row\'s acts when the v
   // a module version is checked again through the reassess route, with a one-tap reason
   const rc = D.cardFor('module_rechecks:7', d, { now: NOW });
   assert.deepEqual(C.request(rc.row.card, 'recheck', { option: 'fixed', label: 'fixed since' }), { method: 'POST', url: '/api/bongos/store/modules/image-tools/versions/1.2.0/reassess', body: { reason: 'Asked on the street: fixed since.' } });
+  // a dry pot's borrow is answered at the treasury route, the chip's key as the answer (task 1004712)
+  const tb = D.cardFor('treasury_spending:5', d, { now: NOW });
+  assert.deepEqual(C.request(tb.row.card, 'answer', { option: 'half', label: 'Lend $200' }), { method: 'POST', url: '/api/bongos/government/treasury/borrows/5/answer', body: { key: 'half' } });
   // the review queue's pin opens its first piece of work, with that work's acts
   const q = D.cardFor('queue', d, { room: r, now: NOW });
   assert.equal(q.key, 'criteria_uat:3');

package/tests/hall_my_agents.mjs

@@ -0,0 +1,481 @@
+// tests/hall_my_agents.mjs — MY AGENTS and "governing is a position" (task 1004685,
+// the living-city prototype; round-3 boards 6-8).
+//
+// What it pins:
+//   1. gov-positions.js: the seats a viewer holds are /me's server-resolved
+//      `positions` block (task 1004713) and nothing else; ?as=nobody only ever
+//      takes away; unknown is unknown, never "none"; and it is pure.
+//   2. my-agents.js buildView over the real fixtures: real rows carry /me's own
+//      values, laws lock exactly the rows they name under each preset, an
+//      `overlay` handed in changes nothing (task 1004717 deleted it), the session-start
+//      panel quotes the real contract, and a habit is a real non-default choice.
+//   3. every write goes to a route the builder-settings module really mounts, and
+//      the harness recorder answers it with the real shapers.
+//   4. craft-mode.js: no seat → no Governing anywhere, a stored Governing reads as
+//      no mode; a seat names the mode; unknown is today's picker.
+//   5. the page itself: in the hall's family, no prototype key, the
+//      fifteen tokens only, dark twins byte-identical, motion on transform only and
+//      dead under the kill switch.
+//
+// Run:  node --test --test-reporter=tap tests/hall_my_agents.mjs
+
+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 require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules', 'hall-ui', 'public');
+const FX = path.join(ROOT, 'scripts', 'hall-preview', 'fixtures');
+const read = (f) => fs.readFileSync(path.join(HALL, f), 'utf8');
+const fx = (name) => JSON.parse(fs.readFileSync(path.join(FX, name + '.json'), 'utf8'));
+
+const GovPositions = require(path.join(HALL, 'gov-positions.js'));
+const GovLiving = require(path.join(HALL, 'gov-living.js'));
+const MyAgents = require(path.join(HALL, 'my-agents.js'));
+const LIBS = { GovLiving, GovPositions };
+const NOW = Date.parse('2026-10-09T14:00:00.000Z');
+// the kind of thing the deleted prototype overlay said: settings no table holds,
+// invented laws and a preset. Handed in, none of it may show.
+const OLD_OVERLAY = {
+  personal_settings: [{ key: 'when_stuck', label: 'When stuck', values: ['ask', 'try'], value: 'ask' }, { key: 'agents_at_once', label: 'Agents at once', values: [1, 2, 3], value: 3 }],
+  laws: [{ id: 'one-agent', text: 'One agent at a time', locks: [{ setting: 'wandering', max: 'focused' }] }],
+  strictness: { current: 'factory', presets: [{ key: 'factory', name: 'Factory', line: 'x' }] },
+  leads: [{ building: 'planning', lead: '1000025', charter: { scope: 'x' } }],
+};
+
+const viewOf = (over = {}) => MyAgents.buildView({
+  me: fx('me'), constitution: fx('government__constitution'), presets: fx('government__presets'),
+  skills: fx('me__skill-prefs'), specialities: fx('specialities'), project: 'Cloud Bongos', now: NOW, ...over,
+}, LIBS);
+const rows = (v) => v.groups.flatMap((g) => g.rows);
+const row = (v, key) => rows(v).find((r) => r.key === key);
+const codeOf = (src) => src.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:'"`\\])\/\/.*$/gm, '$1');
+
+// ---------------------------------------------------------------------------
+// 1. the seats
+// ---------------------------------------------------------------------------
+
+const lead = (building) => ({ kind: 'lead', seat: 'lead:' + building, building, title: GovPositions.BUILDING_NAMES[building] + ' Lead' });
+const withSeats = (held, builder = { id: '424242', rank: 'thetes' }) => ({ builder, positions: { held, title: held.length ? held[0].title : null, has_position: held.length > 0 } });
+
+test('SEATS: the seats are /me\'s positions block, exactly as the server resolved them', () => {
+  const me = fx('me');
+  const p = GovPositions.positionsFor({ me });
+  assert.equal(p.known, true);
+  assert.deepEqual(p.positions.map((s) => s.kind), me.positions.held.map((s) => s.kind));
+  assert.equal(p.title, me.positions.held[0].title, 'the first seat names the Governing mode');
+  assert.ok(p.positions.every((s) => s.source === 'real'), 'every seat is the server\'s');
+});
+
+test('SEATS: a Lead is named by their seat', () => {
+  for (const b of Object.keys(GovPositions.BUILDING_NAMES)) {
+    const p = GovPositions.positionsFor({ me: withSeats([lead(b)]) });
+    assert.equal(p.title, GovPositions.BUILDING_NAMES[b] + ' Lead', b);
+    assert.equal(p.has_position, true);
+  }
+});
+
+test('SEATS: nothing is re-derived here — no rank, craft, constitution or overlay makes a seat', () => {
+  const none = withSeats([], { id: '1000025', rank: 'archon', preferred_disciplines: ['governing'] });
+  const p = GovPositions.positionsFor({ me: none, overlay: OLD_OVERLAY, constitution: fx('government__constitution') });
+  assert.equal(p.known, true);
+  assert.equal(p.has_position, false, 'the server said none: an archon who picked every craft, named Planning Lead by an overlay, still holds none');
+  const odd = GovPositions.positionsFor({ me: withSeats([{ kind: 'committee', title: 'Made up' }, lead('review')]) });
+  assert.deepEqual(odd.positions.map((s) => s.kind), ['lead'], 'a kind the server does not name is dropped');
+});
+
+test('SEATS: unknown is unknown — /me with no positions block is not "holds none"', () => {
+  const me = fx('me');
+  delete me.positions;
+  assert.equal(GovPositions.positionsFor({ me }).known, false);
+  assert.equal(GovPositions.positionsFor({ me: { ...me, positions: null } }).known, false, 'a null block (unreadable) is unknown');
+  assert.equal(GovPositions.positionsFor({}).known, false, 'no viewer, no answer');
+});
+
+test('SEATS: ?as=nobody takes every seat away and never raises a rank', () => {
+  const p = GovPositions.positionsFor({ me: fx('me'), as: 'nobody' });
+  assert.equal(p.known, true);
+  assert.equal(p.has_position, false);
+  assert.equal(p.sim_rank, 'thetes', 'an archon is shown as a thetes');
+  assert.notEqual(p.viewer_id, fx('me').builder.id, 'the stand-in is nobody');
+  const xenos = GovPositions.positionsFor({ me: withSeats([lead('planning')], { id: '9', rank: 'xenos' }), as: 'nobody' });
+  assert.equal(xenos.sim_rank, 'xenos', 'a xenos stand-in stays a xenos');
+  assert.equal(GovPositions.positionsFor({ me: fx('me'), as: 'archon' }).as, null, 'only "nobody" is honoured');
+});
+
+test('SEATS: the kinds the hall reads are the kinds the server names', () => {
+  const { KINDS } = require(path.join(ROOT, 'modules', 'government', 'positions.js'));
+  assert.deepEqual([...GovPositions.KINDS], [...KINDS]);
+});
+
+test('SEATS: gov-positions.js is pure — no window, document, fetch or clock', () => {
+  const code = codeOf(read('gov-positions.js'));
+  const tail = "typeof window !== 'undefined' ? window : globalThis";
+  assert.ok(code.includes(tail));
+  const body = code.replace(tail, '');
+  for (const [name, re] of Object.entries({ window: /\bwindow\b/, document: /\bdocument\b/, fetch: /\bfetch\b/, 'Date.now': /Date\.now/, storage: /Storage/ })) {
+    assert.doesNotMatch(body, re, `${name} must not appear in gov-positions.js`);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// 2. the view
+// ---------------------------------------------------------------------------
+
+test('VIEW: a real row carries the viewer\'s own value from /me', () => {
+  const v = viewOf();
+  const me = fx('me');
+  for (const f of me.interaction.fields) assert.equal(row(v, f.field).effective, me.interaction.effective[f.field], f.field);
+  assert.equal(row(v, 'wandering').value, me.wandering.effective_key, 'the viewer\'s own wandering is the real one');
+  for (const s of me.model_allocation.slots) assert.equal(row(v, 'model.' + s.slot).effective, me.model_allocation.effective[s.slot]);
+  assert.equal(row(v, 'render').effective, me.render.level);
+  assert.match(row(v, 'skills').fact, new RegExp('^' + fx('me__skill-prefs').effective.length + ' skills'));
+  assert.equal(row(v, 'sounds').fact, 'all off for now', 'sounds are off by the owner\'s call');
+  assert.ok(rows(v).every((r) => r.name.split(/\s+/).length <= 3), 'a row name is three words at most');
+});
+
+test('VIEW: no row is prototype data, and only a real law locks one (task 1004714)', () => {
+  const v = viewOf();
+  assert.equal(rows(v).some((r) => 'proto' in r), false, 'no row carries a prototype flag');
+  const ov = viewOf({ overlay: OLD_OVERLAY });
+  for (const s of OLD_OVERLAY.personal_settings) assert.equal(row(ov, s.key), undefined, s.key + ' (no table holds it) is not a row');
+  assert.equal(ov.counts.locked, 0, 'the hub has no law in force: nothing is locked, whatever an overlay\'s preset');
+  assert.equal(row(ov, 'wandering').effective, fx('me').wandering.effective_key, 'an invented law does not cap wandering');
+  assert.equal(row(v, 'wandering').advised, undefined, 'nor advise it');
+  for (const preset of ['open', 'guild', 'factory']) {
+    assert.equal(viewOf({ preview: preset }).counts.locked, 0, 'previewing ' + preset + ' locks no row');
+  }
+  assert.ok(rows(v).every((r) => r.lock === null || r.lock.real), 'every lock there is is real');
+  assert.deepEqual(v._sources.groups, 'real');
+});
+
+// The server's presets read (GET /government/presets) over a law book, as the
+// route builds it — the pure half of modules/government/presets.js.
+const Presets = require(path.join(ROOT, 'modules', 'government', 'presets.js'));
+const bookOf = (key) => {
+  const sw = Presets.switchProposal(key, []);
+  return sw.proposal.enact.map((l, i) => ({ id: String(i + 1), ...l, repealed_at: null }));
+};
+
+test('VIEW: the strictness strip is real (task 1004715): GET /government/presets, counted against your rows', () => {
+  const v = viewOf();
+  assert.equal(v._sources.strict, 'real');
+  assert.equal(v.strict.real, true);
+  assert.equal(v.strict.current, null, 'the hub has no law in force: no preset is');
+  assert.equal(v.strict.locked, 0, 'and nothing is locked');
+  assert.equal(v.strict.total, v.counts.total, 'over the same rows the desk shows');
+  const n = Object.fromEntries(v.strict.presets.map((p) => [p.key, p.locks]));
+  assert.deepEqual(n, { open: 0, guild: 1, factory: 4 }, 'open locks nothing; guild caps off-task; factory adds the three model caps');
+  const factory = viewOf({ preview: 'factory' });
+  assert.equal(factory.strict.previewing, true);
+  assert.equal(factory.strict.locked, 4);
+  assert.equal(factory.strict.locked, factory.strict.pips.filter(Boolean).length, 'one lit pip per row it would hold');
+  assert.equal(factory.counts.locked, 0, 'a preview locks no row');
+  assert.equal(factory.strict.canSwitch, true, 'a builder who may open a board item may put it to a vote');
+  assert.equal(factory.strict.filed, null);
+  assert.equal(viewOf({ preview: 'factory', switched: { factory: '77' } }).strict.filed, '77', 'once filed, the strip links the vote');
+  const noPerm = viewOf({ preview: 'factory', me: { ...fx('me'), permissions: { 'board.vote.cast': true } } });
+  assert.equal(noPerm.strict.canSwitch, false, 'without board.item.open there is no switch');
+  assert.equal(v.strict.canSwitch, false, 'no switch without a preview');
+  assert.equal(viewOf({ preview: 'no-such' }).strict.previewing, false, 'an unknown preset is no preview');
+});
+
+test('VIEW: the preset in force is the one the laws in force amount to; previewing it is no preview', () => {
+  const guild = viewOf({ presets: Presets.presetsView(bookOf('guild')) });
+  assert.equal(guild.strict.current.key, 'guild');
+  assert.equal(guild.strict.locked, 1, 'guild holds off-task');
+  assert.equal(guild.strict.pips.filter(Boolean).length, 1);
+  assert.equal(viewOf({ presets: Presets.presetsView(bookOf('guild')), preview: 'guild' }).strict.previewing, false);
+  assert.equal(viewOf({ presets: null }).strict, null, 'no presets read, no strip');
+});
+
+test('VIEW: an overlay handed in changes nothing — the whole view reads the same', () => {
+  assert.deepEqual(viewOf({ overlay: OLD_OVERLAY }), viewOf(), 'the overlay is not read');
+  assert.equal('governed' in viewOf(), false, 'and nothing says the page is "governed" by one');
+});
+
+test('VIEW: what the agent reads first — the project\'s REAL laws (GET /me laws, task 1004707), then the REAL contract text', () => {
+  const v = viewOf();
+  const me = fx('me');
+  // the hub has passed no law: nothing is sent, and an invented law is never "read"
+  assert.deepEqual(viewOf({ overlay: OLD_OVERLAY }).reads.laws, [], 'an overlay\'s laws are not what an agent reads');
+  assert.deepEqual(v.reads.laws, []);
+  assert.equal(v.reads.sent, false);
+  assert.equal(v._sources['reads.laws'], 'real');
+  // a law in force: exactly the book GET /me carries, in its numbering, sent first
+  const withLaw = { ...fx('me'), laws: { inject: true, contract: 'Project laws — …\n1. Ask like a human', laws: [{ id: '11', no: 1, text: 'Ask like a human', effect_on_ai: 'One short card.', locks: [] }], locks: [] } };
+  const lv = viewOf({ me: withLaw });
+  assert.deepEqual(lv.reads.laws, [{ id: '11', no: 1, text: 'Ask like a human', effect: 'One short card.' }]);
+  assert.equal(lv.reads.sent, true);
+  const said = v.reads.mine.find((x) => x.key === 'interaction');
+  assert.equal(said.text, me.interaction.contract, 'the interaction profile is quoted, not paraphrased');
+  assert.equal(said.sent, me.interaction.inject);
+  const wander = v.reads.mine.find((x) => x.key === 'wandering');
+  assert.equal(wander.sent, false, 'exploratory is not injected (wandering-prefs.js inject:false)');
+  assert.match(wander.note, /^Not sent/);
+});
+
+test('VIEW: a law in force (GET /me laws.locks) locks the row it names, as real, numbered in the real book', () => {
+  const me = fx('me');
+  me.interaction.effective = { ...me.interaction.effective, verbosity: 'concise' };
+  me.laws = {
+    inject: true, contract: 'Project laws — …', laws: [{ id: '11', no: 1, text: 'Ask like a human', effect_on_ai: null, locks: [{ setting: 'verbosity', value: 'concise' }] }],
+    locks: [{ setting: 'verbosity', law_id: '11', law_no: 1, law_text: 'Ask like a human', value: 'concise', route: 'interaction', enforced: true, from: 'detailed', to: 'concise' }],
+  };
+  for (const overlay of [OLD_OVERLAY, null]) {
+    const r = row(viewOf({ me, overlay }), 'verbosity');
+    assert.equal(r.locked, true);
+    assert.deepEqual(r.lock, { law_id: 'law:11', no: 1, text: 'Cloud Bongos: Ask like a human · Law 1', real: true });
+    assert.equal(r.fact, 'short', 'the law\'s value');
+    assert.equal(r.yours, 'detailed', 'and theirs, still said');
+  }
+});
+
+// a law that only CAPS a setting (1004707 locked the whole row for it)
+const meCapped = () => {
+  const me = fx('me');
+  me.wandering = { ...me.wandering, effective_key: 'focused' };
+  me.laws = {
+    inject: true, contract: 'Project laws — …', laws: [{ id: '12', no: 1, text: 'Stay near the task', effect_on_ai: null, locks: [{ setting: 'wandering', max: 'balanced' }] }],
+    locks: [{ setting: 'wandering', law_id: '12', law_no: 1, law_text: 'Stay near the task', max: 'balanced', route: 'wandering', enforced: true, from: 'exploratory', to: 'focused', allowed: ['locked', 'focused', 'balanced'] }],
+  };
+  return me;
+};
+
+test('VIEW: a law that only CAPS a setting offers the values under the cap, not a locked row (task 1004714)', () => {
+  for (const overlay of [OLD_OVERLAY, null]) {
+    const r = row(viewOf({ me: meCapped(), overlay }), 'wandering');
+    assert.equal(r.locked, false, 'a cap is not a lock');
+    assert.deepEqual(r.options.map((o) => o.value), ['locked', 'focused', 'balanced'].filter((k) => fx('me').wandering.levels.some((l) => l.key === k && l.allowed !== false)),
+      'the chips are the values under the cap, in order');
+    assert.equal(r.options.find((o) => o.pressed).value, 'focused', 'the effective value is the one pressed');
+    assert.deepEqual(r.cap, { law_id: 'law:12', no: 1, text: 'Cloud Bongos: Stay near the task · Law 1', max: 'balanced', real: true });
+    assert.equal(r.yours, 'roams', 'and their own choice, past the cap, is still said');
+  }
+  // a cap that leaves a single value is a lock in all but name
+  const me = meCapped();
+  me.laws.locks[0].allowed = ['locked'];
+  me.wandering.effective_key = 'locked';
+  assert.equal(row(viewOf({ me }), 'wandering').locked, true);
+  // a server that names no allowed values: the safe reading is the whole-row lock
+  const old = meCapped();
+  delete old.laws.locks[0].allowed;
+  assert.equal(row(viewOf({ me: old }), 'wandering').locked, true);
+});
+
+test('VIEW: a habit is a real non-default choice no law already holds, offered to who may propose a law', () => {
+  const v = viewOf();
+  const me = fx('me');
+  assert.equal(v.canPropose, true, 'the fixture viewer may open a board item');
+  const expected = ['machinery'].concat(me.wandering.override_level != null ? ['wandering'] : []);
+  assert.deepEqual(v.habits.map((h) => h.key), expected);
+  const mach = v.habits.find((h) => h.key === 'machinery');
+  assert.equal(mach.law, 'Agents hide the machinery');
+  assert.deepEqual(mach.lock, { setting: 'machinery', value: 'quiet' }, 'the law would lock the setting to their value');
+  assert.equal(viewOf({ proposed: { machinery: '77' } }).habits.find((h) => h.key === 'machinery').item, '77', 'a proposed habit points at its vote');
+  assert.equal(viewOf({ me: meCapped() }).habits.some((h) => h.key === 'wandering'), false, 'a setting a law already caps is no habit');
+  const noPerm = fx('me');
+  noPerm.permissions = { ...noPerm.permissions, 'board.item.open': false };
+  assert.deepEqual(viewOf({ me: noPerm }).habits, [], 'no right to open a board item, no Make it a law');
+  assert.equal(viewOf({ me: noPerm }).canPropose, false);
+  const unknown = fx('me');
+  delete unknown.permissions;
+  assert.equal(viewOf({ me: unknown }).canPropose, false, 'an unreadable permission map offers nothing');
+});
+
+test('PROPOSE: Make it a law files a valid laws vote — the server\'s own validator accepts it', () => {
+  const laws = require(path.join(ROOT, 'modules', 'government', 'laws.js'));
+  const routes = fs.readFileSync(path.join(ROOT, 'modules', 'government', 'routes', 'government.js'), 'utf8');
+  assert.match(routes, /router\.post\('\/government\/board\/laws'/, 'the route is mounted');
+  const v = viewOf();
+  for (const h of v.habits) {
+    const body = MyAgents.proposalFor(h, 'someone');
+    const checked = laws.validateLawsProposal({ enact: body.enact });
+    assert.equal(checked.ok, true, h.key + ': ' + JSON.stringify(checked));
+    assert.deepEqual(checked.proposal.enact[0].locks, [h.lock]);
+    assert.equal(typeof body.rationale_md, 'string');
+  }
+  assert.match(read('my-agents.js'), /'\/government\/board\/laws'/, 'the page posts there');
+  assert.doesNotMatch(codeOf(read('my-agents.js')), /'\/inbox'/, 'not an idea any more');
+});
+
+test('VIEW: buildView is pure and leaves its inputs alone', () => {
+  const input = { me: fx('me'), constitution: fx('government__constitution'), project: 'P', now: NOW };
+  const before = JSON.stringify(input);
+  const one = MyAgents.buildView(input, LIBS);
+  assert.equal(JSON.stringify(input), before);
+  assert.deepEqual(MyAgents.buildView(input, LIBS), one);
+});
+
+// ---------------------------------------------------------------------------
+// 3. the writes
+// ---------------------------------------------------------------------------
+
+test('WRITES: every real row writes to a route builder-settings really mounts', () => {
+  const routes = fs.readFileSync(path.join(ROOT, 'modules', 'builder-settings', 'routes', 'settings.js'), 'utf8');
+  const mounted = new Set([...routes.matchAll(/router\.patch\('([^']+)'/g)].map((m) => m[1]));
+  const me = fx('me');
+  const v = viewOf();
+  for (const r of rows(v).filter((x) => x.control === 'chips')) {
+    const w = MyAgents.writeFor(r.key, r.options[0].value, { me });
+    assert.ok(w, `${r.key} has a write`);
+    assert.equal(w.method, 'PATCH');
+    assert.ok(mounted.has(w.path), `${w.path} is mounted`);
+  }
+  assert.deepEqual(MyAgents.writeFor('wandering', 'focused', { me }).body, { wandering: 1 }, 'wandering writes its level number');
+  assert.equal(MyAgents.writeFor('on_stuck', 'skip', { me }), null, 'a setting no table holds has no route');
+  assert.ok(mounted.has(MyAgents.writeFor('skill.builder-ship', 'opus', { me }).path));
+});
+
+test('WRITES: the harness recorder answers with the real shapers and lays the result over later reads', () => {
+  const { createPrefRecorder } = require(path.join(ROOT, 'scripts', 'hall-preview', 'pref-writes.js'));
+  const logged = [];
+  const rec = createPrefRecorder({ log: (l) => logged.push(l) });
+  const me = fx('me');
+  const ok = rec.write('me/interaction', { verbosity: 'detailed' }, { me, skillFixture: fx('me__skill-prefs') });
+  assert.equal(ok.status, 200);
+  assert.equal(ok.body.effective.verbosity, 'detailed');
+  assert.match(ok.body.contract, /Verbosity: detailed/, 'the contract text is the real one, regenerated');
+  assert.equal(ok.body.effective.machinery, 'quiet', 'the stored fields survive');
+  assert.equal(rec.write('me/interaction', { verbosity: 'loud' }, { me }).status, 422, 'a bad value is the real 422');
+  const after = rec.overlay('me', me);
+  assert.equal(after.interaction.effective.verbosity, 'detailed', 'GET /me shows it');
+  assert.notEqual(after.render.level, me.render.level, 'and the derived card level moves with it, as the real one does');
+  assert.equal(rec.write('me/wandering', { wandering: 1 }, { me }).body.effective_key, 'focused');
+  assert.equal(rec.write('me/skill-prefs', { 'builder-ship': 'opus' }, { me }).body.prefs['builder-ship'], 'opus');
+  assert.equal(rec.handles('PATCH', 'me/interaction'), true);
+  assert.equal(rec.handles('POST', 'inbox'), false, 'only the five pref routes are recorded');
+  assert.ok(logged.every((l) => /^ {2}recorded: PATCH me\//.test(l)));
+});
+
+// ---------------------------------------------------------------------------
+// 4. the craft mode
+// ---------------------------------------------------------------------------
+
+function bootCraft({ session = {} } = {}) {
+  const el = (html = '') => {
+    const attrs = {};
+    return {
+      _html: html, dataset: {}, style: {}, children: [],
+      classList: { add() {}, remove() {}, toggle() {}, contains() { return false; } },
+      setAttribute(k, v) { attrs[k] = String(v); }, getAttribute(k) { return k in attrs ? attrs[k] : null; },
+      hasAttribute(k) { return k in attrs; }, removeAttribute(k) { delete attrs[k]; },
+      addEventListener() {}, appendChild(c) { this.children.push(c); return c; }, removeChild() {},
+      querySelector() { return null; }, querySelectorAll() { return []; }, focus() {}, contains() { return false; },
+      set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+    };
+  };
+  const root = el();
+  const body = el();
+  const mk = (o) => ({ getItem: (k) => (k in o ? o[k] : null), setItem: (k, v) => { o[k] = String(v); }, removeItem: (k) => { delete o[k]; } });
+  const document = {
+    documentElement: root, body, activeElement: null,
+    getElementById: () => null, querySelector: () => null, querySelectorAll: () => [],
+    createElement: () => el(), addEventListener() {}, removeEventListener() {}, dispatchEvent() { return true; },
+  };
+  const window = { location: { search: '' }, matchMedia: () => ({ matches: false }), sessionStorage: mk(session), localStorage: mk({}) };
+  const sandbox = { window, document, console, CustomEvent: class { constructor(t, i) { this.type = t; Object.assign(this, i); } } };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(read('craft-mode.js'), sandbox, { filename: 'craft-mode.js' });
+  return { craft: window.OTBCraftMode, root, body, session };
+}
+const seatOf = (has, title) => ({ known: true, has_position: has, title: has ? title : null });
+
+test('CRAFT: with no seat, Governing is not offered anywhere', () => {
+  const b = bootCraft();
+  b.craft.setPositions(seatOf(false));
+  assert.match(b.craft.switchHtml(), /data-craft-opt="governing"[^>]* hidden>/, 'the switch hides it');
+  b.craft.choose('governing');
+  assert.equal(b.root.dataset.craft, undefined, 'and choosing it does nothing');
+  b.craft.open();
+  const picker = b.body.children[0];
+  assert.ok(picker, 'the picker opened');
+  assert.doesNotMatch(picker.innerHTML, /data-craft-pick="governing"/, 'no Governing door');
+  assert.match(picker.innerHTML, /data-doors="3"/, 'three doors, laid out as three');
+});
+
+test('CRAFT: a stored Governing reads as no mode for a builder known to hold no seat', () => {
+  const b = bootCraft({ session: { 'hall-craft': 'governing' } });
+  assert.equal(b.craft.current(), 'governing', 'unknown seats: today\'s behaviour');
+  b.craft.setPositions(seatOf(false));
+  assert.equal(b.craft.current(), null);
+  assert.equal(b.session['hall-craft'], undefined, 'and the stored choice is dropped');
+});
+
+test('CRAFT: a seat names the Governing mode', () => {
+  const b = bootCraft();
+  b.craft.setPositions(seatOf(true, 'Treasury Lead'));
+  assert.equal(b.craft.seatName(), 'Treasury Lead');
+  assert.match(b.craft.switchHtml(), /data-craft-opt="governing"[^>]*>[\s\S]*?Treasury Lead<\/span>/);
+  b.craft.choose('governing');
+  assert.equal(b.root.dataset.craft, 'governing');
+  b.craft.open();
+  assert.match(b.body.children[0].innerHTML, /craft-door__name">Treasury Lead</);
+  assert.match(b.body.children[0].innerHTML, /data-doors="4"/);
+});
+
+test('CRAFT: unknown seats are today\'s picker — four doors and a free Governing', () => {
+  const b = bootCraft();
+  b.craft.setPositions(null);
+  assert.equal(b.craft.seatName(), null);
+  assert.doesNotMatch(b.craft.switchHtml(), / hidden>/);
+  assert.match(b.craft.switchHtml(), />Governing<\/span>/);
+  b.craft.setPositions({ known: false, has_position: false });
+  b.craft.choose('governing');
+  assert.equal(b.root.dataset.craft, 'governing', 'an unknown answer never takes the mode away');
+});
+
+// ---------------------------------------------------------------------------
+// 5. the page
+// ---------------------------------------------------------------------------
+
+test('PAGE: in the hall family, with no prototype key', () => {
+  const html = read('my-agents.html');
+  assert.match(html, /<body data-page="my-agents"/);
+  const sheets = [...html.matchAll(/href="\/builders\/([a-z-]+\.css)/g)].map((m) => m[1]);
+  assert.deepEqual(sheets, ['style.css', 'oversight.css', 'my-agents.css'], 'rides the oversight archetype, linked before its own sheet');
+  const scripts = [...html.matchAll(/src="\/builders\/([a-z-]+)\.js/g)].map((m) => m[1]);
+  assert.deepEqual(scripts.slice(0, 3), ['shell-trail', 'craft-mode', 'shell']);
+  for (const s of ['gov-living', 'gov-positions', 'my-agents']) assert.ok(scripts.includes(s), `loads ${s}.js`);
+  assert.doesNotMatch(html, /ma-key|data-proto|Prototype data/, 'nothing on the page is prototype data, so there is no key');
+  assert.doesNotMatch(read('my-agents.js'), /governor-overlay/, 'and it reads no overlay');
+  assert.match(html, /id="hall-main"/);
+  assert.ok(fs.existsSync(path.join(HALL, 'my-agents.states.json')), 'the kit can render it');
+});
+
+test('PAGE: the sheet spends the fifteen tokens only, and no :root', () => {
+  const css = codeOf(read('my-agents.css'));
+  assert.doesNotMatch(css, /(^|[},])\s*:root\s*\{/, 'no page :root');
+  assert.doesNotMatch(css, /#[0-9a-f]{3,8}\b/i, 'no hex literal');
+  assert.doesNotMatch(css, /\brgba?\(|\bhsla?\(/, 'no rgb/hsl literal');
+  assert.doesNotMatch(css, /--accent\b(?!-ink)/, 'the accent is not spent here (salmon means "needs you")');
+});
+
+test('PAGE: the dark twins are byte-identical, and motion is transform-only and killed', () => {
+  const css = read('my-agents.css');
+  const twin = (re) => { const m = re.exec(css); assert.ok(m, 'twin found'); return m[1].replace(/\s+/g, ' ').trim(); };
+  assert.equal(
+    twin(/html\[data-theme="dark"\] body\[data-page="my-agents"\] \{([^}]*)\}/),
+    twin(/html:not\(\[data-theme\]\) body\[data-page="my-agents"\] \{([^}]*)\}/));
+  for (const m of css.matchAll(/@keyframes [\w-]+ \{([\s\S]*?)\}\s*\}/g)) {
+    const props = [...m[1].matchAll(/([a-z-]+)\s*:/g)].map((x) => x[1]);
+    assert.ok(props.every((p) => p === 'transform'), `a keyframe animates transform only (${props.join(', ')})`);
+  }
+  const transitions = [...css.matchAll(/transition:\s*([^;]+);/g)].map((m) => m[1]).filter((v) => !/^none\b/.test(v));
+  assert.ok(transitions.length >= 1, 'the saved tick transitions');
+  for (const t of transitions) assert.match(t, /^transform\b/, 'a transition moves transform only');
+  assert.match(css, /@media \(prefers-reduced-motion: reduce\) \{\s*body\[data-page="my-agents"\] \*,[\s\S]*animation: none !important; transition: none !important;/);
+});
+
+test('PAGE: no animation loop or timer-driven motion in the page script', () => {
+  const code = codeOf(read('my-agents.js'));
+  assert.doesNotMatch(code, /requestAnimationFrame|setInterval/);
+  // the one timer takes the saved tick's attribute back off; CSS plays the motion
+  assert.equal((code.match(/setTimeout\(/g) || []).length, 1);
+});