@bongos/core 1.25.20 → 1.25.22

package/tests/government_charter_advice.mjs

@@ -148,3 +148,52 @@ test('the port entry reads the head count and the law book', async () => {
   assert.equal(expected.headcount, 2, 'the founder\'s expected number wins over the live count');
   assert.equal(expected.charter.key, 'monarchy');
 });
+
+// ── task 1005130: every project is already a monarchy, and is told so ────────
+const MONARCHY = { membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true };
+const config = require(path.join(ROOT, 'modules', 'government', 'config.js'));
+
+test('the default constitution reads as Monarchy, and the stage says so on arrival', () => {
+  const live = config.loadGovernmentConfig().board;
+  const v = charter.charterView(live);
+  assert.equal(v.in_force.form, 'monarchy', 'every project boots as a monarchy');
+  assert.match(v.in_force.line, /runs as Monarchy \/ BDFL now\. Every project opens as one/);
+  assert.match(v.in_force.line, /You decide\. Each decision takes one yes from you\./);
+  assert.deepEqual(v.forms.filter((f) => f.current).map((f) => f.key), ['monarchy'], 'exactly the form in force is marked');
+});
+
+test('every form says who decides and what closing takes, derived from its own settings', () => {
+  const v = charter.charterView(MONARCHY);
+  for (const f of v.forms.filter((x) => x.available)) {
+    const d = charter.dutyOf(f.franchise, f.pass_rule);
+    assert.equal(f.who_decides, d.who_decides, f.key);
+    assert.equal(f.to_close, d.to_close, f.key);
+    assert.ok(f.who_decides && f.to_close, `${f.key} says both`);
+  }
+  assert.equal(charter.dutyOf('founder', 'first_ratifier').to_close, 'Each decision takes one yes from you.');
+  assert.match(charter.dutyOf('everyone', 'majority').to_close, /more than half/);
+  assert.notEqual(charter.dutyOf('trusted', 'consent').to_close, charter.dutyOf('trusted', 'majority').to_close,
+    'the sentence follows the pass rule, so a tuned rule is described as it runs');
+});
+
+test('choosing what is in force changes nothing and is done; choosing another says what happens next', () => {
+  const same = charter.choiceOutcome(MONARCHY, 'monarchy');
+  assert.equal(same.changes, false);
+  assert.equal(same.complete, true);
+  assert.match(same.line, /already a Monarchy \/ BDFL\. Nothing to change/);
+  const other = charter.choiceOutcome(MONARCHY, 'direct-democracy');
+  assert.equal(other.changes, true);
+  assert.match(other.line, /filed as a change to the rules and decided under the government in force \(Monarchy \/ BDFL\)\. Under it, your own one yes applies it\./);
+  const underCircle = charter.choiceOutcome({ ...MONARCHY, membership: 'rank:xenos+', pass_rule: 'consent' }, 'monarchy');
+  assert.match(underCircle.line, /passes unless one of them objects/, 'under another government the rule in force is named');
+});
+
+test('the charter stage advice carries what is in force and what choosing the recommendation does', () => {
+  const a = advice.buildAdvice({ answers: {}, headcount: 1, board: MONARCHY });
+  assert.equal(a.in_force.form, 'monarchy');
+  assert.equal(a.charter.key, 'monarchy');
+  assert.equal(a.charter.on_choose.changes, false, 'a solo founder is told the recommendation is what they already have');
+  const b = advice.buildAdvice({ answers: { final_say: 'everyone' }, headcount: 1, board: MONARCHY });
+  assert.equal(b.charter.on_choose.changes, true);
+  assert.ok(b.forms.find((f) => f.key === 'monarchy').current);
+});

package/tests/government_charter_forms.mjs

@@ -254,8 +254,12 @@ test('a charter that changes nothing files nothing, and a council must be a rank
     getRankByKey: async (key) => (key === 'trustees' ? { rank_key: 'trustees' } : null),
     builderHoldsRankActive: async () => true,
   }, async () => {
-    assert.equal((await board.proposeCharter({ form: 'monarchy', proposedBy: '42' })).reason, 'no_change',
-      'a sitting on the constitution already in force would decide nothing');
+    const same = await board.proposeCharter({ form: 'monarchy', proposedBy: '42' });
+    assert.equal(same.reason, 'no_change', 'a sitting on the constitution already in force would decide nothing');
+    // task 1005130: the refusal says what is true in words and counts the choice done
+    assert.equal(same.in_force, 'Monarchy / BDFL');
+    assert.equal(same.complete, true);
+    assert.match(same.message, /You are already a Monarchy \/ BDFL\. Nothing to change/);
     assert.equal((await board.proposeCharter({ form: 'foundation', councilRank: 'ghosts', proposedBy: '42' })).reason, 'unknown_council_rank');
     assert.equal((await board.proposeCharter({ form: 'direct-democracy', proposedBy: null })).reason, 'missing_proposer');
   });
@@ -272,7 +276,14 @@ test('the constitution view carries the charter: forms, variables, and what the
   });
   const routes = fs.readFileSync(path.join(GOV, 'routes', 'government.js'), 'utf8');
   assert.match(routes, /router\.post\('\/government\/board\/charter', api\.requireBuilder, api\.requirePermission\('board\.item\.open'\)/);
-  assert.match(routes, /proposeCharter: board\.proposeCharter/);
+  // The port's charter filing IS board.proposeCharter, followed by the board-of-one
+  // confirm (task 1005130) — called, not read: a refusal from board comes back as is.
+  const { governmentPort } = require(path.join(GOV, 'routes', 'government.js'));
+  const real = board.proposeCharter;
+  board.proposeCharter = async (a) => ({ ok: false, reason: 'from_board', seen: a.form });
+  try {
+    assert.deepEqual(await governmentPort.proposeCharter({ form: 'monarchy', proposedBy: '42' }), { ok: false, reason: 'from_board', seen: 'monarchy' });
+  } finally { board.proposeCharter = real; }
   const pins = fs.readFileSync(path.join(ROOT, 'src', 'bongos', 'route-rank-check.js'), 'utf8');
   assert.match(pins, /'POST \/government\/board\/charter': 'perm:board\.item\.open'/);
 });

package/tests/government_seed.mjs

@@ -55,6 +55,7 @@ const NON_GRANT_MIGRATIONS = new Set([
   'government_036_access_holders.sql',             // who holds the keys outside Bongos + the access:<key> ask seat (task 1005000)
   'government_037_constitution.sql',               // the constitution in force as a durable row (task 1005140)
   'government_038_vote_cast_via.sql',               // HOW a vote was cast: a ballot, or a stage-close confirm (task 1005121)
+  'government_039_vote_cast_via_filed.sql',         // a board of one's confirm given by filing (task 1005130)
 ]);
 
 // Permission keys RENAMED after the grant migrations that first granted them.

package/tests/government_sole_member.mjs

@@ -0,0 +1,153 @@
+// tests/government_sole_member.mjs — a board of ONE decides by filing (task 1005130,
+// part C; the ruling task 1005121 shipped for closing a genesis stage, applied
+// wherever it holds).
+//
+// The rule held here, for a charter change, a laws change and a decision-rules change:
+//   • the sole member of a first_ratifier board files → their yes is cast in the same
+//     call, recorded as THEIR vote (attributed, cast_via 'filed'), and the sitting
+//     closes through the ordinary close path;
+//   • a second member on the board, a consent or majority rule, or a caller who is not
+//     the sole member → the filing comes back exactly as it was, and nothing is cast;
+//   • the yes goes through the real castVote — its membership re-check, and a
+//     'filed' cast is refused on anything but an amendment, or as a 'no';
+//   • a filing the filer was refused comes back untouched, and a failing confirm
+//     leaves the sitting open rather than failing the filing.
+// The real routes (permission gate first, a non-member's filing left open, a lower
+// rank refused before anything is filed) are walked end to end in
+// scripts/bongos/government-walk.js (rows G3, G5, B*, L2–L4, L11–L15).
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const GOV = path.join(ROOT, 'modules', 'government');
+const db = require(path.join(GOV, 'db.js'));
+const board = require(path.join(GOV, 'board.js'));
+const sole = require(path.join(GOV, 'sole-member.js'));
+
+const MONARCHY = { membership: 'rank:archon', pass_rule: 'first_ratifier', window_minutes: null, close_early_on_full_turnout: true };
+const FILERS = ['proposeCharter', 'proposeLaws', 'proposeDecisionRules'];
+
+// A world: who holds which rank, the one open item a filing opened, and every vote
+// written. db is stubbed underneath the REAL castVote; the filers and the close are
+// stubbed on board (looked up at call time), so this exercises the decision alone.
+async function world({ members = ['42'], constitution = MONARCHY, subjectType = 'constitutional_amendment', filedOk = true } = {}, fn) {
+  const votes = [];
+  const closes = [];
+  const item = { id: 7, subject_type: subjectType, constitution, closed_at: null, expired: false };
+  const stubs = {
+    getActiveBuildersWithRank: async () => members.map((id) => ({ builder_id: id, github_login: `b${id}`, display_name: `B${id}` })),
+    builderHoldsRankActive: async (id) => members.includes(String(id)),
+    getBoardItemForVote: async () => ({ ...item }),
+    getBoardItemAuthor: async () => '42',
+    insertBoardVote: async (v) => { const row = { item_id: String(v.itemId), voter_id: String(v.voterId), direction: v.direction, cast_via: v.castVia || 'ballot', cast_at: '2026-11-13T12:00:00.000Z' }; votes.push(row); return row; },
+    getBoardVote: async () => null,
+    insertVoteKarma: async () => { throw new Error('a confirm given by filing earns no vote karma'); },
+  };
+  const boardStubs = {
+    maybeCloseAfterVote: async (id) => { closes.push(id); return { closed: true, outcome: 'passed', item: { id } }; },
+  };
+  for (const f of FILERS) boardStubs[f] = async () => (filedOk ? { ok: true, amendment: { id: 3 }, item: { ...item } } : { ok: false, reason: 'proposer_would_lose_their_seat' });
+  const saved = {};
+  for (const [k, v] of Object.entries(stubs)) { saved[`db.${k}`] = db[k]; db[k] = v; }
+  for (const [k, v] of Object.entries(boardStubs)) { saved[`board.${k}`] = board[k]; board[k] = v; }
+  try {
+    return await fn({ votes, closes });
+  } finally {
+    for (const [k, v] of Object.entries(saved)) {
+      const [obj, key] = k.split('.');
+      (obj === 'db' ? db : board)[key] = v;
+    }
+  }
+}
+
+for (const filer of FILERS) {
+  test(`${filer}: the sole member of a one-yes board decides by filing, and the vote is theirs on the record`, async () => {
+    await world({}, async ({ votes, closes }) => {
+      const out = await sole[filer]({ proposedBy: '42' });
+      assert.equal(out.ok, true);
+      assert.deepEqual(out.decided, { closed: true, outcome: 'passed', cast_via: 'filed' });
+      assert.equal(votes.length, 1);
+      assert.equal(votes[0].voter_id, '42', 'attributed to the member who filed');
+      assert.equal(votes[0].direction, 'yes');
+      assert.equal(votes[0].cast_via, 'filed', 'the record says how it was cast');
+      assert.ok(votes[0].cast_at, 'and when');
+      assert.deepEqual(closes, [7], 'closed through the ordinary close path');
+    });
+  });
+
+  test(`${filer}: a second member on the board — nothing is cast, the sitting waits`, async () => {
+    await world({ members: ['42', '43'] }, async ({ votes, closes }) => {
+      const out = await sole[filer]({ proposedBy: '42' });
+      assert.equal(out.decided, undefined);
+      assert.deepEqual(votes, []);
+      assert.deepEqual(closes, []);
+    });
+  });
+
+  for (const rule of ['consent', 'majority', 'unanimous']) {
+    test(`${filer}: under ${rule} a sole member's filing still waits for their vote`, async () => {
+      await world({ constitution: { ...MONARCHY, pass_rule: rule } }, async ({ votes, closes }) => {
+        const out = await sole[filer]({ proposedBy: '42' });
+        assert.equal(out.decided, undefined);
+        assert.deepEqual(votes, []);
+        assert.deepEqual(closes, []);
+      });
+    });
+  }
+
+  test(`${filer}: a caller who is not the sole member — the sitting is left open, exactly as today`, async () => {
+    await world({ members: ['42'] }, async ({ votes, closes }) => {
+      const out = await sole[filer]({ proposedBy: '43' });
+      assert.equal(out.ok, true);
+      assert.equal(out.decided, undefined);
+      assert.deepEqual(votes, []);
+      assert.deepEqual(closes, []);
+    });
+  });
+
+  test(`${filer}: a refused filing comes back untouched, and nothing is cast`, async () => {
+    await world({ filedOk: false }, async ({ votes }) => {
+      assert.deepEqual(await sole[filer]({ proposedBy: '42' }), { ok: false, reason: 'proposer_would_lose_their_seat' });
+      assert.deepEqual(votes, []);
+    });
+  });
+}
+
+test('the yes goes through the real castVote: membership is re-checked under the item\'s snapshot', async () => {
+  // resolve says 42 is the one member, but the per-request re-check says 42 no longer
+  // holds the rank (demoted between the two reads): the cast is refused, nothing closes.
+  await world({}, async ({ votes, closes }) => {
+    db.builderHoldsRankActive = async () => false;
+    const out = await sole.proposeLaws({ proposedBy: '42' });
+    assert.equal(out.decided, undefined);
+    assert.deepEqual(votes, []);
+    assert.deepEqual(closes, []);
+  });
+});
+
+test('a cast marked "filed" is refused on anything but an amendment, and as a no', async () => {
+  await world({ subjectType: 'full_idea' }, async ({ votes }) => {
+    assert.equal((await board.castVote({ itemId: 7, voterId: '42', direction: 'yes', castVia: 'filed' })).reason, 'bad_cast_via');
+    assert.deepEqual(votes, []);
+  });
+  await world({ subjectType: 'genesis_stage' }, async () => {
+    assert.equal((await board.castVote({ itemId: 7, voterId: '42', direction: 'yes', castVia: 'filed' })).reason, 'bad_cast_via');
+  });
+  await world({}, async () => {
+    assert.equal((await board.castVote({ itemId: 7, voterId: '42', direction: 'no', reasonMd: 'no', sectionKey: 'purpose', castVia: 'filed' })).reason, 'bad_cast_via');
+    assert.equal((await board.castVote({ itemId: 7, voterId: '42', direction: 'yes', castVia: 'by_magic' })).reason, 'bad_cast_via');
+  });
+});
+
+test('a confirm that fails leaves the filing standing and the sitting open', async () => {
+  await world({}, async () => {
+    board.maybeCloseAfterVote = async () => { throw new Error('db down'); };
+    const out = await sole.proposeCharter({ proposedBy: '42' });
+    assert.equal(out.ok, true);
+    assert.equal(out.decided, undefined);
+  });
+});

package/tests/project_catalog_routes.mjs

@@ -50,6 +50,8 @@ let published = [];
 let healed = [];
 
 provisioning.getInstanceById = async (_db, id) => (instance ? { ...instance, id } : null);
+// The gate also admits an owner-made grant (task 1004161, ADR 0407); nobody in this file holds one.
+require('../modules/provisioning/grants.js').liveGrant = async () => null;
 provisioning.getInstanceBySlug = async (_db, slug) => (instance && instance.slug === slug ? { ...instance } : null);
 provisioning.getInstanceByDomain = async () => null;
 provisioning.listInstancesForOwner = async () => [];   // the shape gate's count (task 1004412): no other hosted project

package/tests/project_facts.mjs

@@ -0,0 +1,158 @@
+// tests/project_facts.mjs — the project's own facts, carried from the hub, and each reward
+// option's real implications at the point of choice (task 1005129).
+//
+// Everything RUNS: the hub's real companion line (provisioning.js SETTINGS_COMPANION_ENV →
+// project-facts.js) decoded by the project's real reader, the real soft-limit table carried
+// as data, and the project's facts + options over an in-memory project_settings store and
+// a fake `lifecycle.payTypeGates` port built from the REAL gate table.
+//
+// Run:  node --test tests/project_facts.mjs
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const provisioning = require('../modules/provisioning/provisioning.js');
+const hub = require('../modules/provisioning/project-facts.js');
+const pf = require('../modules/onboarding/project-facts.js');
+const gatesLib = require('../modules/lifecycle/pay-type-gates.js');
+const { PAY_TYPE_LABELS } = require('../modules/lifecycle/pay-terms.js');
+
+// The real gate verdicts with nothing on file (or with the given pay types cleared).
+function payGates(cleared = []) {
+  return {
+    labels: PAY_TYPE_LABELS,
+    readGates: async () => {
+      const types = [...Object.keys(gatesLib.REQUIREMENTS), 'eu_labour'];
+      return types.map((p) => gatesLib.withoutEvidence(gatesLib.gateVerdict(p, cleared.includes(p)
+        ? gatesLib.requirementIds(p).map((requirement) => ({ pay_type: p, requirement, state: 'cleared' })) : [])));
+    },
+  };
+}
+
+function project({ detail, gates = payGates() } = {}) {
+  const store = new Map();
+  const line = detail ? provisioning.SETTINGS_COMPANION_ENV.PROJECT_FACTS({ detail }) : '';
+  return {
+    store,
+    deps: () => ({
+      getSetting: async (k) => (store.has(k) ? { key: k, value: store.get(k) } : null),
+      setSetting: async (k, v) => { store.set(k, String(v)); },
+      factsMarker: pf.factsMarker({ projectFacts: line }),
+      payGates: gates,
+      now: () => new Date('2026-11-13T12:00:00Z'),
+    }),
+  };
+}
+
+test('the hub carries only the facts a stage reads, and the reward rules as data', () => {
+  const line = provisioning.SETTINGS_COMPANION_ENV.PROJECT_FACTS({ detail: {
+    home_country: 'DE', builder_geography: 'global', entity: 'nonprofit', minors_on_board: false,
+    reward_intents: ['cash', 'equity'], framing: 'managed', project_state: 'new',
+  } });
+  const m = JSON.parse(Buffer.from(line, 'base64url').toString('utf8'));
+  assert.deepEqual(Object.keys(m.facts).sort(), ['builder_geography', 'entity', 'home_country', 'minors_on_board', 'reward_intents']);
+  assert.ok(!('framing' in m.facts), 'nothing a stage does not read crosses');
+  assert.ok(m.rules.length > 0 && m.rules.every((r) => r.options.some((o) => o.startsWith('reward_intents'))), 'only reward rules ride along');
+  assert.deepEqual(m.rules.map((r) => r.id), hub.REWARD_RULES.map((r) => r.id), 'read from the soft-limit table, never rewritten');
+  assert.equal(provisioning.SETTINGS_COMPANION_ENV.PROJECT_FACTS({ detail: {} }), '', 'nothing answered: an empty line, not a guess');
+  assert.equal(provisioning.SETTINGS_COMPANION_ENV.PROJECT_FACTS({}), '');
+});
+
+test('the project seeds its own copy once, as carried over; the founder\'s edit wins after', async () => {
+  const p = project({ detail: { home_country: 'US', home_region: 'US-CA', builder_geography: 'us-only' } });
+  let r = await pf.readFacts(p.deps());
+  const geo = r.facts.find((f) => f.key === 'builder_geography');
+  assert.equal(geo.value, 'us-only');
+  assert.equal(geo.origin, 'carried_over');
+  assert.deepEqual(r.unanswered, ['minors_on_board', 'entity', 'reward_intents'], 'never answered reads as not answered');
+  const w = await pf.setFacts({ builder_geography: 'global' }, 1, p.deps());
+  assert.equal(w.ok, true);
+  r = await pf.readFacts(p.deps());
+  assert.equal(r.facts.find((f) => f.key === 'builder_geography').value, 'global', 'the copy is editable, not a frozen snapshot');
+  assert.equal(r.facts.find((f) => f.key === 'builder_geography').origin, 'founder');
+  assert.equal(r.facts.find((f) => f.key === 'home_country').origin, 'carried_over');
+  // Un-answering goes back to "not answered".
+  await pf.setFacts({ home_region: null }, 1, p.deps());
+  assert.ok((await pf.readFacts(p.deps())).unanswered.includes('home_region'));
+});
+
+test('a project not made through the hub has every fact "not answered" and is not refused', async () => {
+  const p = project({});
+  const r = await pf.readOptions(p.deps());
+  assert.equal(r.unanswered.length, 6);
+  assert.equal(r.facts.every((f) => f.value === null), true);
+  assert.ok(r.options.length > 0, 'the options are still stated, from the enforced table');
+  assert.ok(r.options.every((o) => o.facts.length === 0), 'no fact note fires on an answer nobody gave');
+});
+
+test('every option states what the server enforces and the facts beside it, kept apart', async () => {
+  const p = project({ detail: { home_country: 'US', builder_geography: 'us-eu', entity: 'nonprofit', minors_on_board: true } });
+  const r = await pf.readOptions(p.deps());
+  const cash = r.options.find((o) => o.pay_type === 'cash');
+  assert.equal(cash.status, 'needs_setup');
+  assert.equal(cash.enforced.cleared, false);
+  assert.deepEqual(cash.enforced.missing, ['Processor onboarding done', 'Tax details collected', 'Age check passed', 'Sanctions screening done', 'Signed pay rule on file'],
+    'the five things cash needs, from the gate table');
+  assert.ok(cash.facts.some((n) => /EU aren't available yet/.test(n.reason)), 'builders in the EU: a fact about cash');
+  assert.ok(cash.facts.some((n) => /13 to 15/.test(n.reason)), 'minors on board: a fact about cash');
+  assert.ok(cash.facts.every((n) => n.enforced === false), 'a soft limit is never shown as enforced');
+  const equity = r.options.find((o) => o.pay_type === 'equity');
+  assert.ok(equity.facts.some((n) => n.effect === 'grey' && /nonprofit/i.test(n.reason)));
+  assert.equal(equity.advised_against, true);
+  // A blocked option is SHOWN, with its reason.
+  const eu = r.options.find((o) => o.pay_type === 'eu_labour');
+  assert.ok(eu, 'EU labour is listed, not hidden');
+  assert.equal(eu.status, 'closed');
+  assert.equal(eu.enforced.never, true);
+  assert.match(eu.enforced.reason, /refuses/);
+  assert.equal(eu.label, 'Paying builders in the EU');
+  // A cleared gate reads as allowed.
+  const q = project({ gates: payGates(['self_managed']) });
+  assert.equal((await pf.readOptions(q.deps())).options.find((o) => o.pay_type === 'self_managed').status, 'open');
+});
+
+test('changing a fact re-checks every option and says what it changed', async () => {
+  const p = project({ detail: { home_country: 'US', builder_geography: 'us-only' } });
+  let r = await pf.readOptions(p.deps());
+  assert.equal(r.options.find((o) => o.pay_type === 'cash').facts.length, 0);
+  const w = await pf.setFacts({ builder_geography: 'global' }, 1, p.deps());
+  const c = w.changed.find((x) => x.pay_type === 'cash');
+  assert.ok(c, 'cash is named as changed');
+  assert.ok(c.new_notes.some((n) => /EU/.test(n)));
+  r = await pf.readOptions(p.deps());
+  assert.ok(r.options.find((o) => o.pay_type === 'cash').facts.length > 0, 'the read reflects the new fact at once');
+  const back = await pf.setFacts({ builder_geography: 'us-only' }, 1, p.deps());
+  assert.ok(back.changed.find((x) => x.pay_type === 'cash').gone_notes.length > 0, 'and says when a note no longer applies');
+});
+
+test('a bad fact is refused with its reason; nothing is written', async () => {
+  const p = project({ detail: { home_country: 'US' } });
+  await pf.readFacts(p.deps());
+  const before = p.store.get(pf.FACTS_KEY);
+  assert.equal((await pf.setFacts({ nope: 1 }, 1, p.deps())).reason, 'unknown_fact');
+  assert.equal((await pf.setFacts({ builder_geography: 'mars' }, 1, p.deps())).reason, 'bad_fact');
+  assert.equal((await pf.setFacts({ home_region: 'CA-ON' }, 1, p.deps())).reason, 'region_not_in_country');
+  assert.equal((await pf.setFacts({ reward_intents: ['gold'] }, 1, p.deps())).reason, 'bad_fact');
+  assert.equal(p.store.get(pf.FACTS_KEY), before);
+});
+
+test('with no pay-rules module nothing is claimed as enforced', async () => {
+  const p = project({ detail: { entity: 'nonprofit' }, gates: null });
+  const r = await pf.readOptions(p.deps());
+  assert.equal(r.rules_module, false);
+  assert.ok(r.options.every((o) => o.enforced === null && o.status === 'no_rules_module'));
+  assert.ok(r.options.find((o) => o.pay_type === 'equity').facts.length > 0, 'the facts still speak');
+  assert.match(pf.optionsMarkdown(r), /nothing below is enforced by the server/);
+});
+
+test('the session read explains the rules and tells it never to add one', async () => {
+  const p = project({ detail: { home_country: 'US', builder_geography: 'global' } });
+  const md = pf.optionsMarkdown(await pf.readOptions(p.deps()));
+  assert.match(md, /never add a rule of your own/);
+  assert.match(md, /Closed \(enforced\)/);
+  assert.match(md, /Fact, not a rule: /);
+  assert.match(md, /Where its builders are: global \(from project creation, not yet confirmed\)/);
+  assert.match(md, /not answered/);
+});

package/tests/projects_hub.mjs

@@ -2240,7 +2240,7 @@ test('the wizard\'s own structures wear the world: hairline fields, cells of one
   assert.match(SCRIPT, /body: JSON\.stringify\(\{\s*slug: state\.slug,/, 'the filing still carries the slug first');
   assert.match(SCRIPT, /hosting_shape: 'cloud-host',/, 'the shape is unchanged');
   assert.match(SCRIPT, /target_ref: state\.owner \+ '\/' \+ state\.repo,/, 'the repo ref is unchanged');
-  assert.match(SCRIPT, /onboard_mode: state\.mode === 'adopt' \? 'adopt' : 'greenfield'/, 'the onboard mode is unchanged');
+  assert.match(SCRIPT, /onboard_mode: state\.mode === 'adopt' \|\| state\.folderUploaded \? 'adopt' : 'greenfield'/, 'the onboard mode: adopt, or a repo made from an uploaded folder (task 1005282)');
   // the kit walks every step and files against the stub
   const states = JSON.parse(fs.readFileSync(path.join(LANDING, 'projects.states.json'), 'utf8')).states;
   for (const s of ['named', 'ready', 'demo', 'checks-filled', 'row-code', 'row-extras', 'look', 'create-blocked', 'done']) assert.ok(states['in-new-' + s], `the ${s} state has a kit state`);

package/tests/provision_settings_apply.mjs

@@ -82,6 +82,7 @@ ${NEUTRAL_PREFIX}_DEMO_HOURS=
 ${NEUTRAL_PREFIX}_SHIP_MODE=
 ${NEUTRAL_PREFIX}_TEST_PROJECT=
 ${NEUTRAL_PREFIX}_GUIDE_HANDOFF=
+${NEUTRAL_PREFIX}_PROJECT_FACTS=
 ${NEUTRAL_PREFIX}_HUB_UPGRADE_URL=
 `;
 
@@ -153,7 +154,7 @@ t('settingsEnvVarsFor: the runner pushes the SAME pair webEnvBody writes at stan
     // the birth marker and a demo's box (task 1004506), empty on an un-stamped row
     [`${NEUTRAL_PREFIX}_FOUNDING_BIRTH`]: '', [`${NEUTRAL_PREFIX}_FOUNDING_GENESIS`]: '', [`${NEUTRAL_PREFIX}_DEMO_PEOPLE`]: '', [`${NEUTRAL_PREFIX}_DEMO_HOURS`]: '',
     // the wizard's ship mode (task 1004629), empty when none was picked
-    [`${NEUTRAL_PREFIX}_SHIP_MODE`]: '', [`${NEUTRAL_PREFIX}_TEST_PROJECT`]: '', [`${NEUTRAL_PREFIX}_GUIDE_HANDOFF`]: '',
+    [`${NEUTRAL_PREFIX}_SHIP_MODE`]: '', [`${NEUTRAL_PREFIX}_TEST_PROJECT`]: '', [`${NEUTRAL_PREFIX}_GUIDE_HANDOFF`]: '', [`${NEUTRAL_PREFIX}_PROJECT_FACTS`]: '',
     // where the hall's Update button goes (task 1004608), empty when no hub origin resolves
     [`${NEUTRAL_PREFIX}_HUB_UPGRADE_URL`]: '',
   });

package/tests/provisioning_env_manifest.mjs

@@ -235,6 +235,10 @@ console.log('\nthe routes:');
 
 let instance = null;
 provisioning.getInstanceById = async (_db, id) => (instance ? { ...instance, id } : null);
+// The routes also admit an owner-made grant (task 1004161) and audit each change: nobody here
+// holds a grant, and the audit rows are not this file's subject.
+require('../modules/provisioning/grants.js').liveGrant = async () => null;
+provisioning.recordEvent = async () => {};
 
 const api = require('../src/module-api.js');
 let builder = { id: 7, rank: 'xenos', github_login: 'owner' };

package/tests/provisioning_env_manifest_edit_delete.mjs

@@ -32,6 +32,8 @@ const express = require('express');
 
 const api = require('../src/module-api.js');
 const provisioning = require('../modules/provisioning/provisioning.js');
+// The gate also admits an owner-made grant (task 1004161, ADR 0407); nobody in this file holds one.
+require('../modules/provisioning/grants.js').liveGrant = async () => null;
 const envManifest = require('../modules/provisioning/env-manifest.js');
 const { attachFail } = require('../src/bongos/middleware/error-envelope.js');