@bongos/core 1.17.0

package/tests/criterion_progress.mjs

@@ -0,0 +1,220 @@
+// tests/criterion_progress.mjs
+//
+// Unit tests for buildCriterionProgress() — the pure aggregation half of
+// criterionProgress() (src/bongos/done-when.js, #435). It folds the flat joined
+// rows from GET /api/gds/versions/:id/progress into the per-criterion shape
+// (status counts + the not-yet-shipped `remaining` list). Split out from the DB
+// query so it's testable without Postgres (addresses the grader's
+// "core aggregation ships untested" finding).
+//
+// Row shape (one (criterion, task) pair; a criterion with no tasks → one row
+// with null task_* fields, mirroring the LEFT JOIN):
+//   { cnum, id, criterion_id, criterion_md, satisfied, task_id, task_title, task_status }
+//
+// Run:  node tests/criterion_progress.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { buildCriterionProgress, buildGoals } = require('../modules/lifecycle/done-when.js');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.message}`); }
+}
+
+const row = (cnum, id, crit, satisfied, task_id, task_title, task_status) =>
+  ({ cnum, id, criterion_id: crit, criterion_md: `md-${crit}`, satisfied, task_id, task_title, task_status });
+
+test('groups rows into one entry per criterion, in row order', () => {
+  const rows = [
+    row(1, 10, 'c-one', false, 100, 'V3.R54 — a', 'shipped'),
+    row(1, 10, 'c-one', false, 101, 'V3.R55 — b', 'backlog'),
+    row(2, 11, 'c-two', true, 200, 'V3.R60 — c', 'shipped'),
+  ];
+  const out = buildCriterionProgress('GDS-V3', rows, 0);
+  assert.equal(out.version_id, 'GDS-V3');
+  assert.equal(out.criteria.length, 2);
+  assert.deepEqual(out.criteria.map((c) => c.cnum), [1, 2]);
+  assert.equal(out.criteria[0].tasks.length, 2);
+});
+
+test('per-status counts + shipped + remaining count are correct', () => {
+  const rows = [
+    row(1, 10, 'c', false, 100, 't1', 'shipped'),
+    row(1, 10, 'c', false, 101, 't2', 'shipped'),
+    row(1, 10, 'c', false, 102, 't3', 'backlog'),
+    row(1, 10, 'c', false, 103, 't4', 'confirmed'),
+  ];
+  const c = buildCriterionProgress('V', rows, 0).criteria[0];
+  assert.equal(c.counts.total, 4);
+  assert.equal(c.counts.shipped, 2);
+  assert.equal(c.counts.backlog, 1);
+  assert.equal(c.counts.confirmed, 1);
+  assert.equal(c.counts.remaining, 2); // the non-shipped ones
+});
+
+test('remaining lists exactly the non-shipped tasks', () => {
+  const rows = [
+    row(1, 10, 'c', false, 100, 't-ship', 'shipped'),
+    row(1, 10, 'c', false, 101, 't-back', 'backlog'),
+  ];
+  const c = buildCriterionProgress('V', rows, 0).criteria[0];
+  assert.deepEqual(c.remaining.map((t) => t.id), [101]);
+  assert.equal(c.remaining[0].status, 'backlog');
+});
+
+test('criterion with no linked tasks (LEFT JOIN null row) → empty tasks, zeroed counts', () => {
+  const rows = [row(3, 12, 'lonely', false, null, null, null)];
+  const c = buildCriterionProgress('V', rows, 0).criteria[0];
+  assert.equal(c.tasks.length, 0);
+  assert.equal(c.counts.total, 0);
+  assert.equal(c.counts.shipped, 0);
+  assert.equal(c.counts.remaining, 0);
+  assert.deepEqual(c.remaining, []);
+});
+
+test('satisfied flag + criterion_id pass through untouched', () => {
+  const rows = [row(8, 45, 'cloneable-local-memory-server-sync', true, 273, 'V3.R54', 'shipped')];
+  const c = buildCriterionProgress('GDS-V3', rows, 0).criteria[0];
+  assert.equal(c.satisfied, true);
+  assert.equal(c.criterion_id, 'cloneable-local-memory-server-sync');
+  assert.equal(c.id, 45);
+});
+
+test('unattributed_tasks count passes through', () => {
+  assert.equal(buildCriterionProgress('V', [], 7).unattributed_tasks, 7);
+  assert.equal(buildCriterionProgress('V', [], undefined).unattributed_tasks, 0); // default
+});
+
+test('empty rows → no criteria, valid envelope', () => {
+  const out = buildCriterionProgress('V', [], 0);
+  assert.deepEqual(out.criteria, []);
+  assert.equal(out.version_id, 'V');
+});
+
+test('all-shipped criterion → remaining empty', () => {
+  const rows = [
+    row(1, 10, 'c', true, 1, 'a', 'shipped'),
+    row(1, 10, 'c', true, 2, 'b', 'shipped'),
+  ];
+  const c = buildCriterionProgress('V', rows, 0).criteria[0];
+  assert.equal(c.counts.remaining, 0);
+  assert.deepEqual(c.remaining, []);
+});
+
+// -------------------------------------------------------------------------
+// Auto-flag: pending_review (ADR 0086 §6 / BV1.R63)
+// A criterion is "met — pending review" iff NOT satisfied, has ≥1 task, all shipped.
+// -------------------------------------------------------------------------
+
+test('pending_review: all tasks shipped + NOT satisfied → flagged', () => {
+  const rows = [
+    row(1, 10, 'c', false, 1, 'a', 'shipped'),
+    row(1, 10, 'c', false, 2, 'b', 'shipped'),
+  ];
+  const c = buildCriterionProgress('V', rows, 0).criteria[0];
+  assert.equal(c.pending_review, true, 'all linked tasks shipped + unconfirmed → pending review');
+});
+
+test('pending_review: all shipped but ALREADY satisfied → not flagged (confirmed, not pending)', () => {
+  const rows = [row(1, 10, 'c', true, 1, 'a', 'shipped')];
+  const c = buildCriterionProgress('V', rows, 0).criteria[0];
+  assert.equal(c.pending_review, false, 'a confirmed criterion is done, not pending review');
+});
+
+test('pending_review: a non-shipped task in the mix → not flagged', () => {
+  const rows = [
+    row(1, 10, 'c', false, 1, 'a', 'shipped'),
+    row(1, 10, 'c', false, 2, 'b', 'backlog'),
+  ];
+  const c = buildCriterionProgress('V', rows, 0).criteria[0];
+  assert.equal(c.pending_review, false, 'not every task has shipped → not yet flag-able');
+});
+
+test('pending_review: criterion with NO tasks → not flagged (not started, not met)', () => {
+  const rows = [row(3, 12, 'lonely', false, null, null, null)];
+  const c = buildCriterionProgress('V', rows, 0).criteria[0];
+  assert.equal(c.pending_review, false, 'zero linked tasks is "not started", never "pending review"');
+});
+
+test('pending_review: a `confirmed` (not yet shipped) task does NOT flag — only shipped counts', () => {
+  const rows = [row(1, 10, 'c', false, 1, 'a', 'confirmed')];
+  const c = buildCriterionProgress('V', rows, 0).criteria[0];
+  assert.equal(c.pending_review, false, 'auto-flag keys on shipped, mirroring listPendingReviewCriteria');
+});
+
+// -------------------------------------------------------------------------
+// Goal grouping + version-done rollup (ADR 0086 §2 / BV1.R58)
+// -------------------------------------------------------------------------
+const grow = (cnum, id, crit, satisfied, goal_id, task_id, title, status) =>
+  ({ cnum, id, criterion_id: crit, criterion_md: `md-${crit}`, satisfied, goal_id, task_id, task_title: title, task_status: status });
+
+test('goals: criteria group under their goal_id; goals[] preserves goal order', () => {
+  const rows = [
+    grow(1, 10, 'c-a', false, 7, 100, 't', 'shipped'),
+    grow(2, 11, 'c-b', true, 7, null, null, null),
+    grow(3, 12, 'c-c', false, 8, 200, 'u', 'backlog'),
+  ];
+  const goalRows = [
+    { id: 7, title: 'Goal Seven', status: 'open', scope_modules: ['x'] },
+    { id: 8, title: 'Goal Eight', status: 'achieved', scope_modules: [] },
+  ];
+  const out = buildCriterionProgress('V', rows, 0, goalRows);
+  assert.deepEqual(out.goals.map((g) => g.id), [7, 8]);
+  assert.deepEqual(out.goals[0].criteria.map((c) => c.id), [10, 11]);
+  assert.deepEqual(out.goals[1].criteria.map((c) => c.id), [12]);
+  assert.equal(out.goals[0].scope_modules[0], 'x');
+  // criteria stay flat + now carry goal_id (back-compat + grouping key)
+  assert.equal(out.criteria.length, 3);
+  assert.equal(out.criteria.find((c) => c.id === 10).goal_id, 7);
+});
+
+test('goals: a goal with no criteria is kept (renders gracefully)', () => {
+  const out = buildCriterionProgress('V', [grow(1, 10, 'c', false, 7, null, null, null)], 0, [
+    { id: 7, title: 'Has crit', status: 'open', scope_modules: [] },
+    { id: 9, title: 'Empty goal', status: 'open', scope_modules: [] },
+  ]);
+  const empty = out.goals.find((g) => g.id === 9);
+  assert.ok(empty && empty.criteria.length === 0);
+});
+
+test('version_done: true only when there are goals and ALL are achieved', () => {
+  const rows = [grow(1, 10, 'c', true, 7, 1, 'a', 'shipped')];
+  const done = buildCriterionProgress('V', rows, 0, [{ id: 7, title: 'g', status: 'achieved', scope_modules: [] }]);
+  assert.equal(done.version_done, true);
+  assert.equal(done.goals_achieved, 1);
+  assert.equal(done.goals_total, 1);
+  const oneOpen = buildCriterionProgress('V', rows, 0, [
+    { id: 7, title: 'g', status: 'achieved', scope_modules: [] },
+    { id: 8, title: 'h', status: 'open', scope_modules: [] },
+  ]);
+  assert.equal(oneOpen.version_done, false);
+  assert.equal(oneOpen.goals_achieved, 1);
+});
+
+test('version_done: false when the version has no goals at all', () => {
+  const out = buildCriterionProgress('V', [], 0, []);
+  assert.equal(out.version_done, false);
+  assert.equal(out.goals_total, 0);
+  assert.deepEqual(out.goals, []);
+});
+
+test('goals: a criterion whose goal_id matches no goal → (ungrouped) bucket; version not done', () => {
+  const rows = [grow(1, 10, 'orphan', false, 999, null, null, null)];
+  const out = buildCriterionProgress('V', rows, 0, [{ id: 7, title: 'g', status: 'achieved', scope_modules: [] }]);
+  const ung = out.goals.find((g) => g.id === null);
+  assert.ok(ung && ung.criteria[0].id === 10, 'orphan criterion lands in the (ungrouped) bucket');
+  assert.equal(out.version_done, false, 'an open ungrouped bucket keeps the version not-done');
+});
+
+test('buildGoals: pure grouping, empty goalRows → []', () => {
+  assert.deepEqual(buildGoals([], []), []);
+});
+
+console.log('');
+console.log(`criterionProgress aggregation tests: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/tests/criterion_proposal.mjs

@@ -0,0 +1,109 @@
+// tests/criterion_proposal.mjs
+//
+// V3.R31 (#252) — Unit tests for the criterion-proposal body parser and the
+// idea_inbox VALID_KINDS enum extension.
+//
+// DB-touching paths (the ratifyCriterionProposal transaction itself) are
+// exercised by the post-deploy smoke run, not here — this file is meant to
+// run in any environment without a live Postgres.
+//
+// Run:  node tests/criterion_proposal.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const inbox = require('../modules/ideas/inbox.js');
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    passed += 1;
+    console.log(`  ok  ${name}`);
+  } catch (err) {
+    failed += 1;
+    console.log(`  FAIL  ${name}\n      ${err.message}`);
+  }
+}
+
+// -- VALID_KINDS enum ------------------------------------------------------
+test('VALID_KINDS includes criterion-proposal', () => {
+  assert.ok(
+    inbox.VALID_KINDS.includes('criterion-proposal'),
+    'criterion-proposal missing from VALID_KINDS'
+  );
+});
+
+test('VALID_KINDS still admits the original task-kind enum', () => {
+  for (const k of [
+    'feature', 'bug', 'infra', 'refactor', 'spike',
+    'learning-capture', 'cleanup', 'decision', 'blocker-resolution',
+    'unclassified',
+  ]) {
+    assert.ok(inbox.VALID_KINDS.includes(k), `${k} missing from VALID_KINDS`);
+  }
+});
+
+// -- parseProposalBody happy paths ----------------------------------------
+test('parseProposalBody returns the three fields on a good body', () => {
+  const body = JSON.stringify({
+    target_version: 'GDS-V3',
+    criterion_md: 'Builders can do X.',
+    sort_order_hint: 150,
+  });
+  const out = inbox.parseProposalBody(body);
+  assert.equal(out.target_version, 'GDS-V3');
+  assert.equal(out.criterion_md, 'Builders can do X.');
+  assert.equal(out.sort_order_hint, 150);
+});
+
+test('parseProposalBody defaults sort_order_hint to null when absent', () => {
+  const body = JSON.stringify({
+    target_version: 'GDS-V3',
+    criterion_md: 'Builders can do Y.',
+  });
+  const out = inbox.parseProposalBody(body);
+  assert.equal(out.sort_order_hint, null);
+});
+
+// -- parseProposalBody rejection paths ------------------------------------
+const BAD_BODIES = [
+  ['empty string', '', 'body_md_empty'],
+  ['unparseable JSON', 'hello world', 'body_md_not_json'],
+  ['array root', '[]', 'body_md_not_object'],
+  ['null root', 'null', 'body_md_not_object'],
+  ['missing target_version', JSON.stringify({ criterion_md: 'X' }), 'target_version_required'],
+  ['missing criterion_md', JSON.stringify({ target_version: 'V' }), 'criterion_md_required'],
+  ['target_version not a string', JSON.stringify({ target_version: 42, criterion_md: 'X' }), 'target_version_required'],
+  ['criterion_md not a string', JSON.stringify({ target_version: 'V', criterion_md: 42 }), 'criterion_md_required'],
+  ['sort_order_hint not numeric', JSON.stringify({ target_version: 'V', criterion_md: 'X', sort_order_hint: 'abc' }), 'sort_order_hint_not_integer'],
+  ['sort_order_hint a float', JSON.stringify({ target_version: 'V', criterion_md: 'X', sort_order_hint: 12.5 }), 'sort_order_hint_not_integer'],
+];
+
+for (const [label, body, expectedReason] of BAD_BODIES) {
+  test(`parseProposalBody rejects: ${label}`, () => {
+    let caught = null;
+    try { inbox.parseProposalBody(body); }
+    catch (err) { caught = err; }
+    assert.ok(caught, 'should have thrown');
+    assert.equal(caught.code, 'BAD_BODY', `expected BAD_BODY, got ${caught.code}`);
+    assert.equal(caught.reason, expectedReason, `expected ${expectedReason}, got ${caught.reason}`);
+  });
+}
+
+// -- constants -----------------------------------------------------------
+// V3.R28 (#248): delta tuned from +5 → +3. Recognizes good civic input
+// without overweighting it relative to peer-upvote signals (which arrive in
+// volume). Reason vocabulary unchanged.
+test('KARMA_RATIFY_DELTA = +3 (V3.R28 tuned this value; tunable)', () => {
+  assert.equal(inbox.KARMA_RATIFY_DELTA, 3);
+});
+test('KARMA_RATIFY_REASON = proposal_ratified matches migration 040 doc', () => {
+  assert.equal(inbox.KARMA_RATIFY_REASON, 'proposal_ratified');
+});
+
+console.log(`\nCriterion-proposal tests: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/tests/criterion_ref_parse.mjs

@@ -0,0 +1,53 @@
+// tests/criterion_ref_parse.mjs
+//
+// Unit test for db.parseCriterionRef (task 438) — the PURE classifier behind
+// resolveCriterionIds, which maps a criterion "ref" to one of:
+//   - a positional "Cn" token   → { kind: 'cnum', n }
+//   - a numeric done_when id     → { kind: 'id', id }
+//   - a criterion_id slug        → { kind: 'slug', slug }
+// resolveCriterionIds itself is DB-backed (it ranks a version's criteria), so the
+// parsing rule — the part that decides what a token MEANS — is what's unit-tested
+// here without a database. Run: node tests/criterion_ref_parse.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const db = require('../modules/lifecycle/db.js');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.message}`); }
+}
+
+test('"Cn" tokens are positional (case-insensitive, trimmed)', () => {
+  assert.deepEqual(db.parseCriterionRef('C8'), { kind: 'cnum', n: 8 });
+  assert.deepEqual(db.parseCriterionRef('c3'), { kind: 'cnum', n: 3 });
+  assert.deepEqual(db.parseCriterionRef('  C12  '), { kind: 'cnum', n: 12 });
+});
+
+test('bare digits are a numeric done_when_criteria.id (string or number)', () => {
+  assert.deepEqual(db.parseCriterionRef('42'), { kind: 'id', id: 42 });
+  assert.deepEqual(db.parseCriterionRef(42), { kind: 'id', id: 42 });
+  assert.deepEqual(db.parseCriterionRef('007'), { kind: 'id', id: 7 });
+});
+
+test('anything else is a criterion_id slug', () => {
+  assert.deepEqual(db.parseCriterionRef('cloneable-local-memory'), { kind: 'slug', slug: 'cloneable-local-memory' });
+  // "C" with no digits, "C8x", and an empty string are NOT positional tokens.
+  assert.deepEqual(db.parseCriterionRef('C'), { kind: 'slug', slug: 'C' });
+  assert.deepEqual(db.parseCriterionRef('C8x'), { kind: 'slug', slug: 'C8x' });
+  assert.deepEqual(db.parseCriterionRef(''), { kind: 'slug', slug: '' });
+  assert.deepEqual(db.parseCriterionRef(null), { kind: 'slug', slug: '' });
+});
+
+test('a "Cn" embedded in a longer string does NOT match (anchored)', () => {
+  // Only a whole-token "Cn" is positional — prose like "see C8 above" is a slug,
+  // never a silent position match (the brittleness migration 055 calls out).
+  assert.equal(db.parseCriterionRef('see C8 above').kind, 'slug');
+});
+
+console.log(`\ncriterion ref parse (task 438) tests: ${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);

package/tests/currency_label.mjs

@@ -0,0 +1,119 @@
+// tests/currency_label.mjs — the client-safe branding projection that drives the
+// hall/status surfaces from config (R56 currency / task 1195 + R57 look / task 1196,
+// ADR 0062 §3). Pure: exercises clientBranding() + the serve-internal injection.
+// The reward MATH + idempotency (migration 091) are untouched by R56/R57 and are
+// covered by tests/credit_grant.mjs — this file only asserts the LABEL + LOOK are
+// config-driven and that no server-only field leaks to the browser.
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import brandingMod from '../src/branding.js';
+import serveInternal from '../src/bongos/serve-internal.js';
+
+const { clientBranding } = brandingMod;
+const { injectBrandingGlobal, themeMarkup, injectModuleHallWidgets } = serveInternal;
+
+const OTB_ISH = {
+  identity: { productName: 'Off the Boats', worldName: 'Amazonprimea', company: { name: 'Hermeslines', site: 'x' } },
+  currency: { label: 'drachmae', symbol: '' },
+  theme: { palette: 'art/template/palette.json', mode: 'pixel-greek', ui: {
+    colors: { bg: '#ece0c2', ink: '#2a2110', accent: '#4a7d5c' },
+    fonts: { display: '"Cinzel", serif', body: '"EB Garamond", serif', links: ['https://fonts.example/css'] },
+    favicon: "data:image/svg+xml;utf8,<svg/>",
+  } },
+  rankLabels: { xenos: 'Xenos', archon: 'Archon' },
+  copy: { tagline: 'Goods straight off the boats.', hallName: "Builders' Hall", notFound: 'washed ashore' },
+};
+
+test('R56: clientBranding exposes the configurable currency label', () => {
+  assert.equal(clientBranding(OTB_ISH).currency.label, 'drachmae');
+  assert.equal(clientBranding({}).currency.label, 'credits'); // neutral fallback
+});
+
+test('R57: clientBranding exposes identity + theme + rankLabels', () => {
+  const c = clientBranding(OTB_ISH);
+  assert.equal(c.identity.worldName, 'Amazonprimea');
+  assert.equal(c.identity.productName, 'Off the Boats');
+  assert.equal(c.theme.colors.bg, '#ece0c2');
+  assert.equal(c.theme.fonts.display, '"Cinzel", serif');
+  assert.deepEqual(c.theme.fonts.links, ['https://fonts.example/css']);
+  assert.equal(c.rankLabels.archon, 'Archon');
+  assert.equal(c.copy.tagline, 'Goods straight off the boats.');
+});
+
+test('R57: clientBranding exposes theme.ui (web), NOT theme.palette (server-only game path)', () => {
+  const c = clientBranding(OTB_ISH);
+  assert.equal(c.theme.palette, undefined, 'the game pixel-art palette path must not leak to the client');
+  assert.equal(c.theme.mode, undefined);
+  assert.ok(c.theme.colors && c.theme.favicon, 'the WEB theme is what ships');
+});
+
+test('clientBranding is a SMALL allow-list — no server-only field leaks to the browser', () => {
+  const projected = clientBranding({
+    ...OTB_ISH,
+    domains: { publicOrigin: 'https://amazonprimea.com', cookieDomain: '.amazonprimea.com' },
+    repo: { owner: 'lars589', name: 'amazonprimea' },
+    db: { database: 'amazonprimea' },
+    envPrefix: 'OTB',
+  });
+  assert.deepEqual(Object.keys(projected).sort(), ['copy', 'currency', 'identity', 'rankLabels', 'theme']);
+  for (const leak of ['domains', 'repo', 'db', 'envPrefix', 'llmProjectName']) {
+    assert.equal(projected[leak], undefined, `${leak} must not reach the client`);
+  }
+});
+
+test('R56: injectBrandingGlobal inserts a synchronous window.__BRANDING__ before </head>', () => {
+  const html = '<!doctype html><html><head><title>x</title></head><body>hi</body></html>';
+  const out = injectBrandingGlobal(html, clientBranding(OTB_ISH));
+  assert.match(out, /<script>window\.__BRANDING__=\{.*\};<\/script>/);
+  assert.ok(out.indexOf('window.__BRANDING__') < out.indexOf('</head>'));
+  assert.ok(out.indexOf('</head>') < out.indexOf('<body>'));
+});
+
+test('R57: themeMarkup emits the :root palette override + font links + favicon', () => {
+  const m = themeMarkup(clientBranding(OTB_ISH).theme);
+  assert.match(m, /<style>:root\{[^}]*--bg:#ece0c2;/);
+  assert.match(m, /--ink:#2a2110;/);
+  assert.match(m, /--font-display:"Cinzel", serif;/);
+  assert.match(m, /<link rel="stylesheet" href="https:\/\/fonts\.example\/css">/);
+  assert.match(m, /<link rel="icon" href="data:image\/svg\+xml/);
+});
+
+test('R57: themeMarkup is a no-op when the pack carries no theme (stylesheet defaults stand)', () => {
+  assert.equal(themeMarkup(undefined), '');
+  assert.equal(themeMarkup({ colors: {}, fonts: { links: [] }, favicon: '' }), '');
+});
+
+test('R57: injected theme <style> lands AFTER the page stylesheet so the pack wins', () => {
+  const html = '<head><link rel="stylesheet" href="/builders/style.css"><title>x</title></head><body></body>';
+  const out = injectBrandingGlobal(html, clientBranding(OTB_ISH));
+  assert.ok(out.indexOf('/builders/style.css') < out.indexOf('<style>:root'), 'pack :root override must follow style.css');
+});
+
+test('injectBrandingGlobal degrades safely when there is no </head>', () => {
+  const out = injectBrandingGlobal('<div>no head</div>', clientBranding({}));
+  // The generated-client bundle (task 1996 / R09) loads first, then the branding
+  // script; both are prepended when there is no </head> to anchor on.
+  assert.match(out, /^<script src="\/lib\/bongos-client\.js\?v=[0-9a-f]{8}"><\/script><script>window\.__BRANDING__=/);
+  assert.ok(out.includes('<div>no head</div>'));
+});
+
+// --- BV1.R75: module hall-widget script injection (ADR 0062 §4) ---
+
+const HALL = '<body><script src="/builders/builders.js?v=2026-06-27-r75" defer></script></body>';
+
+test('R75: injectModuleHallWidgets inserts an enabled module widget BEFORE builders.js', () => {
+  const out = injectModuleHallWidgets(HALL, [{ key: 'alpha', src: '/modules/alpha/public/hall-widget.js' }]);
+  assert.match(out, /<script src="\/modules\/alpha\/public\/hall-widget\.js" defer><\/script>/);
+  // The widget script must load before its consumer (builders.js mounts the registry).
+  assert.ok(out.indexOf('/modules/alpha/public/hall-widget.js') < out.indexOf('/builders/builders.js'),
+    'a module widget must be injected before builders.js');
+});
+
+test('R75: injectModuleHallWidgets is a no-op when no module ships a hall widget (default today)', () => {
+  assert.equal(injectModuleHallWidgets(HALL, []), HALL);
+});
+
+test('R75: injectModuleHallWidgets falls back to </body> when builders.js anchor is absent', () => {
+  const out = injectModuleHallWidgets('<body>hi</body>', [{ key: 'beta', src: '/modules/beta/public/hall-widget.js' }]);
+  assert.ok(out.indexOf('/modules/beta/public/hall-widget.js') < out.indexOf('</body>'));
+});