@bongos/core 1.19.1015 → 1.19.1016

package/tests/profile_rollup_consent.mjs

@@ -62,6 +62,7 @@ const ALL_ORIGINS = [PUB_ORIGIN, PRIV_ORIGIN, STEALTH_ORIGIN, UNREAD_ORIGIN];
 const q = (sql, params) => pool.query(sql, params);
 
 async function cleanup() {
+  await q(`DELETE FROM platform_identity_activity_snapshots WHERE github_id = ANY($1::bigint[])`, [ALL_IDS]).catch(() => {});
   await q(`DELETE FROM platform_identity_builder_project_activity WHERE github_id = ANY($1::bigint[])`, [ALL_IDS]).catch(() => {});
   await q(`DELETE FROM platform_identity_project_memberships WHERE github_id = ANY($1::bigint[])`, [ALL_IDS]).catch(() => {});
   await q(`DELETE FROM platform_identity_accounts WHERE github_id = ANY($1::bigint[])`, [ALL_IDS]).catch(() => {});
@@ -81,7 +82,9 @@ try {
   // error dressed up as a boundary failure — instead of a clean assertion.
   // 011 and 020 carry the columns the naming rule reads (description, visibility,
   // the door-known pair); 012_recent_ships the column the rollup SELECTs; 008 and
-  // 009 the handle and display_name_source columns upsertAccount writes.
+  // 009 the handle and display_name_source columns upsertAccount writes; 022 is
+  // the table upsertActivity now also writes on every call (task 1002977) — step
+  // 5 below issues that INSERT, and a fresh database without it fails 42P01.
   await q(migrationSql('platform_identity_001_tables.sql'));
   await q(migrationSql('platform_identity_004_projects.sql'));
   await q(migrationSql('platform_identity_005_builder_activity.sql'));
@@ -93,6 +96,7 @@ try {
   await q(migrationSql('platform_identity_012_recent_ships.sql'));
   await q(migrationSql('platform_identity_019_terms_acceptance.sql'));
   await q(migrationSql('platform_identity_020_visibility_pull.sql'));
+  await q(migrationSql('platform_identity_022_activity_snapshots.sql'));
   await cleanup();
 
   // CONSENT IS TWO COLUMNS (ADR 0213, task 1002913): profile_state='active' AND

package/tests/project_admin_console_model.mjs

@@ -0,0 +1,105 @@
+// tests/project_admin_console_model.mjs — the project admin console model holds
+// (task 1002813, R1 of the console wave; the ADR whose filename ends in ADR_SLUG).
+//
+// The ADR decides three things and then tells three build tasks what to build on
+// them. Its decisions rest on facts about live code, and a decision whose premises
+// drift quietly is worse than none, so the load-bearing ones are pinned here:
+//
+//   D1  the hub relays and notifies; it never writes a project's admission row
+//   D2  an invite is a row the existing gate already reads — `kind` and
+//       `created_by` are descriptive and never enter the admission read
+//   D3  the admission verdict stays `access_request.review` at the archon floor,
+//       and `project.recruit`, once minted, takes exactly the shape the ADR fixes
+//
+// The ADR is found by its slug, not its number, because a parallel ADR can take
+// the number first and force a renumber (tests/adr_renumber_integrity.mjs).
+//
+// Run:  node --test --test-reporter=tap tests/project_admin_console_model.mjs
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const ADR_DIR = path.join(ROOT, 'docs', 'adr');
+const ADR_SLUG = 'an-invite-is-a-pre-approved-row-on-the-projects-own-instance.md';
+const catalog = require(path.join(ROOT, 'modules', 'government', 'catalog.js'));
+const { stripComments } = require(path.join(ROOT, 'scripts', 'gds', 'category-advisory-guard.js'));
+
+const read = (...p) => fs.readFileSync(path.join(ROOT, ...p), 'utf8');
+
+function findAdr() {
+  const hits = fs.readdirSync(ADR_DIR).filter((f) => /^\d{4}-/.test(f) && f.endsWith(ADR_SLUG));
+  assert.equal(hits.length, 1, `exactly one ADR ends in ${ADR_SLUG}; found ${hits.length}`);
+  return hits[0];
+}
+
+function jsFilesUnder(dir) {
+  const out = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name === 'node_modules' || entry.name === 'tests') continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...jsFilesUnder(full));
+    else if (entry.name.endsWith('.js')) out.push(full);
+  }
+  return out;
+}
+
+test('the ADR exists, is indexed, and ADR 0141 names it as superseding its §5 invitations note', () => {
+  const file = findAdr();
+  const index = read('docs', 'adr', 'README.md');
+  assert.ok(index.includes(`](${file})`), 'docs/adr/README.md carries an index row linking the ADR');
+
+  const status = read('docs', 'adr', '0141-cross-site-identity-federated-hub-idp.md')
+    .split(/\r?\n/)
+    .find((l) => l.startsWith('- **Status:**'));
+  assert.ok(status, 'ADR 0141 keeps a Status line');
+  assert.ok(status.includes(file), 'ADR 0141 Status line links the superseding ADR');
+  assert.match(status, /§5/, 'the supersession is partial — it names §5, not the whole of ADR 0141');
+
+  const specHead = read('docs', 'specs', 'bongos-v1-project-admin-console.md').split(/\r?\n/)[0];
+  assert.ok(specHead.includes(file), 'the spike spec sends its reader to the ADR that narrowed it');
+});
+
+// Both admission reads: the gate's own (hasInvitedAccessRequest) and the state the
+// "confirming access" waiting page polls (accessStateByLogin), which must agree with it.
+test('D2: both admission reads look at status alone — an invite and an approved application admit identically', () => {
+  const src = read('src', 'bongos', 'db-kernel.js');
+  for (const fn of ['hasInvitedAccessRequest', 'accessStateByLogin']) {
+    const m = new RegExp(`async function ${fn}\\([^)]*\\)\\s*\\{([\\s\\S]*?)\\n\\}`).exec(src);
+    assert.ok(m, `${fn} is still an admission read in db-kernel.js`);
+    const body = m[1];
+    assert.match(body, /status\s*=\s*'invited'/, `${fn}: admission is status = invited`);
+    assert.doesNotMatch(body, /\bkind\b/, `${fn}: kind is descriptive; it must never decide admission`);
+    assert.doesNotMatch(body, /\bcreated_by\b/, `${fn}: created_by is audit data; it must never decide admission`);
+  }
+});
+
+test('D1: no hub (platform-identity) source writes access_requests — the hub relays, it never admits', () => {
+  const writers = [];
+  for (const f of jsFilesUnder(path.join(ROOT, 'modules', 'platform-identity'))) {
+    const code = stripComments(fs.readFileSync(f, 'utf8'));
+    if (/\b(?:INSERT\s+INTO|UPDATE|DELETE\s+FROM)\s+access_requests\b/i.test(code)) {
+      writers.push(path.relative(ROOT, f));
+    }
+  }
+  assert.deepEqual(writers, [], 'a project admits on its own instance; the hub reaches it only through a relay');
+});
+
+test('D3: the verdict stays access_request.review at archon, and project.recruit takes the fixed shape', () => {
+  const review = catalog.byKey('access_request.review');
+  assert.ok(review, 'access_request.review exists');
+  assert.equal(review.floor, 'archon', 'the admission verdict stays at the archon floor');
+
+  // R3 (task 1002815) mints the atom. Until then there is nothing to check; once
+  // it lands, this is the shape the ADR fixed, so a drifted mint reds here.
+  const recruit = catalog.byKey('project.recruit');
+  if (!recruit) return;
+  assert.equal(recruit.floor, 'archon', 'the per-project invite floor defaults to archon (ADR 0217 D1)');
+  assert.equal(recruit.system, false, 'grantable, and composable into a custom rank');
+  assert.ok(!recruit.substrate, 'enforced in the app, so a grant is never inert');
+  assert.ok(recruit.principal == null, 'held by ranks, never by a machine principal');
+});

package/tests/sky_read.mjs

@@ -47,7 +47,7 @@ await test('the shape: wells carry their criteria and their compact tasks; edges
     criteria: [cr(10, 1, 100, 'shipped'), cr(10, 1, 101, 'ready'), cr(11, 2, null)],
     tasks: [t(100, 1, { status: 'shipped', idea_id: '555' }), t(101, 1), t(200, 2)],
   });
-  assert.deepEqual(Object.keys(out), ['goals', 'edges', 'counts']);
+  assert.deepEqual(Object.keys(out), ['goals', 'edges', 'born', 'counts']);
   assert.deepEqual(out.edges, [{ from: '1', to: '2', count: 3 }]);
   assert.deepEqual(out.counts, { goals: 2, edges: 1, criteria: 2, tasks: 3 });
   const w1 = out.goals[0];
@@ -108,7 +108,7 @@ await test('a PRIVATE goal the viewer cannot see stays a well with its counts, r
 });
 
 await test('an empty corpus is a valid, empty sky', () => {
-  assert.deepEqual(shapeSky({}), { goals: [], edges: [], counts: { goals: 0, edges: 0, criteria: 0, tasks: 0 } });
+  assert.deepEqual(shapeSky({}), { goals: [], edges: [], born: { goals: {}, criteria: {} }, counts: { goals: 0, edges: 0, criteria: 0, tasks: 0 } });
 });
 
 // ---- the criterion→task link agrees with the progress rollup ------------------------
@@ -198,6 +198,23 @@ await test('the payload is the shaped sky, categories included, from one fake re
   assert.equal(out.goals[0].tasks[0].title, 'Task 100');
 });
 
+// ---- born of a thought (task 1004233, sky part 5) ---------------------------------------
+
+await test('born rides on the sky from the ideas port, normalised to string ids; an absent or failing port is an EMPTY map — never a guess', async () => {
+  const pool = fakePool({ goalRows: [{ goal_id: '1', title: 'A', status: 'open', version_id: 'V1', category_id: null, visible: true, task_total: 1, task_done: 0 }], extraRows: [x(1)] });
+  const out = await sky({ viewerId: 1 }, { pool, categoryIndex: async () => CATS, readBornOf: async () => ({ goals: { 1: 55 }, criteria: { 10: '56', 11: null } }) });
+  assert.deepEqual(out.born, { goals: { 1: '55' }, criteria: { 10: '56' } });
+  assert.equal(pool.calls.length, 5, 'the born read is the ideas module\'s own — not a sixth query here');
+  const none = await sky({ viewerId: 1 }, { pool: fakePool(), categoryIndex: async () => CATS, readBornOf: null });
+  assert.deepEqual(none.born, { goals: {}, criteria: {} });
+  const broken = await sky({ viewerId: 1 }, { pool: fakePool(), categoryIndex: async () => CATS, readBornOf: async () => { throw new Error('port down'); } });
+  assert.deepEqual(broken.born, { goals: {}, criteria: {} }, 'a failing port empties the map and the sky still draws');
+  assert.deepEqual(skyLib.normalizeBorn({ goals: 'nope' }), { goals: {}, criteria: {} });
+  const SKY_SRC = fs.readFileSync(path.join(ROOT, 'modules/lifecycle/sky.js'), 'utf8');
+  assert.match(SKY_SRC, /resolveOptional\('ideas\.bornOf'\)/, 'production resolves the port');
+  assert.equal(/ideas_goal_ratifications|criterion_proposal_audit/.test(SKY_SRC), false, 'lifecycle reads no ideas table itself');
+});
+
 // ---- the cache and the handler -------------------------------------------------------
 
 function run(handler, req) {

package/tests/ui_design_skills.mjs

@@ -145,6 +145,15 @@ test('impeccable is one in-house skill whose sixteen sub-commands each own exact
   }
 });
 
+test('impeccable menu names the kit-report temp dir OS-generically, not Windows-only %TMP% (task 1003636)', () => {
+  const skill = read(path.join(IMPECCABLE, 'SKILL.md'));
+  const signalLine = skill.split('\n').find((l) => l.includes('The last kit report'));
+  assert.ok(signalLine, 'the kit-report menu signal line exists');
+  assert.doesNotMatch(signalLine, /`%TMP%\/ui-design-kit/, 'the signal does not lead with a bare Windows %TMP% path');
+  assert.match(signalLine, /os\.tmpdir\(\)/, 'points at os.tmpdir(), which resolves per-OS');
+  assert.match(signalLine, /\$TMPDIR/, 'names the mac/linux env var too, not just %TMP%');
+});
+
 test('impeccable carries none of the behaviour that made its origin dangerous: no hooks, no bypass agent, no telemetry, no remote bundle, no live-server token', () => {
   const files = [path.join(IMPECCABLE, 'SKILL.md'), ...fs.readdirSync(path.join(IMPECCABLE, 'reference')).map((f) => path.join(IMPECCABLE, 'reference', f))];
   for (const f of files) {