@bongos/core 1.21.113 → 1.21.114

package/tests/government_laws_session.mjs

@@ -0,0 +1,321 @@
+// tests/government_laws_session.mjs — the project's laws are read into every AI
+// session, and a law's lock on a personal setting is ENFORCED (task 1004707,
+// goal 1000111 "government is how a project steers its AI").
+//
+// What this pins (the task's three done-when lines, and the walls behind them):
+//   1. A SESSION ON A PROJECT WITH LAWS SHOWS THE LAWS BLOCK. The government
+//      port's lawsForSession turns the laws in force into one numbered block;
+//      GET /me carries it (static wiring pin here, the hook run for real in
+//      tests/conductor_main_e2e.mjs); the Conductor relays it verbatim, ahead of
+//      the builder's own contracts. No law in force → no block, no context spent.
+//   2. CHANGING A LAW CHANGES WHAT THE NEXT SESSION READS. The port reads the
+//      book per call (no cache), and the Conductor's advisory id carries a hash
+//      of the words, so a changed law re-emits even inside one session.
+//   3. A LOCK IS ENFORCED, NOT JUST SHOWN. On every READ the effective value
+//      obeys the lock (a value stored before the law passed included) and the
+//      injected contracts say the locked value; on every WRITE a value the lock
+//      does not allow is refused 409 and nothing is saved; with the laws
+//      unreadable a write is refused 503, never let through on a guess. The rank
+//      still caps wandering: a law cannot lift a builder past it.
+//
+// DB-free: db reads/writes are monkeypatched by property.
+//
+// Run:  node --test tests/government_laws_session.mjs
+
+import { strict as assert } from 'node:assert';
+import { test, after } from 'node:test';
+import http from 'node:http';
+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 laws = require(path.join(ROOT, 'modules', 'government', 'laws.js'));
+const govDb = require(path.join(ROOT, 'modules', 'government', 'db.js'));
+const lawLocks = require(path.join(ROOT, 'modules', 'builder-settings', 'law-locks.js'));
+const settingsPort = require(path.join(ROOT, 'modules', 'builder-settings', 'settings.js'));
+const interactionPrefs = require(path.join(ROOT, 'modules', 'builder-settings', 'interaction-prefs.js'));
+const wanderingPrefs = require(path.join(ROOT, 'modules', 'builder-settings', 'wandering-prefs.js'));
+const conductor = require(path.join(ROOT, '.claude', 'hooks', 'conductor.js'));
+
+// Law rows as db.listLaws returns them (in force, oldest first).
+const row = (id, text, extra = {}) => ({ id, text, effect_on_ai: null, locks: [], passed_by_item_id: 90 + id, passed_at: '2026-10-09T00:00:00Z', repealed_at: null, ...extra });
+const ASK = row(11, 'Ask like a human', { effect_on_ai: 'Every question to a person is one short card.', locks: [{ setting: 'verbosity', value: 'concise' }, { setting: 'ask_format', value: 'card' }] });
+const LAND = row(12, 'Land only. Ask before going live', { locks: [{ setting: 'wandering', max: 'focused' }, { setting: 'model.main', max: 'sonnet' }] });
+
+// ── 1. the block a session reads ────────────────────────────────────────────
+
+test('the laws in force become one numbered block: each law one line, its meaning and its locks beside it', () => {
+  const s = laws.forSession([ASK, LAND]);
+  assert.equal(s.inject, true);
+  assert.deepEqual(s.laws.map((l) => [l.id, l.no, l.text]), [['11', 1, 'Ask like a human'], ['12', 2, 'Land only. Ask before going live']]);
+  const lines = s.contract.split('\n');
+  assert.match(lines[0], /^Project laws — passed by a vote of this project's government\. Every AI agent on the project obeys them/);
+  assert.match(lines[0], /come before this builder's own settings/);
+  assert.equal(lines[1], '1. Ask like a human — Every question to a person is one short card. (locks: verbosity is fixed at concise; ask_format is fixed at card)');
+  assert.equal(lines[2], '2. Land only. Ask before going live (locks: wandering is at most focused; model.main is at most sonnet)');
+  assert.equal(lines.length, 3, 'one line per law, nothing else');
+});
+
+test('no law in force → no block at all (a project with no laws spends no context); a repealed law is never read', () => {
+  assert.deepEqual(laws.forSession([]), { laws: [], contract: '', inject: false });
+  assert.deepEqual(laws.forSession(null), { laws: [], contract: '', inject: false });
+  const s = laws.forSession([row(3, 'Gone now', { repealed_at: '2026-10-01T00:00:00Z' }), ASK]);
+  assert.deepEqual(s.laws.map((l) => l.id), ['11']);
+  assert.doesNotMatch(s.contract, /Gone now/);
+});
+
+test('the government port reads the book on EVERY call — a law passed or repealed is in the next session', async () => {
+  const { governmentPort } = require(path.join(ROOT, 'modules', 'government', 'routes', 'government.js'));
+  const orig = govDb.listLaws;
+  let book = [ASK];
+  let reads = 0;
+  govDb.listLaws = async (opts) => { reads += 1; assert.ok(!opts || !opts.includeRepealed, 'in force only'); return book; };
+  try {
+    const first = await governmentPort.lawsForSession();
+    assert.match(first.contract, /Ask like a human/);
+    book = [ASK, LAND];
+    const second = await governmentPort.lawsForSession();
+    assert.match(second.contract, /Land only/);
+    book = [];
+    const third = await governmentPort.lawsForSession();
+    assert.equal(third.inject, false);
+    assert.equal(reads, 3, 'no cache between sessions');
+  } finally { govDb.listLaws = orig; }
+});
+
+test('GET /me carries the block and resolves the settings slices through the locks (wiring pin)', () => {
+  const src = fs.readFileSync(path.join(ROOT, 'src', 'bongos', 'routes', 'me.js'), 'utf8');
+  assert.match(src, /government\.lawsForSession\(\)/, '/me reads the laws through the government port');
+  assert.match(src, /settings\.describeWithLaws\(behaviorPrefs, \(sessionLaws && sessionLaws\.laws\) \|\| \[\]/, 'the slices are resolved with the laws applied');
+  for (const slice of ['wandering', 'interaction', 'model_allocation']) {
+    assert.match(src, new RegExp(`${slice}: lawed \\? lawed\\.${slice} :`), `${slice} reads the locked slice`);
+  }
+  assert.match(src, /laws: sessionLaws \? \{/, '/me answers a laws block');
+  assert.equal(typeof settingsPort.describeWithLaws, 'function');
+});
+
+// ── 2. the Conductor relays it, and a change re-emits ──────────────────────
+
+test('the Conductor relays the block verbatim, ahead of the builder\'s own contracts', () => {
+  const s = laws.forSession([ASK, LAND]);
+  const out = conductor.evaluateTriggers({
+    laws: { inject: s.inject, contract: s.contract },
+    interaction: { inject: true, contract: 'PROFILE' },
+    wandering: { inject: true, contract: 'FOCUS' },
+  });
+  const ids = out.map((a) => a.id);
+  const at = ids.findIndex((id) => id.startsWith('laws:'));
+  assert.ok(at >= 0, 'the laws advisory is emitted');
+  assert.equal(out[at].text, s.contract, 'verbatim');
+  assert.ok(at < ids.indexOf('wandering') && at < ids.indexOf('interaction'), 'laws come first');
+  assert.match(conductor.render(out), /Project laws/);
+});
+
+test('no laws, or laws:null (offline) → no laws advisory', () => {
+  for (const l of [null, { inject: false, contract: '' }, laws.forSession([])]) {
+    assert.ok(!conductor.evaluateTriggers({ laws: l }).some((a) => a.id.startsWith('laws:')));
+  }
+});
+
+test('a changed law is a new advisory: the dedupe fingerprint moves, so the block re-emits inside one session', () => {
+  const a = conductor.evaluateTriggers({ laws: laws.forSession([ASK]) });
+  const b = conductor.evaluateTriggers({ laws: laws.forSession([ASK, LAND]) });
+  const c = conductor.evaluateTriggers({ laws: laws.forSession([ASK]) });
+  assert.notEqual(conductor.fingerprint(a), conductor.fingerprint(b));
+  assert.equal(conductor.fingerprint(a), conductor.fingerprint(c), 'the same words, the same id: no re-emit noise');
+  assert.match(conductor.wordsHash('Ask like a human'), /^[0-9a-f]{8}$/);
+  assert.equal(conductor.wordsHash('Ask like a human'), conductor.wordsHash('Ask like a human'));
+  assert.notEqual(conductor.wordsHash('Ask like a human'), conductor.wordsHash('Ask like a human.'), 'one character is a different law');
+});
+
+// ── 3. the locks, enforced on the read ─────────────────────────────────────
+
+const BOOK = laws.forSession([ASK, LAND]).laws;
+
+test('a FIXED value wins over the builder\'s own, and the injected contract says the law\'s value', () => {
+  const mine = { interaction: { verbosity: 'detailed', technical_level: 'engineer' } };
+  const d = lawLocks.describe(mine, BOOK, { rank: 'archon', instanceModels: {} });
+  assert.equal(d.interaction.effective.verbosity, 'concise', 'the law');
+  assert.equal(d.interaction.effective.technical_level, 'engineer', 'an unlocked setting stays the builder\'s');
+  assert.deepEqual(d.interaction.stored, mine.interaction, 'what they chose is still reported as theirs');
+  assert.match(d.interaction.contract, /Verbosity: concise/);
+  assert.doesNotMatch(d.interaction.contract, /Verbosity: detailed/, 'the session never reads the overridden value');
+  const v = d.locks.find((l) => l.setting === 'verbosity');
+  assert.deepEqual([v.enforced, v.from, v.to, v.law_id, v.law_no], [true, 'detailed', 'concise', '11', 1]);
+});
+
+test('a CAP pulls a value above it down and leaves one under it alone — wandering and the model tiers', () => {
+  const high = lawLocks.describe({ wandering: 3, model_allocation: { main: 'fable' } }, BOOK, { rank: 'archon', instanceModels: {} });
+  assert.equal(high.wandering.effective_key, 'focused');
+  assert.equal(high.wandering.override_level, 3, 'their own choice is still on record');
+  assert.equal(high.wandering.inject, true, 'the focus contract is now sent');
+  assert.equal(high.model_allocation.effective.main, 'sonnet');
+  assert.equal(high.model_allocation.override.main, 'fable');
+  const low = lawLocks.describe({ wandering: 0, model_allocation: { main: 'haiku' } }, BOOK, { rank: 'archon', instanceModels: {} });
+  assert.equal(low.wandering.effective_key, 'locked', 'under the cap: theirs');
+  assert.equal(low.model_allocation.effective.main, 'haiku');
+  // nothing stored: the default is capped too (a law binds the builder who never opened Settings)
+  const none = lawLocks.describe({}, BOOK, { rank: 'archon', instanceModels: { main: 'opus' } });
+  assert.equal(none.model_allocation.effective.main, 'sonnet');
+});
+
+test('each enforced lock names every value it still allows — a cap the values under it, a fixed value just that one (task 1004714)', () => {
+  const d = lawLocks.describe({ wandering: 3, model_allocation: { main: 'fable' }, interaction: { verbosity: 'detailed' } }, BOOK, { rank: 'archon', instanceModels: {} });
+  const of = (k) => d.locks.find((l) => l.setting === k).allowed;
+  assert.deepEqual(of('wandering'), ['locked', 'focused'], 'wandering up to the cap, in its own order');
+  assert.deepEqual(of('model.main'), ['haiku', 'sonnet'], 'the model tiers cheap to capable, up to the cap');
+  assert.deepEqual(of('verbosity'), ['concise'], 'a fixed value allows only itself');
+  // the write check and the read report agree: what a PATCH may set is what allowed names
+  assert.deepEqual(lawLocks.checkPatch({ wandering: 'balanced' }, BOOK).allowed, of('wandering'));
+  assert.equal(lawLocks.checkPatch({ wandering: 'focused' }, BOOK), null);
+});
+
+test('a law cannot lift a builder past their rank: wandering stays inside the rank ceiling', () => {
+  const lift = laws.forSession([row(20, 'Roam freely', { locks: [{ setting: 'wandering', value: 'exploratory' }] })]).laws;
+  const xenos = lawLocks.describe({}, lift, { rank: 'xenos', instanceModels: {} });
+  assert.equal(xenos.wandering.effective_level, wanderingPrefs.maxLevelForRank('xenos'), 'the rank has the last word');
+  const archon = lawLocks.describe({}, lift, { rank: 'archon', instanceModels: {} });
+  assert.equal(archon.wandering.effective_key, 'exploratory');
+});
+
+test('a lock on a setting no table holds yet is reported, not invented; a value the setting does not have is not applied', () => {
+  const d = lawLocks.describe({}, laws.forSession([ASK, row(21, 'Odd words', { locks: [{ setting: 'machinery', value: 'loud' }] })]).laws, { rank: 'archon' });
+  const askFormat = d.locks.find((l) => l.setting === 'ask_format');
+  assert.deepEqual([askFormat.enforced, askFormat.reason], [false, 'not_a_personal_setting']);
+  const odd = d.locks.find((l) => l.setting === 'machinery');
+  assert.deepEqual([odd.enforced, odd.reason], [false, 'value_not_allowed']);
+  assert.equal(d.interaction.effective.machinery, interactionPrefs.defaultValue('machinery'));
+});
+
+test('no laws → every slice exactly as before', () => {
+  const prefs = { interaction: { verbosity: 'detailed' }, wandering: 2, model_allocation: { main: 'fable' } };
+  const d = lawLocks.describe(prefs, [], { rank: 'metic', instanceModels: {} });
+  assert.deepEqual(d.interaction, interactionPrefs.describeForApi(prefs));
+  assert.deepEqual(d.wandering, wanderingPrefs.describeForApi(prefs, 'metic'));
+  assert.deepEqual(d.locks, []);
+});
+
+// ── 4. the locks, enforced on the write — through the real router ──────────
+
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+const seams = require(path.join(ROOT, 'src', 'module-seams.js'));
+const { attachFail } = require(path.join(ROOT, 'src', 'bongos', 'middleware', 'error-envelope.js'));
+const settingsDb = require(path.join(ROOT, 'modules', 'builder-settings', 'db.js'));
+const express = require('express');
+
+const realRequireBuilder = api.requireBuilder;
+const realGetBuilder = api.getBuilderById;
+const realGet = settingsDb.getBuilderBehaviorPrefs;
+const realSet = settingsDb.setBuilderBehaviorPrefs;
+api.requireBuilder = (req, res, next) => { req.builder = { id: 42, rank: 'archon' }; next(); };
+api.getBuilderById = async () => ({ id: 42, rank: 'archon' });
+let stored = {};
+let saves = 0;
+settingsDb.getBuilderBehaviorPrefs = async () => JSON.parse(JSON.stringify(stored));
+settingsDb.setBuilderBehaviorPrefs = async (_id, next) => { saves += 1; stored = next; return next; };
+seams._reset();
+let lawRows = [ASK, LAND];
+let lawsDown = false;
+let lawReads = 0;
+seams.registerProvider('government', {
+  lawsForSession: async () => { lawReads += 1; if (lawsDown) throw new Error('db down'); return laws.forSession(lawRows); },
+});
+const buildSettingsRouter = require(path.join(ROOT, 'modules', 'builder-settings', 'routes', 'settings.js'));
+const app = express();
+app.use(express.json());
+app.use(attachFail);
+app.use(buildSettingsRouter());
+const server = http.createServer(app);
+await new Promise((r) => server.listen(0, '127.0.0.1', r));
+const BASE = `http://127.0.0.1:${server.address().port}`;
+after(() => {
+  server.close();
+  api.requireBuilder = realRequireBuilder;
+  api.getBuilderById = realGetBuilder;
+  settingsDb.getBuilderBehaviorPrefs = realGet;
+  settingsDb.setBuilderBehaviorPrefs = realSet;
+  seams._reset();
+});
+
+async function call(method, p, body) {
+  const res = await fetch(`${BASE}${p}`, { method, headers: body === undefined ? {} : { 'content-type': 'application/json' }, body: body === undefined ? undefined : JSON.stringify(body) });
+  let json = null; try { json = await res.json(); } catch { /* none */ }
+  return { status: res.status, json };
+}
+function reset(prefs = {}) { stored = prefs; saves = 0; lawReads = 0; lawRows = [ASK, LAND]; lawsDown = false; }
+
+test('GET reads the locked value and names the law; a value stored before the law passed still resolves to the law', async () => {
+  reset({ interaction: { verbosity: 'detailed' }, wandering: 3 });
+  const i = await call('GET', '/me/interaction');
+  assert.equal(i.status, 200);
+  assert.equal(i.json.effective.verbosity, 'concise');
+  assert.equal(i.json.stored.verbosity, 'detailed');
+  assert.deepEqual(i.json.law_locks.map((l) => [l.setting, l.law_id, l.enforced]), [['verbosity', '11', true]]);
+  assert.equal(i.json.laws_read, true);
+  const w = await call('GET', '/me/wandering');
+  assert.equal(w.json.effective_key, 'focused');
+  assert.deepEqual(w.json.law_locks.map((l) => l.setting), ['wandering']);
+  const m = await call('GET', '/me/model-allocation');
+  assert.equal(m.json.effective.main, 'sonnet');
+});
+
+test('a PATCH a law forbids is refused 409 naming the law, and NOTHING is saved', async () => {
+  for (const [p, body, setting] of [
+    ['/me/interaction', { verbosity: 'detailed' }, 'verbosity'],
+    ['/me/wandering', { wandering: 2 }, 'wandering'],
+    ['/me/model-allocation', { main: 'opus' }, 'model.main'],
+  ]) {
+    reset({});
+    const r = await call('PATCH', p, body);
+    assert.equal(r.status, 409, `${p} ${JSON.stringify(r.json)}`);
+    assert.equal(r.json.error.code || r.json.error, 'locked_by_law');
+    const det = r.json.error.details || r.json.details;
+    assert.equal(det.setting, setting);
+    assert.ok(['11', '12'].includes(det.law_id));
+    assert.equal(saves, 0, `${p}: nothing saved`);
+    const msg = r.json.error.message || r.json.message;
+    assert.ok(msg.includes(setting) && det.allowed.every((a) => msg.includes(a)), `the refusal names the setting and what is allowed: ${msg}`);
+  }
+});
+
+test('a PATCH the law allows goes through: the locked value itself, a value under a cap, an unlocked field, a clear', async () => {
+  for (const [p, body] of [
+    ['/me/interaction', { verbosity: 'concise' }],
+    ['/me/interaction', { technical_level: 'engineer' }],
+    ['/me/interaction', { verbosity: null }],
+    ['/me/wandering', { wandering: 1 }],
+    ['/me/wandering', { wandering: null }],
+    ['/me/model-allocation', { main: 'haiku' }],
+    ['/me/model-allocation', { subagentDefault: 'fable' }],
+  ]) {
+    reset({});
+    const r = await call('PATCH', p, body);
+    assert.equal(r.status, 200, `${p} ${JSON.stringify(body)} → ${JSON.stringify(r.json)}`);
+    assert.equal(saves, 1);
+    assert.equal(lawReads, 1, `${p}: the book is read once per request`);
+    assert.ok(Array.isArray(r.json.law_locks), 'the answer reports the locks');
+  }
+});
+
+test('repeal the law and the same write goes through — the next read follows the book', async () => {
+  reset({});
+  lawRows = [LAND];
+  const r = await call('PATCH', '/me/interaction', { verbosity: 'detailed' });
+  assert.equal(r.status, 200);
+  assert.equal(r.json.effective.verbosity, 'detailed');
+});
+
+test('laws unreadable: a write is refused 503 and saves nothing; a read falls back to the builder\'s own and says so', async () => {
+  reset({ interaction: { verbosity: 'detailed' } });
+  lawsDown = true;
+  const w = await call('PATCH', '/me/interaction', { verbosity: 'detailed' });
+  assert.equal(w.status, 503);
+  assert.equal(saves, 0);
+  const r = await call('GET', '/me/interaction');
+  assert.equal(r.status, 200);
+  assert.equal(r.json.laws_read, false);
+  assert.equal(r.json.effective.verbosity, 'detailed');
+});