@bongos/core 1.19.375 → 1.19.377

package/tests/goals_lib.mjs

@@ -1,8 +1,15 @@
 // tests/goals_lib.mjs — the Goals page's extracted pure helpers (goals-lib.js,
-// task 1003135). Pins (a) that the lib loads standalone in a bare window — it
-// must not silently grow a dependency on the page's IIFE state, which is the
-// whole reason it could move out of the oversized goals-page.js — and (b) the
-// behaviour of the helpers the page destructures.
+// task 1003135). Pins (a) that the lib loads with no dependency on the page's
+// IIFE state — the whole reason it could move out of the oversized
+// goals-page.js — and (b) the behaviour of the helpers the page destructures.
+//
+// task 1003278: "no page state" is NOT "no siblings". The lib already read
+// window.OTB.escapeHtml (subtitleAttr), and its activity clock now comes from
+// window.OTBTaskLib, because the criterion legibility-sort-and-staleness needs
+// ONE meaning of "touched" across both tiers — a synced pair of definitions is
+// the thing it is trying to prevent. So the harness loads the sibling libs the
+// way goals.html does (task-lib before goals-lib) and the property under test
+// stays what it always was: no reach into page state.
 //
 // Run:  node tests/goals_lib.mjs
 
@@ -15,17 +22,22 @@ import { makeRunner } from './helpers.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/goals-lib.js'), 'utf8');
+const TASK_LIB_SRC = fs.readFileSync(path.join(ROOT, 'modules/hall-ui/public/task-lib.js'), 'utf8');
 const { test, summary } = makeRunner();
 
 const windowObj = {};
 const sandbox = { window: windowObj, Set, Map, Math, Number, String, Array, Object, Date, JSON };
 sandbox.globalThis = sandbox;
 vm.createContext(sandbox);
+// The REAL sibling, in load order — stubbing it would let the shared activity
+// clock rot behind a fake that always agrees.
+vm.runInContext(TASK_LIB_SRC, sandbox, { filename: 'task-lib.js' });
 vm.runInContext(SRC, sandbox, { filename: 'goals-lib.js' });
 const lib = windowObj.OTBGoalsLib;
 
 await test('loads standalone in a bare window (no page-state dependency) and exports the full surface', () => {
   assert.ok(lib, 'window.OTBGoalsLib must be set');
+  assert.equal('state' in sandbox, false, 'the lib must not reach for page state');
   for (const k of ['DONE_STATUSES', 'CUT_STATUSES', 'isTodoStatus', 'ring', 'memberName',
     'readinessOf', 'EMPTY_ROLLUP', 'goalRollLine', 'matchesTodoSearch', 'msOf', 'taskActivityMs']) {
     assert.ok(k in lib, `missing export: ${k}`);

package/tests/kickoff_checklist.mjs

@@ -0,0 +1,107 @@
+// tests/kickoff_checklist.mjs — the shared kickoff checklist (task 1003239).
+//
+// One list, two filers: `bongos init` at scaffold time (self-host) and the lifecycle
+// module at the founder's first sign-in (hub-provisioned, where init ran --no-seed).
+// The first-sign-in shape must contain only what is still TRUE after a hub standup,
+// and must never name a surface that does not exist — the task's own rule: a blank
+// board beats untrue copy.
+//
+// Run:  node --test tests/kickoff_checklist.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { kickoffChecklist, productionTopologyKickoff } = require('../modules/lifecycle/kickoff-checklist.js');
+const { VALID_KINDS, VALID_DISCIPLINES } = require('../modules/lifecycle/task-classifier.js');
+
+const spec = () => ({
+  firstAdmin: 'founder', repo: { owner: 'o', name: 'n' },
+  domains: { publicOrigin: 'https://p.example' }, modules: [],
+});
+
+test('default (self-host): the seven owner-manual steps, topology included', () => {
+  const t = kickoffChecklist(spec());
+  assert.equal(t.length, 7);
+  assert.ok(t.some((x) => /OAuth/i.test(x.title)), 'OAuth app step');
+  assert.ok(t.some((x) => /founding owner/i.test(x.title)), 'first sign-in step');
+  assert.ok(t.some((x) => /repo binding/i.test(x.title)), 'repo binding step');
+  assert.ok(t.some((x) => /Production topology/i.test(x.title)), 'topology step');
+  assert.ok(t.every((x) => x.title && x.description), 'every step has a title + description');
+});
+
+test('provisioned: only the topology step is omitted', () => {
+  const t = kickoffChecklist(spec(), { provisioned: true });
+  assert.equal(t.length, 6);
+  assert.ok(!t.some((x) => /Production topology/i.test(x.title)));
+  assert.ok(t.some((x) => /OAuth/i.test(x.title)), 'the self-host owner still registers their OAuth app');
+});
+
+test('firstSignIn: only what is still true after a hub standup', () => {
+  const t = kickoffChecklist(spec(), { firstSignIn: true });
+  assert.deepEqual(
+    t.map((x) => x.title),
+    [
+      'Decide how people join, and invite the first builders',
+      'Arm the merge gate before a second builder joins (ci deploy mode)',
+      'Fill the instance look with your own LLM',
+    ],
+  );
+  for (const x of t) {
+    assert.ok(!/OAuth|founding owner|repo binding|topology/i.test(x.title + x.description),
+      `"${x.title}" names a step the standup already did`);
+  }
+});
+
+test('firstSignIn: the admission step points at surfaces that exist, never an env var', () => {
+  const join = kickoffChecklist(spec(), { firstSignIn: true })[0];
+  assert.ok(!/ENVPREFIX|OPEN_XENOS_ENROLLMENT|config\//.test(join.description), 'no env var or config file a hub founder cannot reach');
+  assert.match(join.description, /How people join/, 'the hub setting (task 1003044)');
+  assert.match(join.description, /manage page/, 'where the setting lives');
+  assert.match(join.description, /Watch page/, 'where invites live');
+  assert.match(join.description, /GitHub username/, 'how an invite is addressed');
+});
+
+test('firstSignIn: per-module keys still follow the enabled modules', () => {
+  const t = kickoffChecklist({ ...spec(), modules: ['art-pipeline', 'discord'] }, { firstSignIn: true });
+  assert.equal(t.length, 5);
+  assert.ok(t.some((x) => /Gemini/i.test(x.title)));
+  assert.ok(t.some((x) => /Discord/i.test(x.title)));
+});
+
+test('firstSignIn: never reads spec.repo or spec.firstAdmin (the steps that need them are omitted)', () => {
+  assert.doesNotThrow(() => kickoffChecklist({}, { firstSignIn: true }));
+  assert.equal(kickoffChecklist({}, { firstSignIn: true }).length, 3);
+});
+
+test('every variant satisfies the DB CHECK vocabulary (tasks_kind_check / tasks_discipline_check)', () => {
+  const full = { ...spec(), modules: ['art-pipeline', 'discord', 'dev-box'] };
+  const all = [
+    ...kickoffChecklist(full),
+    ...kickoffChecklist(full, { provisioned: true }),
+    ...kickoffChecklist(full, { firstSignIn: true }),
+    productionTopologyKickoff(),
+  ];
+  for (const t of all) {
+    assert.ok(VALID_KINDS.has(t.kind), `"${t.title}": kind '${t.kind}' violates tasks_kind_check`);
+    if (t.discipline !== undefined) {
+      assert.ok(VALID_DISCIPLINES.has(t.discipline), `"${t.title}": discipline '${t.discipline}' violates tasks_discipline_check`);
+    }
+  }
+});
+
+test('the look step is a decision BY an ideator in every variant', () => {
+  for (const opts of [{}, { provisioned: true }, { firstSignIn: true }]) {
+    const look = kickoffChecklist(spec(), opts).find((t) => /instance look/i.test(t.title));
+    assert.ok(look, `look step present for ${JSON.stringify(opts)}`);
+    assert.equal(look.kind, 'decision');
+    assert.equal(look.discipline, 'ideator');
+  }
+});
+
+test('returns fresh objects — a filer mutating one cannot poison the next call', () => {
+  const a = kickoffChecklist(spec(), { firstSignIn: true });
+  a[0].title = 'mutated';
+  assert.notEqual(kickoffChecklist(spec(), { firstSignIn: true })[0].title, 'mutated');
+});

package/tests/kickoff_seed.mjs

@@ -0,0 +1,93 @@
+// tests/kickoff_seed.mjs — the lifecycle module files the kickoff checklist at the
+// founder's first sign-in, and only onto an EMPTY board (task 1003239).
+//
+// The seed is idempotent by emptiness, not by path: the self-host path already filed
+// its checklist before anyone signed in, so it must be skipped there without any
+// "was I provisioned" marker. Every case runs against an in-memory pool + insert —
+// no database.
+//
+// Run:  node --test tests/kickoff_seed.mjs
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { seedKickoffIfEmpty, specFromBranding } = require('../modules/lifecycle/kickoff-seed.js');
+const buildRouter = require('../modules/lifecycle/routes/kickoff-seed.js');
+const api = require('../src/module-api.js');
+
+const spec = { firstAdmin: 'founder', repo: { owner: 'o', name: 'n' }, domains: { publicOrigin: 'https://p.example' }, modules: [] };
+
+function fakePool({ taskCount, versions }) {
+  const queries = [];
+  return {
+    queries,
+    query: async (sql) => {
+      queries.push(sql);
+      if (/FROM tasks/.test(sql)) return { rows: [{ n: taskCount }] };
+      if (/FROM versions/.test(sql)) return { rows: versions };
+      throw new Error(`unexpected query: ${sql}`);
+    },
+  };
+}
+
+test('an empty board gets the first-sign-in checklist, as ready tasks attributed to the founder', async () => {
+  const inserted = [];
+  const pool = fakePool({ taskCount: 0, versions: [{ id: 'V1' }] });
+  const r = await seedKickoffIfEmpty({ builderId: 7 }, { pool, spec, createTask: async (row) => { inserted.push(row); return row; } });
+  assert.deepEqual(r, { seeded: 3, versionId: 'V1' });
+  assert.equal(inserted.length, 3);
+  for (const row of inserted) {
+    assert.equal(row.versionId, 'V1');
+    assert.equal(row.status, 'ready', 'claimable from the first board, not backlog');
+    assert.equal(row.source, 'first-sign-in');
+    assert.equal(row.createdBy, 7);
+    assert.ok(row.title && row.description);
+  }
+  assert.match(inserted[0].title, /how people join/i);
+});
+
+test('a board that already has tasks is left alone (the self-host path seeded at init)', async () => {
+  const inserted = [];
+  const pool = fakePool({ taskCount: 12, versions: [{ id: 'V1' }] });
+  const r = await seedKickoffIfEmpty({ builderId: 7 }, { pool, spec, createTask: async (row) => inserted.push(row) });
+  assert.deepEqual(r, { seeded: 0, skipped: 'tasks_exist' });
+  assert.equal(inserted.length, 0);
+  assert.ok(!pool.queries.some((q) => /FROM versions/.test(q)), 'never even looks for a version');
+});
+
+test('no version to file under → skipped, nothing inserted', async () => {
+  const inserted = [];
+  const pool = fakePool({ taskCount: 0, versions: [] });
+  const r = await seedKickoffIfEmpty({ builderId: 7 }, { pool, spec, createTask: async (row) => inserted.push(row) });
+  assert.deepEqual(r, { seeded: 0, skipped: 'no_version' });
+  assert.equal(inserted.length, 0);
+});
+
+test('the version query prefers the building one, then the first by id', async () => {
+  const pool = fakePool({ taskCount: 0, versions: [{ id: 'V1' }] });
+  await seedKickoffIfEmpty({ builderId: 1 }, { pool, spec, createTask: async () => {} });
+  const q = pool.queries.find((s) => /FROM versions/.test(s));
+  assert.match(q, /status = 'building'/);
+  assert.match(q, /LIMIT 1/);
+});
+
+test('specFromBranding reads the instance pack and keeps modules empty', () => {
+  const s = specFromBranding({ firstAdmin: 'f', repo: { owner: 'a', name: 'b' }, domains: { publicOrigin: 'https://x' } });
+  assert.deepEqual(s, { firstAdmin: 'f', repo: { owner: 'a', name: 'b' }, domains: { publicOrigin: 'https://x' }, modules: [] });
+  assert.deepEqual(specFromBranding({}).repo, {});
+});
+
+test('the route factory registers the port once, returns an empty router, and the port delegates', async () => {
+  const before = api.hasProvider('lifecycle.kickoffSeed');
+  const router = buildRouter();
+  buildRouter(); // a rebuild must not trip the single-provider guard
+  assert.ok(api.hasProvider('lifecycle.kickoffSeed'));
+  assert.equal(typeof router, 'function');
+  assert.equal(router.stack.length, 0, 'seeding has no HTTP surface');
+  const port = api.resolveOptional('lifecycle.kickoffSeed');
+  const r = await port.seedIfEmpty({ builderId: 3 }, { pool: fakePool({ taskCount: 1, versions: [] }), spec });
+  assert.deepEqual(r, { seeded: 0, skipped: 'tasks_exist' });
+  assert.equal(before, false, 'this test registered it, nothing else in-process had');
+});

package/tests/provisioning_onboard_mode.mjs

@@ -21,9 +21,8 @@ import { createRequire } from 'node:module';
 import http from 'node:http';
 
 const require = createRequire(import.meta.url);
-const ROOT = new URL('..', import.meta.url).pathname;
 
-const provisioning = require(`${ROOT}/modules/provisioning/provisioning.js`);
+const provisioning = require('../modules/provisioning/provisioning.js');
 
 let passed = 0, failed = 0;
 function t(name, fn) {
@@ -99,11 +98,11 @@ provisioning.enqueueIntent = async () => ({ intent: { id: 1, state: 'pending' },
 provisioning.recordEvent = async () => {};
 provisioning.getInstanceBySlug = async () => null;
 
-const api = require(`${ROOT}/src/module-api.js`);
+const api = require('../src/module-api.js');
 api.requireBuilder = (req, _res, next) => { req.builder = { id: 7, github_login: 'owner' }; next(); };
 
 const express = require('express');
-const provisioningRoutes = require(`${ROOT}/modules/provisioning/routes/provisioning.js`);
+const provisioningRoutes = require('../modules/provisioning/routes/provisioning.js');
 const app = express();
 app.use(express.json());
 app.use((_req, res, next) => {

package/tests/search_ingest.mjs

@@ -11,6 +11,7 @@
 
 import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
 
 const require = createRequire(import.meta.url);
 const ingest = require('../scripts/gds/search-ingest-md.js');
@@ -61,7 +62,7 @@ test('SENSITIVE_DOC_GLOBS is the curated source of truth (subtrees end with /)',
 
 test('collectMarkdown finds the repo corpus but excludes node_modules/.git/worktrees/public', () => {
   const path = require('node:path');
-  const repoRoot = path.resolve(new URL('..', import.meta.url).pathname);
+  const repoRoot = path.resolve(fileURLToPath(new URL('..', import.meta.url)));
   const real = collectMarkdown(repoRoot, repoRoot);
   // Assert on paths RELATIVE to the repo root — the suite may run from inside a
   // git worktree (…/.claude/worktrees/<name>/…), so the ABSOLUTE paths would all
@@ -77,7 +78,7 @@ test('collectMarkdown finds the repo corpus but excludes node_modules/.git/workt
 
 test('chunkFile yields well-formed rows (source_kind doc, hash, rank, sequential index)', () => {
   const path = require('node:path');
-  const repoRoot = path.resolve(new URL('..', import.meta.url).pathname);
+  const repoRoot = path.resolve(fileURLToPath(new URL('..', import.meta.url)));
   const rows = chunkFile(path.join(repoRoot, 'docs', 'adr', '0016-trust-boundary-server-enforced-permissions.md'));
   assert.ok(rows.length > 0);
   rows.forEach((r, i) => {

package/tests/setup_smoke.mjs

@@ -22,8 +22,9 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 
-const REPO_ROOT = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..');
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const SETUP_JS = path.join(REPO_ROOT, 'scripts/gds/setup.js');
 
 const tests = [];
@@ -36,7 +37,8 @@ function makeFreshHome() {
 
 function runSetup(args, env = {}) {
   return spawnSync('node', [SETUP_JS, ...args], {
-    env: { ...process.env, ...env },
+    // os.homedir() reads USERPROFILE on Windows, so a HOME override alone leaks the real home there.
+    env: { ...process.env, ...env, ...(env.HOME ? { USERPROFILE: env.HOME } : {}) },
     encoding: 'utf8',
     timeout: 15000,
   });

package/tests/test_path_guard.mjs

@@ -0,0 +1,126 @@
+// tests/test_path_guard.mjs — the guard that keeps a test runnable on a checkout
+// whose path has a space in it (task 1002889).
+//
+// Four tests built their repo root from URL.pathname and threw MODULE_NOT_FOUND at
+// load on the owner's Windows checkout, while CI (no space in its path) stayed
+// green. The guard is tested on synthetic sources, not only the live tree: a scan
+// that passes because the tree is clean today proves nothing about what it REFUSES.
+//
+// The defective form is spelled by concatenation below so this file never trips the
+// guard it tests.
+//
+// Of the four files the task named, tests/provisioning_github_app_routes.mjs had
+// already been converted before this landed (915d273b, task 1003236 — fileURLToPath
+// at its line 17), so it is absent from this change on purpose; the live-tree case
+// at the bottom is what proves all four are clean.
+//
+// Run:  node tests/test_path_guard.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { checkTestsUseFileUrlToPath, scanTests } = require('../scripts/gds/test-path-guard.js');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+const from = (map) => ({
+  files: Object.keys(map),
+  read: (rel) => (rel in map ? map[rel] : null),
+});
+
+const BAD_TAIL = 'import.meta.url)' + '.pathname';
+
+// --- THE DEFECT ------------------------------------------------------------
+
+test('the shipped defect is refused, with its line and the fix', () => {
+  const { violations } = scanTests(...Object.values(from({
+    'tests/bad.mjs':
+      "import { createRequire } from 'node:module';\n"
+      + `const ROOT = new URL('..', ${BAD_TAIL};\n`
+      + 'const mod = require(`${ROOT}/modules/x.js`);\n',
+  })));
+  assert.equal(violations.length, 1);
+  assert.match(violations[0], /bad\.mjs:2/, 'names the file and line');
+  assert.match(violations[0], /%20/, 'says WHY it breaks');
+  assert.match(violations[0], /fileURLToPath/, 'and what to write instead');
+});
+
+test('the dirname form is the same defect', () => {
+  const { violations } = scanTests(...Object.values(from({
+    'tests/smoke.mjs': `const REPO_ROOT = path.resolve(path.dirname(new URL(${BAD_TAIL}), '..');\n`,
+  })));
+  assert.equal(violations.length, 1);
+});
+
+test('every site in a file is reported, not just the first', () => {
+  const { violations } = scanTests(...Object.values(from({
+    'tests/two.mjs':
+      `const a = path.resolve(new URL('..', ${BAD_TAIL});\n`
+      + 'x();\n'
+      + `const b = path.resolve(new URL('..', ${BAD_TAIL});\n`,
+  })));
+  assert.equal(violations.length, 2);
+  assert.match(violations[1], /two\.mjs:3/);
+});
+
+// --- WHAT IT MUST NOT FLAG -------------------------------------------------
+
+test('fileURLToPath and a relative createRequire are the correct forms — never flagged', () => {
+  const { violations } = scanTests(...Object.values(from({
+    'tests/good_a.mjs':
+      "import { fileURLToPath } from 'node:url';\n"
+      + "const ROOT = fileURLToPath(new URL('..', import.meta.url));\n",
+    'tests/good_b.mjs':
+      "const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');\n",
+    'tests/good_c.mjs':
+      "const require = createRequire(import.meta.url);\n"
+      + "const mod = require('../modules/x.js');\n",
+  })));
+  assert.deepEqual(violations, []);
+});
+
+test('a request URL parsed for its pathname is not the defect', () => {
+  // http tests routinely do this; the guard is about import.meta.url only.
+  const { violations } = scanTests(...Object.values(from({
+    'tests/routes.mjs': "const { pathname } = new URL(req.url, 'http://x');\nconst p = new URL(req.url, base).pathname;\n",
+  })));
+  assert.deepEqual(violations, []);
+});
+
+// --- THE SCAN MUST NOT SILENTLY SUCCEED ------------------------------------
+
+test('an empty enumeration is a hard FAIL, not a clean pass', () => {
+  const r = checkTestsUseFileUrlToPath({ files: [], read: () => null });
+  assert.equal(r.hardFail, true);
+  assert.match(r.violations[0], /scan defect/);
+});
+
+test('an unreadable file is skipped without being counted as scanned', () => {
+  const { scanned } = scanTests(['gone.mjs'], () => null);
+  assert.equal(scanned, 0);
+});
+
+test('the check reports hardFail so CI actually stops', () => {
+  const r = checkTestsUseFileUrlToPath(from({
+    'tests/bad.mjs': `const ROOT = new URL('..', ${BAD_TAIL};\n`,
+  }));
+  assert.equal(r.ok, false);
+  assert.equal(r.hardFail, true);
+});
+
+// --- THE LIVE TREE ---------------------------------------------------------
+
+test('the tracked tests/ tree is clean (the four sites of task 1002889 are fixed)', () => {
+  const r = checkTestsUseFileUrlToPath();
+  assert.equal(r.hardFail, false, r.violations.join('\n'));
+  assert.ok(/^\d+ test file\(s\) scanned/.test(r.note) && !r.note.startsWith('0 '), r.note);
+});
+
+console.log(`\ntest_path_guard: ${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);