@bongos/core 1.21.113 → 1.21.114

package/modules/government/positions.js

@@ -0,0 +1,107 @@
+'use strict';
+
+// modules/government/positions.js — THE POSITIONS A BUILDER HOLDS (task 1004713,
+// goal 1000111; ADR 0377).
+//
+// THE OWNER'S RULING (2026-10-09). A seat in the government is HELD, not a picked
+// craft: you hold a seat in the government or you don't. A position is
+//   owner      the owner seat — every active Archon (leads.ownerOf)
+//   lead       the Lead in office at a building (government_leads, by vote)
+//   seat       a seat on a building's own sitting: its decision-rules row puts
+//              matters to a sitting of the people its predicate names
+//   board      a member of the board under the constitution in force
+//
+// WHERE EACH ANSWER COMES FROM. Never a second rule: the owner and Lead seats are
+// asked of routing.resolveSeat (which asks leads.answerFor), the board and each
+// building's sitting of board-membership's membership predicate. This file only
+// folds the answers into one list for one builder. GET /me carries it as
+// `positions` (through the government port), the way it carries `permissions`,
+// and the hall shows the governing surfaces and the Governing mode — named by the
+// first seat — only to someone who holds one. Cosmetic there: every page and
+// route keeps its own server-side gate (ADR 0016).
+//
+// WHAT A POSITION IS NOT. A craft (PATCH /me/disciplines is ungated, so a
+// craft-derived seat would be self-appointment), and an authority: holding one
+// grants no permission (leads.js: the Lead's office confers none).
+//
+// PURE: no db. readPositions() below takes the reads it needs as functions, so
+// routes/government.js asks them per request, uncached, and a test hands fakes.
+
+const { resolveSeat, BUILDING_NAMES } = require('./routing');
+const { ownerOf } = require('./leads');
+
+const BUILDINGS = Object.freeze(Object.keys(BUILDING_NAMES));
+// Which seat names the Governing mode when a builder holds several.
+const KIND_ORDER = Object.freeze({ lead: 0, owner: 1, seat: 2, board: 3 });
+const KINDS = Object.freeze(Object.keys(KIND_ORDER));
+// Decision-rules values that name no predicate of their own: the board's sitting
+// is the board seat, and a fixed gate or nobody seats no one.
+const NOT_A_PREDICATE = Object.freeze(['board', 'gate', 'nobody']);
+
+function titleOf(kind, building) {
+  const name = BUILDING_NAMES[building] || '';
+  if (kind === 'lead') return `${name} Lead`;
+  if (kind === 'seat') return `${name} seat`;
+  if (kind === 'owner') return 'Owner';
+  return 'Board member';
+}
+
+// positionsOf(builderId, ctx) → { held[], title, has_position }
+//   ctx.leads       Lead rows in office (db.listLeads)
+//   ctx.owner       leads.ownerOf(active Archons)
+//   ctx.board       true when the builder sits on the board in force
+//   ctx.sittings    [building] — the buildings whose own sitting seats them
+function positionsOf(builderId, ctx) {
+  const c = ctx || {};
+  const id = builderId == null || builderId === '' ? null : String(builderId);
+  const held = [];
+  if (id) {
+    const seats = { leads: c.leads || [], owner: c.owner || { builders: [] } };
+    if (resolveSeat('owner', seats).builder_ids.includes(id)) held.push({ kind: 'owner', seat: 'owner', building: null });
+    for (const b of BUILDINGS) {
+      const r = resolveSeat(`lead:${b}`, seats);
+      if (!r.fell_to_owner && r.builder_ids.includes(id)) held.push({ kind: 'lead', seat: `lead:${b}`, building: b });
+    }
+    for (const b of BUILDINGS) {
+      if ((c.sittings || []).includes(b)) held.push({ kind: 'seat', seat: `board:${b}`, building: b });
+    }
+    if (c.board === true) held.push({ kind: 'board', seat: 'board', building: null });
+  }
+  held.sort((a, b) => KIND_ORDER[a.kind] - KIND_ORDER[b.kind]);
+  const positions = held.map((p) => ({ ...p, title: titleOf(p.kind, p.building) }));
+  return { held: positions, title: positions.length ? positions[0].title : null, has_position: positions.length > 0 };
+}
+
+// readPositions(builderId, reads) → the /me `positions` block, or null when any
+// read failed (unknown is never "holds none": the hall then keeps its nav).
+//   reads.listLeads()            Lead rows in office
+//   reads.listActiveArchons()    the owner seat's holders
+//   reads.board()                the board block in force
+//   reads.decisions(board)       the resolved decision-rules rows
+//   reads.sits(id, membership)   does the builder satisfy this predicate (fail closed)
+async function readPositions(builderId, reads) {
+  if (builderId == null || builderId === '') return null;
+  try {
+    const board = reads.board() || {};
+    const [leads, archons, decisions, onBoard] = await Promise.all([
+      reads.listLeads(), reads.listActiveArchons(), reads.decisions(board), reads.sits(builderId, board.membership),
+    ]);
+    const sittings = [];
+    for (const d of decisions || []) {
+      if (!d || !d.sitting || !BUILDINGS.includes(d.area)) continue;
+      if (NOT_A_PREDICATE.includes(d.decided_by)) continue;
+      if (await reads.sits(builderId, d.decided_by)) sittings.push(d.area);
+    }
+    const p = positionsOf(builderId, { leads, owner: ownerOf(archons), board: onBoard === true, sittings });
+    return {
+      held: p.held,
+      title: p.title,
+      has_position: p.has_position,
+      from: 'the Leads in office, the owner seat (every active Archon), the board and each building\'s sitting under the constitution in force; never a craft',
+    };
+  } catch (_) {
+    return null;
+  }
+}
+
+module.exports = { positionsOf, readPositions, titleOf, KINDS, KIND_ORDER };

package/modules/government/presets.js

@@ -0,0 +1,149 @@
+'use strict';
+
+// modules/government/presets.js — HOW STRICT a project runs its AI agents
+// (task 1004715, goal 1000111 "government is how a project steers its AI").
+//
+// A project picks how strict it is the way it picks a form of government. A
+// STRICTNESS PRESET is a named bundle of laws (laws.js) and the locks they put on
+// every builder's personal settings (builder-settings/law-locks.js):
+//
+//   Open workshop  few laws: land only, and going live waits for a person.
+//   Guild          the standard set: Open's law, plus stuck agents skip on, and
+//                  agents stay on the task (wandering capped at "focused").
+//   Factory        strict: Guild's laws made tight (wandering fixed at "locked"),
+//                  plus caps on every model slot, the ask format, and no
+//                  unattended runs.
+//
+// NOTHING HERE WRITES A LAW, and nothing is seeded. A preset is a CATALOGUE: its
+// laws are in force only once a vote passes them. Switching presets is ONE laws
+// amendment (switchProposal → law-board.proposeLaws), filed and decided like any
+// other: it enacts the preset's laws not yet in force and repeals the laws of the
+// other presets that are, and it touches no law that belongs to no preset (a law
+// the project passed on its own stays). The board passing it is the only write
+// (board.closeItem → law-board.applyPassedLaws, guarded by government_027's
+// trigger).
+//
+// WHICH PRESET IS IN FORCE is READ from the laws in force, never stored: a preset
+// is in force when every one of its laws is (same words, same locks) and no other
+// preset's law is. Anything else — a fresh project with no laws, or a book that
+// mixes presets — is "no preset" (`current: null`), said plainly.
+//
+// WHAT EACH WOULD LOCK. The locks in force after a switch: the preset's own plus
+// those of every law it would keep (the project's own laws). The hall counts them
+// against the viewer's rows (My agents' preset strip, the Charter).
+//
+// ENFORCEMENT is the laws' own: a lock on a personal setting is enforced by the
+// server on every read and write (law-locks.js); the ask format is already
+// required of every AI session's blocker (ADR 0373); "No unattended runs" reaches
+// every session as a law's words, and nothing yet refuses an unattended run.
+//
+// PURE: no db, no requires beyond laws.js. The route hands the laws in force in.
+
+const laws = require('./laws');
+
+// The laws a preset is made of. A law shared by two presets carries the same
+// words AND the same locks in both, so a switch between them keeps it.
+const LAW = {
+  land: { text: 'Land only. Ask before going live', effect_on_ai: 'Agents merge finished work; going live always waits for a person.', locks: [] },
+  stuck: { text: 'Stuck? Note it, skip it, keep going', effect_on_ai: 'A stuck agent leaves a note on the task and moves to the next one.', locks: [] },
+  focus: { text: 'Stay on the task; note side ideas', effect_on_ai: 'Agents finish the task in hand and leave one note for anything else.', locks: [{ setting: 'wandering', max: 'focused' }] },
+  tight: { text: 'Stay on the task; no side trips', effect_on_ai: 'Agents do the task in hand and nothing else.', locks: [{ setting: 'wandering', value: 'locked' }] },
+  ask: { text: 'Ask like a human', effect_on_ai: 'Every question to a person is one short card with tap answers, in the ask format.', locks: [] },
+  watched: { text: 'No unattended runs', effect_on_ai: 'A person starts and watches every agent run; nothing runs overnight or on a schedule.', locks: [] },
+  caps: {
+    text: 'Models stay under their caps',
+    effect_on_ai: 'The main session runs at most opus, helpers at most sonnet, routine work on haiku.',
+    locks: [{ setting: 'model.main', max: 'opus' }, { setting: 'model.subagentDefault', max: 'sonnet' }, { setting: 'model.subagentRoutine', max: 'haiku' }],
+  },
+};
+
+const PRESETS = Object.freeze([
+  { key: 'open', name: 'Open workshop', line: 'Few laws. Every builder keeps their own settings.', laws: [LAW.land] },
+  { key: 'guild', name: 'Guild', line: 'The standard set. Laws lock the settings they name; the rest is yours.', laws: [LAW.land, LAW.stuck, LAW.focus] },
+  { key: 'factory', name: 'Factory', line: 'Strict. Caps on, the ask format enforced, no unattended runs.', laws: [LAW.land, LAW.stuck, LAW.tight, LAW.ask, LAW.watched, LAW.caps] },
+]);
+const KEYS = PRESETS.map((p) => p.key);
+
+const norm = (t) => String(t == null ? '' : t).trim().toLowerCase().replace(/\s+/g, ' ');
+const lockKey = (l) => (Object.prototype.hasOwnProperty.call(l, 'value') ? `${l.setting}=${JSON.stringify(l.value)}` : `${l.setting}<=${JSON.stringify(l.max)}`);
+const locksKey = (locks) => (Array.isArray(locks) ? locks : []).filter((l) => l && typeof l.setting === 'string').map(lockKey).sort().join('|');
+// Every preset law's words, in any preset: the laws a switch may repeal.
+const CATALOGUE = new Set(PRESETS.reduce((a, p) => a.concat(p.laws.map((l) => norm(l.text))), []));
+
+const presetOf = (key) => PRESETS.find((p) => p.key === key) || null;
+const inForceOnly = (rows) => (Array.isArray(rows) ? rows : []).filter((r) => r && r.id != null && r.repealed_at == null && typeof r.text === 'string');
+const same = (row, law) => norm(row.text) === norm(law.text) && locksKey(row.locks) === locksKey(law.locks);
+
+// The preset in force, read from the laws in force (`rows`: db.listLaws() rows).
+// Returns a preset key, or null when none is.
+function currentPreset(rows) {
+  const ours = inForceOnly(rows).filter((r) => CATALOGUE.has(norm(r.text)));
+  if (!ours.length) return null;
+  const hit = PRESETS.find((p) => p.laws.length === ours.length && p.laws.every((law) => ours.some((r) => same(r, law))));
+  return hit ? hit.key : null;
+}
+
+// The ONE laws amendment a switch to `key` files: enact the preset's laws not in
+// force (as written), repeal every other preset law in force (including one with
+// the right words but other locks — the preset's own version replaces it). A law
+// that is no preset's is never touched. Returns
+//   { ok: true, proposal: { enact, repeal }, rationale } or { ok: false, reason }.
+function switchProposal(key, rows) {
+  const p = presetOf(key);
+  if (!p) return { ok: false, reason: 'unknown_preset', expected: KEYS.join(' | ') };
+  const inForce = inForceOnly(rows);
+  if (currentPreset(inForce) === key) return { ok: false, reason: 'preset_in_force' };
+  const kept = new Set();
+  const enact = [];
+  p.laws.forEach((law) => {
+    const row = inForce.find((r) => same(r, law));
+    if (row) kept.add(String(row.id));
+    else enact.push({ text: law.text, effect_on_ai: law.effect_on_ai, locks: law.locks.map((l) => ({ ...l })) });
+  });
+  const repeal = inForce.filter((r) => CATALOGUE.has(norm(r.text)) && !kept.has(String(r.id))).map((r) => String(r.id));
+  // the same strict check every laws proposal passes (shape, limits)
+  const v = laws.validateLawsProposal({ enact, repeal });
+  if (!v.ok) return v;
+  const from = currentPreset(inForce);
+  const fromName = from ? presetOf(from).name : 'no preset';
+  return { ok: true, proposal: v.proposal, rationale: `Switch from ${fromName} to ${p.name}: ${p.line}` };
+}
+
+// Every lock in force after a switch to `key`: the preset's own, plus every lock
+// of a law the switch keeps (one that is no preset's).
+function locksAfter(key, rows) {
+  const p = presetOf(key);
+  if (!p) return [];
+  const out = [];
+  const add = (law) => (Array.isArray(law.locks) ? law.locks : []).forEach((l) => {
+    if (l && typeof l.setting === 'string' && !out.some((x) => x.setting === l.setting)) out.push({ ...l, law_text: law.text });
+  });
+  inForceOnly(rows).filter((r) => !CATALOGUE.has(norm(r.text))).forEach(add);
+  p.laws.forEach(add);
+  return out;
+}
+
+// GET /government/presets: the three presets, which one is in force, and for each
+// its laws and the locks a switch to it would leave in force.
+function presetsView(rows) {
+  const current = currentPreset(rows);
+  return {
+    current,
+    presets: PRESETS.map((p) => ({
+      key: p.key,
+      name: p.name,
+      line: p.line,
+      current: p.key === current,
+      laws: p.laws.map((l) => ({ text: l.text, effect_on_ai: l.effect_on_ai, locks: l.locks.map((x) => ({ ...x })) })),
+      locks: locksAfter(p.key, rows),
+    })),
+    changed_by: 'a passed laws vote only: POST /government/board/presets files one',
+  };
+}
+
+module.exports = {
+  PRESETS,
+  currentPreset,
+  switchProposal,
+  presetsView,
+};