@bongos/core 1.19.1015 → 1.19.1017

package/tests/recruiter_sliver_boundary.mjs

@@ -271,6 +271,9 @@ function accountFilter(where, params) {
   take(/\b(?:[a-z_]+\.)?terms_accepted_at IS NOT NULL/, () => (r) => r.terms_accepted_at != null);
   take(/\b(?:[a-z_]+\.)?account_visibility = 'public'/, () => (r) => r.account_visibility === 'public');
   take(/\bNOT (?:[a-z_]+\.)?hide_stats\b/, () => (r) => !r.hide_stats);
+  // The directory's name-only tier asks the hide flag POSITIVELY (task 1002291).
+  // After the NOT form, which consumes its own text first.
+  take(/\b(?:[a-z_]+\.)?hide_stats\b/, () => (r) => !!r.hide_stats);
 
   take(/\b(?:[a-z_]+\.)?github_id = \$(\d+)/, (m) => {
     consumed.add(m[1]);

package/tests/scouting_owner_access_and_reach.mjs

@@ -70,7 +70,11 @@ import { fileURLToPath } from 'node:url';
 // importing them here safe.
 import {
   scoutingListableSql,
+  scoutingNameOnlySql,
   rollupVisibleSql,
+  accountVisibleSql,
+  accountActiveSql,
+  recruiterReachSql,
   isRecruiterDiscoverable,
 } from '../modules/platform-identity/account-visibility.js';
 import {
@@ -130,8 +134,21 @@ const ACCOUNTS = [
   // presence in the SQL provable here rather than merely asserted.
   { github_id: '3030', github_login: 'unaccepted', display_name: 'Unaccepted',
     profile_state: 'active', terms_accepted_at: null, account_visibility: 'public', hide_stats: false, recruiter_discoverable: null },
+  // Task 1002291's two controls for the NAME-ONLY tier, each differing from `shy`
+  // in the one axis that must keep them out of it: `shyout` opted out of
+  // recruiting, `shypriv` is private (and opted in, which never buys existence).
+  { github_id: '6161', github_login: 'shyout', display_name: 'Shy Out',
+    profile_state: 'active', terms_accepted_at: ACCEPTED_AT, account_visibility: 'public', hide_stats: true, recruiter_discoverable: false },
+  { github_id: '6262', github_login: 'shypriv', display_name: 'Shy Private',
+    profile_state: 'active', terms_accepted_at: ACCEPTED_AT, account_visibility: 'private', hide_stats: true, recruiter_discoverable: true },
 ];
 
+// The record a hidden builder keeps private. Planted on every row the name-only
+// read hands back — a real row grows columns — so a projection that spread the
+// row instead of naming its keys would carry these into the body and fail below.
+const HIDDEN_RECORD = { github_id_echo: '6060-ID-ECHO', total_credits: 773311, total_tasks_shipped: 773322,
+  total_karma: 773333, project_count: 773344, last_active: 'shy-last-active-773355', disciplines: ['shy-craft-773366'] };
+
 // Project memberships, as the hub holds them. `membership_kind` is what the
 // PROJECT reported at check-in; `signin_verified_at` is the hub's OWN witness
 // that the person really signed in (ADR 0205 D1/D2). Owner needs both.
@@ -233,6 +250,9 @@ function accountFilter(where, params) {
   take(/\b(?:[a-z_]+\.)?terms_accepted_at IS NOT NULL/, () => (r) => r.terms_accepted_at != null);
   take(/\b(?:[a-z_]+\.)?account_visibility = 'public'/, () => (r) => r.account_visibility === 'public');
   take(/\bNOT (?:[a-z_]+\.)?hide_stats\b/, () => (r) => !r.hide_stats);
+  // The name-only tier's term (task 1002291): the hide flag asked POSITIVELY.
+  // Tried after the NOT form, which consumes its own text first.
+  take(/\b(?:[a-z_]+\.)?hide_stats\b/, () => (r) => !!r.hide_stats);
 
   // The TERM guards run before the STRUCTURE guard, so an unreadable term is
   // reported as the unreadable term it is rather than as leftover text.
@@ -318,6 +338,22 @@ const pool = {
       return { rows, rowCount: rows.length };
     }
 
+    // The directory's NAME-ONLY tier (task 1002291): a plain read of the accounts
+    // table, judged by its own WHERE. Each row comes back WHOLE, plus the record
+    // the builder hid, so the route's projection is what has to drop them.
+    if (/^SELECT .+ FROM platform_identity_accounts WHERE /.test(sql)) {
+      assert.doesNotMatch(sql, /platform_identity_builder_project_activity/,
+        'the name-only read must not consult the rollup — presence there would say who has built');
+      const where = sql.slice(sql.indexOf(' WHERE ') + 7).replace(/ ORDER BY .*| LIMIT .*/g, '');
+      const limit = Number(params[Number((/ LIMIT \$(\d+)/.exec(sql) || [, 0])[1]) - 1]);
+      assert.ok(limit > 0, 'the name-only read is bounded like the ranked one');
+      const rows = ACCOUNTS.filter(accountFilter(where, params))
+        .sort((a, b) => a.github_login.localeCompare(b.github_login))
+        .slice(0, limit)
+        .map((a) => ({ ...a, ...HIDDEN_RECORD }));
+      return { rows, rowCount: rows.length };
+    }
+
     throw new Error(`fake pool: unhandled statement — ${sql.slice(0, 120)}`);
   },
 };
@@ -391,6 +427,7 @@ function getScouting(caller, query = '') {
   });
 }
 const logins = (res) => JSON.parse(res.text).builders.map((b) => b.github_login).sort();
+const namedLogins = (res) => (JSON.parse(res.text).name_only || []).map((b) => b.github_login).sort();
 
 // The cast. `rank` is the caller's rank on the HUB; `github_id` is the hub
 // account whose project memberships decide the ownership door.
@@ -521,8 +558,8 @@ await t('and the whole matrix lands exactly where the specs put it', async () =>
   assert.deepEqual(shown, ['octo', 'optin'],
     'in: reach-unset-and-public (octo) + explicitly-opted-in (optin). '
     + 'out: optout (opted out), scout (private, and reach never buys addressability), '
-    + 'shy (hidden), newbie (provisional), unaccepted (never accepted the platform '
-    + `terms — ADR 0213) — got ${JSON.stringify(shown)}`);
+    + 'shy (hidden — ranked out, listed by name in the second tier below), newbie (provisional), '
+    + `unaccepted (never accepted the platform terms — ADR 0213) — got ${JSON.stringify(shown)}`);
 });
 
 await t('opting back IN restores them — the toggle is a toggle, not a tombstone', async () => {
@@ -613,6 +650,77 @@ await t('/people is the SAME endpoint, so "absent from /people" is true by const
     'and listScoutingRollup — the one reader behind both surfaces — joins the composed predicate');
 });
 
+// ===========================================================================
+// 2b. HIDE CHANGES THE SHAPE, NOT THE PRESENCE (task 1002291, R15)
+// ===========================================================================
+//
+// Privacy spec D2, the "active · public · hide_stats" row, recruiter column:
+// "listed name-only (if not opted out)". Until R15 the directory read hide as a
+// second opt-out and dropped the builder entirely, while the Settings row told
+// that same builder recruiters would see their name and picture. The directory
+// now has two tiers: the ranked record, and a name-only list.
+
+console.log('\nhide — a hidden builder stays findable, by name alone:');
+
+await t('a hidden, reachable builder is listed NAME-ONLY — and never in the ranked tier', async () => {
+  const res = await getScouting(OPERATOR);
+  assert.equal(res.status, 200);
+  assert.deepEqual(namedLogins(res), ['shy'],
+    'in: shy (public, hidden, reach unset). out: shyout (hidden but opted out), shypriv (hidden and private — '
+    + `reach never buys existence), and every unhidden builder, who is ranked instead — got ${JSON.stringify(namedLogins(res))}`);
+  assert.ok(!logins(res).includes('shy'), 'a hidden builder is never RANKED — rank position is derived from the record');
+  const read = calls.find((c) => /^SELECT .+ FROM platform_identity_accounts WHERE /.test(c.sql));
+  assert.ok(read, 'the name-only tier is a read of its own');
+  assert.ok(read.sql.includes(scoutingNameOnlySql()),
+    'and it joins the SHARED predicate, not a copy of it');
+});
+
+await t('the name-only row is identity and nothing else — the record the builder hid never reaches the body', async () => {
+  const res = await getScouting(OWNER);
+  const row = JSON.parse(res.text).name_only[0];
+  assert.deepEqual(Object.keys(row).sort(), ['avatar_url', 'display_name', 'github_login'],
+    'a literal whitelist: what a hidden builder\'s own public page already shows');
+  for (const [key, value] of Object.entries(HIDDEN_RECORD)) {
+    for (const v of [].concat(value)) {
+      assert.ok(!res.text.includes(String(v)), `${key} (${v}) leaked into the directory — the read spread a row it should have named`);
+    }
+  }
+  assert.ok(!res.text.includes('Shy Out') && !res.text.includes('Shy Private'),
+    'and the two hidden builders the tier refuses leave no trace either');
+});
+
+await t('un-hiding moves a builder between the tiers; opting out removes them from both', async () => {
+  const shy = ACCOUNTS.find((a) => a.github_login === 'shy');
+  try {
+    shy.hide_stats = false;
+    let res = await getScouting(OPERATOR);
+    assert.ok(logins(res).includes('shy') && !namedLogins(res).includes('shy'),
+      'shown again, the builder is ranked on their record and gone from the name-only list — never in both');
+    shy.hide_stats = true;
+    shy.recruiter_discoverable = false;
+    res = await getScouting(OPERATOR);
+    assert.ok(!logins(res).includes('shy') && !namedLogins(res).includes('shy'),
+      'hidden AND opted out: absent from the directory entirely — the opt-out is still the only thing that removes a builder');
+  } finally {
+    shy.hide_stats = true;
+    shy.recruiter_discoverable = null;
+  }
+});
+
+await t('MUTATION CHECK: drop the reach or the existence half and the wrong hidden builder walks in', async () => {
+  const admits = (clause) => ACCOUNTS.filter(accountFilter(clause, [])).map((a) => a.github_login).sort();
+  const tier = scoutingNameOnlySql();
+  assert.deepEqual(admits(tier), ['shy'], 'the real predicate');
+  const withoutReach = tier.replace(` AND ${recruiterReachSql()}`, '');
+  assert.notEqual(withoutReach, tier, 'fixture check: the reach term was really removed');
+  assert.deepEqual(admits(withoutReach), ['shy', 'shyout'],
+    'WITHOUT reach, the builder who opted out is listed — so the opt-out assertion above is load-bearing');
+  const withoutExistence = tier.replace(accountVisibleSql(), accountActiveSql());
+  assert.notEqual(withoutExistence, tier, 'fixture check: the existence axis was really removed');
+  assert.deepEqual(admits(withoutExistence), ['shy', 'shypriv'],
+    'WITHOUT the existence axis, a PRIVATE account is listed by name — the D3 sliver\'s subject, which the directory must never carry');
+});
+
 // ===========================================================================
 // 3. THE TWO AXES NEVER TOUCH (ADR 0016)
 // ===========================================================================
@@ -631,6 +739,8 @@ await t('opting out of recruiting grants and denies NO permission', async () =>
     + 'so a reader can never infer a privacy setting from whose list they got');
   assert.deepEqual(shown, logins(await getScouting(OPERATOR)),
     'byte-for-byte the same population an operator sees');
+  assert.deepEqual(namedLogins(res), namedLogins(await getScouting(OPERATOR)),
+    'and the same name-only list — neither tier varies by viewer');
 });
 
 await t('being scoutable buys nothing either — the response is the same descriptive whitelist', async () => {

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) {

package/tests/ui_design_styles.mjs

@@ -120,6 +120,19 @@ test('every mock passes the platform rules under its own colours and its own DES
   }
 });
 
+test("the expedition's halftone screen renders: it sits on a fixed body::before layer, never body's own background-image (task 1003633)", () => {
+  const html = read(path.join(STYLES_DIR, 'expedition', 'mock.html'));
+  const bodyRule = html.match(/\bbody\s*\{[^}]*\}/);
+  assert.ok(bodyRule, 'the mock declares a body rule');
+  assert.doesNotMatch(bodyRule[0], /background-image/, "body's own rule carries no background-image — the branding pack's backdrop emits body{background:...} after the page's sheet (themeMarkup, serve-internal.js) and that shorthand resets it to none");
+  const before = html.match(/body::before\s*\{[^}]*\}/);
+  assert.ok(before, 'the halftone moved onto a body::before layer');
+  assert.match(before[0], /position:\s*fixed/, 'the layer is fixed, not in flow');
+  assert.match(before[0], /pointer-events:\s*none/, 'the layer never intercepts input');
+  assert.match(before[0], /background-image:\s*radial-gradient\(var\(--dots\)/, 'the halftone dots ride the layer, keyed to the pack-derived --dots var');
+  assert.match(before[0], /background-size:\s*var\(--dot-pitch\)/, 'the dot pitch moved with it');
+});
+
 test('the world, hub and hall sheets clear AA under every alternate in both modes: the three token suites run once per pack', () => {
   // relative, forward-slash paths: `node --test <path>` reads its positionals as globs, and a
   // Windows absolute path matches nothing (zero tests, exit 0 — a silent pass)