@bongos/core 1.21.5 → 1.21.6

package/tests/settings_main_role.mjs

@@ -0,0 +1,190 @@
+// tests/settings_main_role.mjs — the Settings main-role picker (task 1004541 /
+// WA6.RP12, goal 1000095, criterion wa6-roles-read-true-in-public).
+//
+// The owner's rule (2026-09-30): the builder CHOOSES their main role. The server
+// side existed (builders.main_discipline, PATCH /me/disciplines main_discipline,
+// task 1004433) with nothing in the hall to make the choice. This EXECUTES the
+// real modules/hall-ui/public/settings.js in a minimal DOM stub against a canned
+// /me and a recording PATCH, and pins the control's contract:
+//
+//   - it seeds from GET /me's main_discipline (and /me now carries it:
+//     db-kernel getBuilderById selects the column);
+//   - the options are "Let my work decide" plus exactly the roles ticked above,
+//     and ticking/unticking a role adds/removes its option;
+//   - unticking the main role hands the choice back to "Let my work decide";
+//   - Save sends main_discipline in the same PATCH — the pick, or null to clear —
+//     and re-seeds from the server's echo.
+//
+// Pure vm + file-read (no DB/network) — runs in the DB-free unit gate.
+import { strict as assert } from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/settings.js'), 'utf8');
+const HTML = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/settings.html'), 'utf8');
+const KERNEL = fs.readFileSync(path.join(ROOT, 'src/bongos/db-kernel.js'), 'utf8');
+
+let passed = 0, failed = 0;
+async function t(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (e) { failed++; console.error(`  FAIL ${name}\n       ${e.message}`); }
+}
+
+const DISCIPLINES = ['engineer', 'artist', 'ideator', 'ui'];
+
+// A permissive element: everything settings.js touches at boot, with listeners
+// recorded so a test can fire them.
+function makeEl() {
+  const listeners = {};
+  return {
+    hidden: false, textContent: '', value: '', disabled: false, href: '', className: '',
+    dataset: {}, style: {}, children: [], _html: '',
+    set innerHTML(v) { this._html = String(v); }, get innerHTML() { return this._html; },
+    addEventListener(type, fn) { (listeners[type] || (listeners[type] = [])).push(fn); },
+    fire(type, ev) { for (const fn of listeners[type] || []) fn(ev); },
+    appendChild(c) { this.children.push(c); return c; },
+    append() {}, prepend() {}, remove() {}, setAttribute() {}, removeAttribute() {}, getAttribute() { return null; },
+    querySelector() { return null; }, querySelectorAll() { return []; }, closest() { return null; },
+    classList: { add() {}, remove() {}, toggle() {}, contains() { return false; } },
+    focus() {},
+  };
+}
+
+async function boot({ builder }) {
+  const els = new Map();
+  const $ = (sel) => { if (!els.has(sel)) els.set(sel, makeEl()); return els.get(sel); };
+  const patches = [];
+  const api = {
+    async request(method, url, opts = {}) {
+      if (method === 'GET' && url === '/api/bongos/me') return { status: 200, ok: true, data: { builder } };
+      if (method === 'PATCH' && url === '/api/bongos/me/disciplines') {
+        const body = opts.body;
+        patches.push(body);
+        const prefs = DISCIPLINES.filter((d) => body.preferred_disciplines.includes(d));
+        const main = body.main_discipline === undefined ? builder.main_discipline : body.main_discipline;
+        return { status: 200, ok: true, data: { builder: { ...builder, preferred_disciplines: prefs, main_discipline: main } } };
+      }
+      return { status: 404, ok: false, data: null };
+    },
+  };
+  const escapeHtml = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+  const document = {
+    getElementById: (id) => $(`#${id}`),
+    createElement: () => makeEl(),
+    dispatchEvent() {}, addEventListener() {},
+    querySelector: () => null, querySelectorAll: () => [],
+  };
+  const window = {
+    __BRANDING__: {}, __MODULES__: { enabled: {} },
+    BongosClient: { createClient: () => api },
+    OTB: {
+      $, escapeHtml, toast() {},
+      disciplines: () => DISCIPLINES,
+      roleLabel: (d) => (d === 'ui' ? 'UI' : d.charAt(0).toUpperCase() + d.slice(1)),
+      hubOrigin: () => null,
+      settingsPanels: () => [],
+    },
+    OTBKit: { emptyStateHtml: (m) => m, makeSectionRail: () => ({ refresh() {}, activate() {} }) },
+    location: { hash: '', pathname: '/settings', search: '', assign() {} },
+    scrollTo() {}, confirm: () => false, addEventListener() {},
+  };
+  const sandbox = {
+    window, document, console: { log() {}, warn() {}, error() {}, info() {} },
+    history: { replaceState() {} }, URLSearchParams, setTimeout, clearTimeout,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(SRC, sandbox, { filename: 'settings.js' });
+  for (let i = 0; i < 12; i++) await new Promise((r) => setImmediate(r));
+
+  // The control as a test sees it.
+  const options = () => [...$('#craft-main-opts').innerHTML.matchAll(/value="([^"]*)"(\s*checked)?>([^<]*)<\/label>/g)]
+    .map((m) => ({ value: m[1], checked: !!m[2], label: m[3] }));
+  const checked = () => (options().find((o) => o.checked) || {}).value;
+  const toggleRole = (d, on) => {
+    const chip = { dataset: {} };
+    const box = { value: d, checked: on, closest: (sel) => (sel === '.craft-pref' ? box : sel === '.craft-chip' ? chip : null) };
+    $('#craft-chips').fire('change', { target: box });
+  };
+  const pickMain = (v) => {
+    const pick = { value: v, closest: (sel) => (sel === '.craft-main-pick' ? pick : null) };
+    $('#craft-main-opts').fire('change', { target: pick });
+  };
+  const save = async () => {
+    $('#craft-save').fire('click', {});
+    for (let i = 0; i < 6; i++) await new Promise((r) => setImmediate(r));
+  };
+  return { $, options, checked, toggleRole, pickMain, save, patches };
+}
+
+const B = (over = {}) => ({ id: 4, github_login: 'b4', display_name: 'Builder 4', preferred_disciplines: ['engineer', 'ideator'], main_discipline: null, ...over });
+
+console.log('\nthe main-role picker:');
+
+await t('the markup carries the Main role group inside Preferred roles', () => {
+  const craft = HTML.slice(HTML.indexOf('id="craft-scroll"'), HTML.indexOf('id="craft-save"'));
+  assert.match(craft, /<fieldset class="craft-main" id="craft-main">/);
+  assert.match(craft, /<legend class="craft-main__h">Main role<\/legend>/);
+  assert.match(craft, /id="craft-main-opts"/);
+  assert.match(craft, /leads your profile and your leaderboard entry/, 'it says what a main role does');
+});
+
+await t('GET /me carries the saved main role (getBuilderById selects the column)', () => {
+  const sel = KERNEL.slice(KERNEL.indexOf('async function getBuilderById'), KERNEL.indexOf('FROM builders WHERE id = $1'));
+  assert.match(sel, /\bmain_discipline\b/);
+});
+
+await t('options are "Let my work decide" plus exactly the ticked roles; nothing saved → by work', async () => {
+  const p = await boot({ builder: B() });
+  assert.deepEqual(p.options().map((o) => o.value), ['', 'engineer', 'ideator']);
+  assert.equal(p.options()[0].label, 'Let my work decide');
+  assert.deepEqual(p.options().map((o) => o.label).slice(1), ['Engineer', 'Ideator']);
+  assert.equal(p.checked(), '', 'no saved main role → "Let my work decide" is chosen');
+});
+
+await t('a saved main role is the one chosen on load', async () => {
+  const p = await boot({ builder: B({ main_discipline: 'ideator' }) });
+  assert.equal(p.checked(), 'ideator');
+});
+
+await t('ticking a role adds its option; unticking the MAIN role hands the choice back to your work', async () => {
+  const p = await boot({ builder: B({ main_discipline: 'ideator' }) });
+  p.toggleRole('artist', true);
+  assert.deepEqual(p.options().map((o) => o.value), ['', 'engineer', 'artist', 'ideator'], 'in the instance\'s role order');
+  assert.equal(p.checked(), 'ideator', 'adding a role keeps the pick');
+  p.toggleRole('ideator', false);
+  assert.deepEqual(p.options().map((o) => o.value), ['', 'engineer', 'artist']);
+  assert.equal(p.checked(), '', 'a role you no longer have cannot lead');
+});
+
+await t('Save sends the pick in the same PATCH, and the echo re-seeds it', async () => {
+  const p = await boot({ builder: B() });
+  p.pickMain('ideator');
+  await p.save();
+  assert.equal(p.patches.length, 1);
+  assert.deepEqual(JSON.parse(JSON.stringify(p.patches[0])), { preferred_disciplines: ['engineer', 'ideator'], main_discipline: 'ideator' });
+  assert.equal(p.checked(), 'ideator', 'the server\'s echo is what the control shows after saving');
+  assert.match(p.$('#craft-status').textContent, /Main role: Ideator\./);
+});
+
+await t('"Let my work decide" saves null, which clears a saved main role', async () => {
+  const p = await boot({ builder: B({ main_discipline: 'engineer' }) });
+  p.pickMain('');
+  await p.save();
+  assert.equal(p.patches[0].main_discipline, null);
+  assert.equal(p.checked(), '');
+  assert.doesNotMatch(p.$('#craft-status').textContent, /Main role/);
+});
+
+await t('unticking the main role, then saving, sends null — never a role outside the set', async () => {
+  const p = await boot({ builder: B({ main_discipline: 'ideator' }) });
+  p.toggleRole('ideator', false);
+  await p.save();
+  assert.deepEqual(JSON.parse(JSON.stringify(p.patches[0])), { preferred_disciplines: ['engineer'], main_discipline: null });
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);

package/tests/software_update.mjs

@@ -194,7 +194,7 @@ const STUB_UPDATE = { reading: 'ok', running: '1.19.10', offered: '1.19.13' };
 test('the platform\'s hall: the Update button goes to its own door', async () => {
   const r = await drive({ softwareUpdate: async () => STUB_UPDATE, canUpdate: async () => true, doorInputs: () => ({ provisioning: true, idp: null }) });
   assert.equal(r.status, 200);
-  assert.deepEqual(r.body.update, STUB_UPDATE);
+  assert.deepEqual(r.body.update, { ...STUB_UPDATE, channel_source: 'default' }, 'the reader\'s answer, plus which rule it used');
   assert.deepEqual(r.body.door, { kind: 'local', url: '/deploy' });
   assert.equal(r.body.can_update, true);
 });
@@ -447,3 +447,58 @@ test('the platform, which runs the door, keeps /deploy behind its own page gate'
   assert.equal(r.status, 302, 'a visitor with no session meets the page gate');
   assert.match(String(r.location), /auth|sign/i, 'and is sent to sign in, as before');
 });
+
+// ── the project's OWN update rule reaches the offer (task 1004535) ────────────
+//
+// The live defect, 2026-10-02: cloudbongos's rule on /deploy is `minor` and the sweep
+// follows it, but GET /software-update answered `"channel": "patch"` — the platform
+// default — so a step-up release would read "up to date" here while the sweep installed it.
+
+test('the route hands the reader the project\'s stored update rule (task 1004535)', async () => {
+  let seen;
+  const r = await drive({ softwareUpdate: async (a) => { seen = a; return STUB_UPDATE; }, selfChannel: async () => 'minor',
+    canUpdate: async () => true, doorInputs: () => ({ provisioning: true, idp: null }) });
+  assert.equal(r.status, 200);
+  assert.equal(seen.channel, 'minor', 'the rule set on /deploy, not the platform default');
+  assert.equal(r.body.update.channel_source, 'deploy', 'and the answer says which rule it used');
+});
+
+test('no stored rule, or a failed read of it, falls back to the default — never a 500 (task 1004535)', async () => {
+  for (const selfChannel of [async () => null, async () => { throw new Error('db down'); }]) {
+    let seen;
+    const r = await drive({ softwareUpdate: async (a) => { seen = a; return STUB_UPDATE; }, selfChannel,
+      canUpdate: async () => true, doorInputs: () => ({ provisioning: false, idp: null }) });
+    assert.equal(r.status, 200);
+    assert.equal(seen.channel, null, 'null → the reader applies DEFAULT_CHANNEL');
+    assert.equal(r.body.update.channel_source, 'default');
+  }
+});
+
+test('the REAL default reads the provisioning.selfUpdateChannel port — and with no provider, the default (task 1004535)', async () => {
+  // No selfChannel injected: the shipped storedSelfChannel → seams.resolveOptional path runs.
+  const seams = require('../src/module-seams.js');
+  const stub = { softwareUpdate: async (a) => ({ reading: 'ok', channel: a.channel }), canUpdate: async () => true, doorInputs: () => ({ provisioning: false, idp: null }) };
+  try {
+    seams._reset();
+    let r = await drive(stub);
+    assert.equal(r.status, 200);
+    assert.equal(r.body.update.channel, null, 'module off: no provider, so no rule is claimed');
+    assert.equal(r.body.update.channel_source, 'default');
+    seams.registerProvider('provisioning.selfUpdateChannel', async () => 'minor');
+    r = await drive(stub);
+    assert.equal(r.body.update.channel, 'minor', 'module on: the port the provisioning module registers is the one read');
+    assert.equal(r.body.update.channel_source, 'deploy');
+  } finally {
+    seams._reset();
+  }
+});
+
+test('[source] the port the route reads is the port the provisioning module registers and declares (task 1004535)', () => {
+  const port = 'provisioning.selfUpdateChannel';
+  const route = fs.readFileSync(path.join(ROOT, 'src/bongos/routes/core-update.js'), 'utf8');
+  const reg = fs.readFileSync(path.join(ROOT, 'modules/provisioning/seams.js'), 'utf8');
+  const manifest = JSON.parse(fs.readFileSync(path.join(ROOT, 'modules/provisioning/module.json'), 'utf8'));
+  assert.ok(route.includes(`'${port}'`), 'the route asks for it');
+  assert.ok(reg.includes(`'${port}'`), 'the module registers it');
+  assert.ok(manifest.provides.includes(port), 'and declares it');
+});

package/tests/update_subscription_engine.mjs

@@ -500,7 +500,7 @@ test('both commitPin successes report committed:true', () => {
 
 // A resolveFrom/load pair standing in for the target instance's core, so the probe is
 // exercised without a second core on disk.
-function fakeCore({ api, willRewrite, upgradeThrows = false, materializeThrows = false } = {}) {
+function fakeCore({ api, willRewrite, upgradeThrows = false, materializeThrows = false, own = () => null } = {}) {
   const seen = [];
   const resolveFrom = (dir, rel) => {
     if (rel === 'scripts/gds/upgrade.js' && api === null) return null;
@@ -515,7 +515,7 @@ function fakeCore({ api, willRewrite, upgradeThrows = false, materializeThrows =
     if (materializeThrows) throw new Error('materialize blew up');
     return { materializeWillRewrite: willRewrite === undefined ? undefined : (args) => { seen.push(args); return willRewrite; } };
   };
-  return { resolveFrom, load, seen };
+  return { resolveFrom, load, seen, own };
 }
 
 test('laneGeneratedPaths unions the API artifacts with what materialize WOULD rewrite', () => {
@@ -545,7 +545,8 @@ test('laneGeneratedPaths is FAIL-SOFT in every direction — an empty set, never
   // The direction matters. An instance this cannot interrogate keeps the OLD, stricter guard
   // (still wedged, and visibly so), rather than gaining a looser one that commits a stranger's work.
   assert.deepEqual(S.laneGeneratedPaths('/srv/demo', fakeCore({ api: null, willRewrite: null })), []);
-  assert.deepEqual(S.laneGeneratedPaths('/srv/demo', fakeCore({ api: {}, willRewrite: undefined })), []);
+  // A core that predates the preview, and no .claude/skills to walk under it: nothing to fall back on.
+  assert.deepEqual(S.laneGeneratedPaths('/srv/demo', fakeCore({ api: {}, willRewrite: undefined, own: () => () => ['CLAUDE.md'] })), []);
   assert.deepEqual(S.laneGeneratedPaths('/srv/demo', fakeCore({ upgradeThrows: true, materializeThrows: true })), []);
   // A core that exports API_ARTIFACT_FILES but whose materialize throws still contributes the
   // half it could answer for.
@@ -555,6 +556,57 @@ test('laneGeneratedPaths is FAIL-SOFT in every direction — an empty set, never
   );
 });
 
+// ---------------------------------------------------------------------------
+// task 1004519 — a core too old to preview its own rewrite. hoodify-finance took one bump to
+// 1.19.871 (before materializeWillRewrite, 1.19.933), was left with 33 materialized skills
+// uncommitted, and halted on them every sweep because its core answered nothing for them.
+// ---------------------------------------------------------------------------
+
+function oldCoreOnDisk(skills) {
+  const dir = mkdtempSync(path.join(tmpdir(), 'sweep-oldcore-'));
+  const core = path.join(dir, 'node_modules', '@bongos', 'core');
+  for (const name of skills) {
+    mkdirSync(path.join(core, '.claude', 'skills', name), { recursive: true });
+    writeFileSync(path.join(core, '.claude', 'skills', name, 'SKILL.md'), `# ${name}\n`);
+  }
+  // An instance-owned CLAUDE.md, so the starter is not "would write" here.
+  writeFileSync(path.join(dir, 'CLAUDE.md'), '# instance\n');
+  return dir;
+}
+
+test('laneGeneratedPaths falls back to the sweep\'s own preview when the instance core predates it', () => {
+  const dir = oldCoreOnDisk(['ask-for-help', 'blocker-review']);
+  // The instance's core resolves claude-materialize.js but exports no materializeWillRewrite.
+  const core = fakeCore({ api: { g: ['docs/api/openapi.json'] }, willRewrite: undefined, own: () => require('../scripts/gds/claude-materialize.js').materializeWillRewrite });
+  const got = S.laneGeneratedPaths(dir, core);
+  for (const f of ['.claude/skills/ask-for-help/SKILL.md', '.claude/skills/blocker-review/SKILL.md', 'docs/api/openapi.json']) {
+    assert.ok(got.includes(f), `${f} is the lane's own output and must be classified so`);
+  }
+  assert.ok(!got.includes('CLAUDE.md'), 'an instance-owned CLAUDE.md is never the lane\'s');
+});
+
+test('real git: the hoodify-finance wedge clears — old-core skills sort as generated, a hand-written skill still halts', () => {
+  const dir = oldCoreOnDisk(['ask-for-help']);
+  const g = (...a) => spawnSync('git', ['-C', dir, ...a], { encoding: 'utf8' });
+  writeFileSync(path.join(dir, '.gitignore'), 'node_modules/\n');
+  mkdirSync(path.join(dir, '.claude', 'skills', 'ask-for-help'), { recursive: true });
+  mkdirSync(path.join(dir, '.claude', 'skills', 'my-own'), { recursive: true });
+  writeFileSync(path.join(dir, '.claude', 'skills', 'ask-for-help', 'SKILL.md'), 'old\n');
+  writeFileSync(path.join(dir, '.claude', 'skills', 'my-own', 'SKILL.md'), 'mine\n');
+  g('init', '-q'); g('add', '-A'); g('-c', 'user.email=t@t', '-c', 'user.name=t', 'commit', '-qm', 'init');
+  const core = fakeCore({ api: {}, willRewrite: undefined, own: () => require('../scripts/gds/claude-materialize.js').materializeWillRewrite });
+  // The bump rewrote the materialized skill and left it uncommitted.
+  writeFileSync(path.join(dir, '.claude', 'skills', 'ask-for-help', 'SKILL.md'), 'new\n');
+  let pre = S.pinState(dir, spawnSync, S.laneGeneratedPaths(dir, core));
+  assert.deepEqual(pre.other, []);
+  assert.deepEqual(S.healDecision(pre, 'push').action, 'commit');
+  // An owner's own skill is not in the installed core's .claude/, so it is still a human's work.
+  writeFileSync(path.join(dir, '.claude', 'skills', 'my-own', 'SKILL.md'), 'edited\n');
+  pre = S.pinState(dir, spawnSync, S.laneGeneratedPaths(dir, core));
+  assert.deepEqual(pre.other.map((e) => e.file), ['.claude/skills/my-own/SKILL.md']);
+  assert.deepEqual(S.healDecision(pre, 'push'), { action: 'halt' });
+});
+
 test('the core still exports the two things the probe reads', () => {
   // laneGeneratedPaths reads them BY NAME off a module it resolves at runtime, so a rename in the
   // core degrades it silently to the empty set — the pre-fix wedge, back again and invisible.

package/tests/wizard_physics_more.mjs

@@ -600,3 +600,22 @@ test('a new owner walks from the quick checks through a fully confirmed review,
   assert.deepEqual({ voice: d.voice, framing: d.framing, services: d.services, team: [d.builders_at_start, d.builders_expected], shape: d.team_shape, rewards: d.reward_intents },
     { voice: 'professional', framing: 'open-source', services: undefined, team: [2, 5], shape: 'small-team', rewards: ['cash', 'equity'] });
 });
+
+// ── the address is the founder's own choice, on every path (task 1004507, BV2.PS19) ──
+test('no path reaches Look without the founder confirming the address: a prefill suggests it, never confirms it', async () => {
+  for (const draft of [{}, { demo: { people: 3, hours_each: 4, idea: '', invites: [] } }]) {
+    const label = draft.demo ? 'demo' : 'real project';
+    const w = await onReview({}, { draft });
+    assert.equal(w.state.confirmed.address, undefined, `${label}: the prefills leave the address unconfirmed`);
+    assert.equal(w.run("rowFixed('address')"), false, `${label}: the address is never a fixed row`);
+    assert.equal(w.row('address').querySelector('[data-row-chg]').hidden, false, `${label}: it can always be changed`);
+    for (const key of ['code', 'app', 'extras', 'team', 'rewards', 'run']) if (w.run(`rowApplies('${key}')`)) w.ok(key);
+    assert.deepEqual(plain(w.run('unconfirmedRows()')), ['address'], `${label}: every other row confirmed, the address still asked`);
+    assert.equal(w.go().disabled, true, `${label}: Continue stays locked`);
+    assert.equal(w.run('validateStep(4)'), false, `${label}: Continue refuses`);
+    assert.equal(w.isOpen('address'), true, `${label}: and opens the address row`);
+    w.use('address');
+    assert.equal(w.state.confirmed.address, true, `${label}: choosing it is the answer`);
+    assert.equal(w.run('validateStep(4)'), true, `${label}: then Continue goes on`);
+  }
+});