@bongos/core 1.23.22 → 1.24.2

package/tests/rank_change_broadcast_port.mjs

@@ -0,0 +1,151 @@
+// tests/rank_change_broadcast_port.mjs
+//
+// Task 1004962 — the rank-change Discord announcement posts IN-PROCESS through
+// the discord module's `discord.post` port, never by spawning
+// `node scripts/discord/post.js` (50-100 MB + ~300 ms CPU per rank change, with
+// nothing bounding a burst). Drives the real PATCH /builders/:id/rank route with
+// auth + db stubbed, and pins the three cases the task names:
+//
+//   1. posted       — the port is called once with the #ship-news line, and no
+//                     child process is started.
+//   2. module off   — no `discord.post` provider: the rank change still 200s and
+//                     nothing is posted.
+//   3. post throws  — a provider that throws (sync) or rejects (async) never fails
+//                     the rank change.
+//
+// Run:  node tests/rank_change_broadcast_port.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import http from 'node:http';
+
+const require = createRequire(import.meta.url);
+const express = require('express');
+
+delete process.env.CHAT_DRY_RUN; // the dry-run guard would hide the port call
+
+// Record any child process the route starts. Patched BEFORE the router loads, so
+// a destructured `execFile`/`spawn` picks up the recorder.
+const cp = require('node:child_process');
+const spawned = [];
+for (const fn of ['execFile', 'spawn', 'exec', 'fork']) {
+  cp[fn] = (...args) => { spawned.push([fn, args[0], args[1]]); throw new Error(`test: ${fn} must not be called`); };
+}
+
+const authPath = require.resolve('../src/bongos/auth.js');
+require.cache[authPath] = {
+  id: authPath, filename: authPath, loaded: true,
+  exports: {
+    requireBuilder: (req, _res, next) => {
+      req.builder = { id: '1', rank: 'archon', github_login: 'archon1', display_name: 'Archon One' };
+      next();
+    },
+    requireRank: () => (_req, _res, next) => next(),
+    requirePermission: () => (_req, _res, next) => next(),
+  },
+};
+
+const fakeDb = {
+  RANKS: ['xenos', 'thetes', 'metic', 'archon'],
+  setBuilderRank: async ({ builderId, newRank }) => ({
+    builder: { id: builderId, rank: newRank, display_name: 'Ada', github_login: 'ada' },
+    previous_rank: 'thetes',
+    direction: 'promotion',
+    credit_delta: 5,
+  }),
+};
+const dbPath = require.resolve('../src/bongos/db.js');
+require.cache[dbPath] = { id: dbPath, filename: dbPath, loaded: true, exports: fakeDb };
+
+const seams = require('../src/module-seams.js');
+const buildBuildersRouter = require('../src/bongos/routes/builders.js');
+const { fireDiscordBroadcast } = buildBuildersRouter;
+const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+
+const app = express();
+app.use(express.json());
+app.use(attachFail);
+app.use('/api/gds', buildBuildersRouter());
+const server = await new Promise((resolve) => { const s = app.listen(0, '127.0.0.1', () => resolve(s)); });
+const { port } = server.address();
+
+function patchRank(id, rank) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify({ rank });
+    const req = http.request({
+      host: '127.0.0.1', port, method: 'PATCH', path: `/api/gds/builders/${id}/rank`,
+      headers: { 'content-type': 'application/json', 'content-length': Buffer.byteLength(data) },
+    }, (res) => {
+      const chunks = [];
+      res.on('data', (c) => chunks.push(c));
+      res.on('end', () => {
+        let json = null;
+        try { json = JSON.parse(Buffer.concat(chunks).toString('utf8')); } catch (_) {}
+        resolve({ status: res.statusCode, json });
+      });
+    });
+    req.on('error', reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+const settle = () => new Promise((r) => setTimeout(r, 20));
+let passed = 0;
+let failed = 0;
+async function t(name, fn) {
+  seams._reset();
+  spawned.length = 0;
+  try { await fn(); passed++; console.log(`ok   ${name}`); } catch (e) { failed++; console.log(`FAIL ${name}\n     ${e && e.stack}`); }
+}
+
+await t('posted: the route calls discord.post once with the #ship-news line, no child process', async () => {
+  const posts = [];
+  seams.registerProvider('discord.post', async (msg) => { posts.push(msg); return { posted: true, channel: msg.channel }; });
+  const r = await patchRank(7, 'metic');
+  assert.equal(r.status, 200);
+  await settle();
+  assert.equal(posts.length, 1);
+  assert.equal(posts[0].channel, 'ship_news');
+  assert.equal(posts[0].text, r.json.broadcast);
+  assert.match(posts[0].text, /Ada has been raised to the rank of Metic/);
+  assert.deepEqual(spawned, []);
+});
+
+await t('module off: no discord.post provider — the rank change succeeds and nothing is posted', async () => {
+  const r = await patchRank(7, 'metic');
+  assert.equal(r.status, 200);
+  assert.equal(r.json.builder.rank, 'metic');
+  await settle();
+  assert.deepEqual(spawned, []);
+  assert.deepEqual(await fireDiscordBroadcast('hello'), { posted: false, reason: 'no_discord' });
+});
+
+await t('post throws synchronously: the rank change still succeeds', async () => {
+  let calls = 0;
+  seams.registerProvider('discord.post', () => { calls++; throw new Error('webhook exploded'); });
+  const r = await patchRank(7, 'metic');
+  assert.equal(r.status, 200);
+  assert.equal(r.json.builder.rank, 'metic');
+  await settle();
+  assert.equal(calls, 1);
+  assert.deepEqual(await fireDiscordBroadcast('hello'), { posted: false, reason: 'post_failed' });
+});
+
+await t('post rejects: the rank change still succeeds and no rejection escapes', async () => {
+  const unhandled = [];
+  const onUnhandled = (e) => unhandled.push(e);
+  process.on('unhandledRejection', onUnhandled);
+  let calls = 0;
+  seams.registerProvider('discord.post', async () => { calls++; throw new Error('discord 500'); });
+  const r = await patchRank(7, 'metic');
+  assert.equal(r.status, 200);
+  await settle();
+  process.off('unhandledRejection', onUnhandled);
+  assert.equal(calls, 1);
+  assert.deepEqual(unhandled, []);
+});
+
+server.close();
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);

package/tests/seed_tasks.mjs

@@ -0,0 +1,176 @@
+// tests/seed_tasks.mjs — scripts/bongos/seed-tasks.js, the one data-driven task seeder (task 1004979).
+//
+// The load-bearing case is EQUIVALENCE: the three per-version seed scripts it replaced
+// (seed-bongos-v1-idea-routing-tasks.js, seed-bv1-profiles-tasks.js,
+// seed-bv2-ideator-surface-tasks.js) each became a spec under tests/fixtures/seed-tasks/, and
+// seed-tasks.js must send exactly the writes the old script sent — every POST /tasks body,
+// dependency edge, promotion and follow-up PATCH, in order. The proof ran LIVE first: the first
+// version of this test (task 1004979's first commit) ran each old script and seed-tasks.js
+// against the same fake API and compared both the writes and the resulting task rows.
+// The old scripts are gone now, so OLD_WRITE_HASHES pins what that run recorded: the sha256 of
+// the canonical write log each old script produced. Any change to what seed-tasks.js sends for
+// these specs moves the hash.
+//
+// Run: node tests/seed_tasks.mjs
+
+import { strict as assert } from 'node:assert';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { startFakeApi, fetchApi, canonical } from './fixtures/seed-tasks/fake-api.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const SEEDER = path.join(ROOT, 'scripts/bongos/seed-tasks.js');
+const EXAMPLE = path.join(ROOT, 'scripts/bongos/seed-tasks.example.json');
+const FIX = path.join(ROOT, 'tests/fixtures/seed-tasks');
+const { validateSpec, seedTasks } = require(SEEDER);
+
+// spec fixture -> the old script it replaced, and the sha256 of that script's write log.
+const HISTORICAL = [
+  { spec: 'bongos-v1-idea-routing.json', old: 'seed-bongos-v1-idea-routing-tasks.js', hash: 'f5bc176890077a62754812cf69666bd49ba0da441dafa84702e1883156c302f8' },
+  { spec: 'bv1-profiles.json', old: 'seed-bv1-profiles-tasks.js', hash: 'cf81ee14131a20fe5a07c05b7c5fe3362bc940d5c5592031ad911b709db129a7' },
+  { spec: 'bv2-ideator-surface.json', old: 'seed-bv2-ideator-surface-tasks.js', hash: '5f8ed981593dfa4738b6dd97208ef0b0aec01a4d7e3eca8abc76caa5d8901f5c' },
+];
+
+let passed = 0, failed = 0;
+async function test(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.stack || err.message}`); }
+}
+const readSpec = (f) => JSON.parse(fs.readFileSync(path.join(FIX, f), 'utf8'));
+const sha = (writes) => crypto.createHash('sha256').update(canonical(writes)).digest('hex');
+const quiet = () => {};
+const noExit = (code) => { throw new Error(`seeder exited ${code}`); };
+
+function run(cmd, args, env) {
+  return new Promise((resolve) => {
+    const p = spawn(cmd, args, { cwd: ROOT, env: { ...process.env, ...env } });
+    let out = '';
+    p.stdout.on('data', (d) => { out += d; });
+    p.stderr.on('data', (d) => { out += d; });
+    p.on('close', (code) => resolve({ code, out }));
+  });
+}
+
+async function runNew(spec) {
+  const api = await startFakeApi();
+  try {
+    await seedTasks(spec, { api: fetchApi(api.base), log: quiet, exit: noExit });
+    return { writes: api.writes(), tasks: api.tasks };
+  } finally { await api.close(); }
+}
+
+// ---- equivalence with the three scripts it replaced -------------------------------------
+
+for (const h of HISTORICAL) {
+  await test(`${h.spec} sends exactly the writes ${h.old} sent`, async () => {
+    const spec = readSpec(h.spec);
+    assert.deepEqual(validateSpec(spec), [], 'the historical spec is valid');
+    const next = await runNew(spec);
+    assert.equal(next.tasks.length, spec.tasks.length, 'every task was filed');
+    assert.equal(sha(next.writes), h.hash, 'same writes, same order, as the old script sent');
+  });
+}
+
+// ---- the example spec and the dry run ----------------------------------------------------
+
+await test('the example spec is valid', async () => {
+  assert.deepEqual(validateSpec(JSON.parse(fs.readFileSync(EXAMPLE, 'utf8'))), []);
+});
+
+await test('--dry-run prints the plan and files nothing', async () => {
+  const api = await startFakeApi();
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'seed-dry-'));
+  try {
+    const r = await run(process.execPath, [SEEDER, EXAMPLE, '--dry-run'], { GDS_API_BASE: api.base, BONGOS_API_BASE: api.base, HOME: home, USERPROFILE: home });
+    assert.equal(r.code, 0, r.out);
+    const spec = JSON.parse(fs.readFileSync(EXAMPLE, 'utf8'));
+    for (const t of spec.tasks) assert.ok(r.out.includes(`${t.ref}  `) && r.out.includes(t.title), `plan lists ${t.ref}`);
+    assert.match(r.out, /Nothing was filed\./);
+    assert.equal(api.requests.length, 0, 'not one request reached the API');
+  } finally { await api.close(); fs.rmSync(home, { recursive: true, force: true }); }
+});
+
+await test('an invalid spec is refused before any write', async () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'seed-bad-'));
+  const file = path.join(dir, 'bad.json');
+  fs.writeFileSync(file, JSON.stringify({ version_id: 'V', goal_id: 1, source_ref_prefix: 'p', tasks: [] }));
+  const r = await run(process.execPath, [SEEDER, file, '--dry-run'], {});
+  fs.rmSync(dir, { recursive: true, force: true });
+  assert.equal(r.code, 1);
+  assert.match(r.out, /tasks must be a non-empty array/);
+});
+
+// ---- validation ---------------------------------------------------------------------------
+
+const base = () => ({
+  version_id: 'V', goal_id: 7, source_ref_prefix: 'p',
+  tasks: [
+    { ref: 'R1', title: 't1', description: 'd', kind: 'feature', discipline: 'engineer', priority: 3, criterion_ids: ['slug-a'] },
+    { ref: 'R2', title: 't2', description: 'd', kind: 'verify', discipline: 'engineer', priority: 3, criterion_ids: ['slug-a'], deps: ['R1'] },
+  ],
+});
+
+await test('validation names each broken thing', async () => {
+  const s = base();
+  s.tasks[1].ref = 'R1';
+  assert.ok(validateSpec(s).some((e) => /duplicate ref/.test(e)));
+  const u = base(); u.tasks[1].deps = ['R9'];
+  assert.ok(validateSpec(u).some((e) => /unknown ref R9/.test(e)));
+  const self = base(); self.tasks[1].deps = ['R2'];
+  assert.ok(validateSpec(self).some((e) => /depends on itself/.test(e)));
+  const p = base(); p.promote = ['R7'];
+  assert.ok(validateSpec(p).some((e) => /promote: unknown ref R7/.test(e)));
+});
+
+await test('a positional "Cn" criterion ref is refused unless the spec opts in (learning 1000188)', async () => {
+  const s = base(); s.tasks[0].criterion_ids = ['C1'];
+  assert.ok(validateSpec(s).some((e) => /positional criterion ref/.test(e)));
+  s.allow_positional_criteria = true;
+  assert.deepEqual(validateSpec(s), []);
+});
+
+// ---- the seeding contract: baseline, replay, verify ---------------------------------------
+
+await test('a re-run replays every task and still verifies (only created links are tallied)', async () => {
+  const api = await startFakeApi({ goalCriteria: { 7: { 'slug-a': 4 } } });
+  try {
+    const first = await seedTasks(base(), { api: fetchApi(api.base), log: quiet, exit: noExit });
+    assert.equal(first.created, 2);
+    const again = await seedTasks(base(), { api: fetchApi(api.base), log: quiet, exit: noExit });
+    assert.equal(again.replayed, 2);
+    assert.equal(api.tasks.length, 2, 'the replay filed nothing new');
+  } finally { await api.close(); }
+});
+
+await test('a criterion link that did not land exits 1', async () => {
+  const api = await startFakeApi();
+  const lying = fetchApi(api.base);
+  // A server that files the task but drops its criterion link: the GET shows zero.
+  const transport = async (m, p, b) => (m === 'GET' ? { status: 200, ok: true, json: { criteria: [] } } : lying(m, p, b));
+  let code = null; const lines = [];
+  try {
+    await seedTasks(base(), { api: transport, log: (l) => lines.push(l), exit: (c) => { code = c; } });
+  } finally { await api.close(); }
+  assert.equal(code, 1);
+  assert.ok(lines.some((l) => /VERIFY FAILED/.test(l)));
+});
+
+await test('a follow-up link waits for the task it names', async () => {
+  const s = base();
+  s.links = [{ method: 'PATCH', path: '/inbox/55', body: { status: 'promoted', promoted_to_task_id: { $task: 'R2' } } }];
+  const api = await startFakeApi();
+  try {
+    await seedTasks(s, { api: fetchApi(api.base), log: quiet, exit: noExit });
+    const patch = api.writes().find((w) => w.method === 'PATCH');
+    assert.deepEqual(patch.body, { status: 'promoted', promoted_to_task_id: Number(api.tasks[1].id) });
+  } finally { await api.close(); }
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+if (failed) process.exitCode = 1;

package/tests/seed_verify_criteria.mjs

@@ -15,7 +15,6 @@
 
 import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
-import { readFileSync } from 'node:fs';
 
 const require = createRequire(import.meta.url);
 const {
@@ -225,11 +224,8 @@ test('a fully re-run seed (every create a replay) plans nothing and verifies OK'
   assert.deepEqual(diffCriterionLinks(tallyCreated(responses), [{ criterion_id: 'ours', linked_tasks: 2 }], { baseline: { ours: 2 } }), []);
 });
 
-test('the baselined reference seed skips replays when it tallies', () => {
-  const src = readFileSync(new URL('../scripts/bongos/seed-bv2-ideator-surface-tasks.js', import.meta.url), 'utf8');
-  assert.match(src, /baselineSeedCriteria\(/, 'it takes a baseline');
-  assert.match(src, /if \(!r\.json\.idempotent\) criterionIdListsPerTask\.push\(t\.crit\);/, 'and tallies only created tasks');
-});
+// That the real seeder baselines and skips replays when it tallies is proven by behaviour, not
+// by its source text: tests/seed_tasks.mjs re-runs a spec against a fake API (task 1004979).
 
 await testAsync('baselineSeedCriteria snapshots the goal before any write', async () => {
   const logs = [];

package/tests/site_classified_once.mjs

@@ -0,0 +1,142 @@
+// tests/site_classified_once.mjs — a request's site is worked out ONCE (task 1004963).
+//
+// THE COST THIS PINS. About fifteen global handlers in src/bongos/serve-internal.js
+// each asked "is this the builders host?" / "is this a module-surface host?", and
+// every answer re-parsed the Host header (the builders question also re-parsed the
+// configured buildersOrigin URL). mountInternalSurfaces now classifies the request
+// at the top of its chain into req.bongosSite and every predicate reads that field.
+//
+// HOW IT IS OBSERVED. A front middleware, mounted BEFORE mountInternalSurfaces,
+// replaces the Host header value with a String object whose toLowerCase() counts
+// its calls — every parse of the Host starts with that call. With the fix, the
+// whole chain parses it exactly once (the classifier) whatever handler answers;
+// without it, a hall request parses it once per host-routed handler it passes.
+// (Counting plain property READS would be the wrong measure: siteOf re-reads the
+// raw header on purpose, to check the cached answer is for the same Host.)
+//
+// WHAT ELSE IT PINS. The routing answer per host is unchanged — the hall, the
+// canonical /builders redirects, the apex /docs, the API on both hosts — and the
+// cache can never answer for a Host it was not computed from.
+//
+// node:http, not fetch: fetch silently drops a Host override (see
+// tests/module_asset_subdomain.mjs for the trap).
+//
+// Run:  node --test tests/site_classified_once.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import http from 'node:http';
+
+const require = createRequire(import.meta.url);
+
+const APEX = 'example.com';
+const HALL = 'builders.example.com';
+
+// The count of Host parses for the request currently in flight. One request at a
+// time (the helpers below await each), so a single counter is unambiguous.
+let hostReads = 0;
+
+// The same text as the real Host, but every toLowerCase() is counted. One instance
+// per request, so siteOf's identity check against the cached raw value still holds.
+class CountedHost extends String {
+  toLowerCase() { hostReads += 1; return String(this).toLowerCase(); }
+}
+
+async function withServer(fn) {
+  const express = require('express');
+  const { mountInternalSurfaces } = require('../src/bongos/serve-internal.js');
+  const app = express();
+  app.use((req, _res, next) => {
+    hostReads = 0;
+    req.headers.host = new CountedHost(req.headers.host);
+    next();
+  });
+  mountInternalSurfaces(app);
+  const server = await new Promise((resolve) => { const s = app.listen(0, () => resolve(s)); });
+  try { await fn(server.address().port); } finally { await new Promise((r) => server.close(r)); }
+}
+
+function get(port, path, host) {
+  return new Promise((resolve, reject) => {
+    const req = http.request({ host: '127.0.0.1', port, path, headers: { Host: host } }, (res) => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (c) => { body += c; });
+      res.on('end', () => resolve({ status: res.statusCode, location: res.headers.location || null, body, reads: hostReads }));
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+// Requests that walk deep into the host-routed chain on each kind of host. The
+// hall index on the builders host passes EVERY host-routed handler down to the
+// final hall static; an unknown apex path falls through the whole chain to Express'
+// default 404. Before the fix these read the Host header a dozen-plus times.
+const WALKS = [
+  ['hall index on the builders host', '/', HALL],
+  ['hall asset on the builders host', '/builders/style.css', HALL],
+  ['unknown path on the builders host', '/no-such-page-xyz', HALL],
+  ['unknown path on the apex', '/no-such-page-xyz', APEX],
+  ['apex /docs', '/docs', APEX],
+  ['apex /builders redirect', '/builders/watch', APEX],
+  ['API healthz on the builders host', '/api/bongos/healthz', HALL],
+];
+
+test('the Host header is parsed once per request, whichever handler answers', async () => {
+  await withServer(async (port) => {
+    for (const [label, path, host] of WALKS) {
+      const r = await get(port, path, host);
+      assert.equal(r.reads, 1, `${label}: Host read ${r.reads} times — the site must be classified once and read from req.bongosSite`);
+    }
+  });
+});
+
+test('routing per host is unchanged', async () => {
+  await withServer(async (port) => {
+    // Apex /builders/* → the builders subdomain (301, path + query carried).
+    let r = await get(port, '/builders/watch?x=1', APEX);
+    assert.equal(r.status, 301);
+    assert.equal(r.location, `https://${HALL}/watch?x=1`);
+    // On the builders host the /builders prefix is redundant → clean path.
+    r = await get(port, '/builders/watch', HALL);
+    assert.equal(r.status, 301);
+    assert.equal(r.location, '/watch');
+    // The builders host serves the hall at its root.
+    r = await get(port, '/', HALL);
+    assert.equal(r.status, 200);
+    assert.match(r.body, /<html/i);
+    // Retired directory → /roster, prefix kept on the apex and dropped on the hall.
+    r = await get(port, '/builders/people', HALL);
+    assert.equal(r.status, 301, 'the canonical redirect answers first on the hall host');
+    assert.equal(r.location, '/people');
+    // /docs: the apex serves the API reference.
+    r = await get(port, '/docs', APEX);
+    assert.equal(r.status, 200);
+    // The API is host-agnostic.
+    for (const host of [APEX, HALL]) {
+      r = await get(port, '/api/bongos/healthz', host);
+      assert.equal(r.status, 200, `API healthz on ${host}`);
+    }
+  });
+});
+
+test('siteOf caches on the request and never answers for a different Host', () => {
+  const { siteOf, isBuildersHost, isStatusHost } = require('../src/bongos/serve-internal.js');
+  const req = { headers: { host: 'Builders.Example.com:8443' } };
+  const first = siteOf(req);
+  assert.equal(first.host, 'builders.example.com');
+  assert.equal(first.builders, true);
+  assert.equal(req.bongosSite, first, 'the classification lives on the request');
+  assert.equal(siteOf(req), first, 'a second read reuses it');
+  // A changed Host is re-classified, not served from the stale entry.
+  req.headers.host = 'status.example.com';
+  assert.equal(isBuildersHost(req), false);
+  assert.equal(isStatusHost(req), true);
+  assert.notEqual(req.bongosSite, first);
+  // A missing Host is the apex, as before.
+  const bare = { headers: {} };
+  assert.equal(isBuildersHost(bare), false);
+  assert.equal(isStatusHost(bare), false);
+});

package/tests/speciality_db_shape.mjs

@@ -112,6 +112,29 @@ test('countTraining counts both halves of training in one round trip', async ()
   assert.equal(q.calls.length, 1);
 });
 
+// task 1004923: GET /me's specialities read is ONE query for all of them.
+test('describeTrainingFor reads owner + both counts for every id in one round trip', async () => {
+  const q = fake([{ rows: [
+    { id: '7', owner_kind: 'builder', owner_builder_id: '1', documents: '3', learnings: '2' },
+    { id: '8', owner_kind: 'project', owner_builder_id: null, documents: '0', learnings: '5' },
+  ], rowCount: 2 }]);
+  const out = await db.describeTrainingFor(['7', 8, '7'], q);
+  assert.equal(q.calls.length, 1, 'one query, however many specialities');
+  assert.match(q.calls[0].sql, /c\.id = ANY\(\$1::bigint\[\]\)/);
+  assert.match(q.calls[0].sql, /specialities_documents d WHERE d\.speciality_id = c\.id/);
+  assert.match(q.calls[0].sql, /specialities_learnings l WHERE l\.speciality_id = c\.id/);
+  assert.deepEqual(q.calls[0].params, [['7', '8']], 'ids are de-duplicated before they are sent');
+  assert.deepEqual(out.get('7'), { owner_kind: 'builder', owner_builder_id: '1', documentCount: 3, learningCount: 2 });
+  assert.deepEqual(out.get('8'), { owner_kind: 'project', owner_builder_id: null, documentCount: 0, learningCount: 5 });
+});
+
+test('describeTrainingFor with no ids asks the database nothing', async () => {
+  const q = fake();
+  const out = await db.describeTrainingFor([], q);
+  assert.equal(out.size, 0);
+  assert.equal(q.calls.length, 0);
+});
+
 test('taskDiscipline reads the CORE tasks table by id', async () => {
   const q = fake([{ rows: [{ discipline: 'engineer' }], rowCount: 1 }]);
   assert.equal(await db.taskDiscipline('1234', q), 'engineer');

package/tests/speciality_session_skills.mjs

@@ -78,8 +78,11 @@ await test('a malformed name in the stored set is never relayed', () => {
 // ---- the whole path: row → real port → real Conductor -----------------------
 const store = { adoptions: [] };
 db.listAdoptions = async () => store.adoptions.map((a) => ({ ...a }));
-db.countTraining = async () => ({ documentCount: 0, learningCount: 0 });
-db.getSpeciality = async (id) => ({ id, owner_kind: 'builder', owner_builder_id: 1 });
+// The port's ONE batched read (task 1004923); the per-row pair it replaced must
+// never be reached again, so those throw rather than answer.
+db.describeTrainingFor = async (ids) => new Map(ids.map((id) => [String(id), { owner_kind: 'builder', owner_builder_id: 1, documentCount: 0, learningCount: 0 }]));
+db.countTraining = async () => { throw new Error('per-row countTraining on the GET /me path'); };
+db.getSpeciality = async () => { throw new Error('per-row getSpeciality on the GET /me path'); };
 skills.installedSkillsCached = () => new Map([['recall', {}], ['status', {}]]);
 require('../modules/specialities/routes/specialities.js')();
 const port = api.resolveOptional('specialities');
@@ -147,4 +150,47 @@ await test('no permission or materialisation surface reads enabled_skills', () =
   }
 });
 
+// ---- task 1004923: the GET /me read is batched, not one pair per adoption ----
+await test('three active adoptions cost ONE training read, and each keeps its own owner and counts', async () => {
+  const saved = db.describeTrainingFor;
+  const calls = [];
+  db.describeTrainingFor = async (ids) => {
+    calls.push(ids.map(String));
+    return new Map([
+      ['9', { owner_kind: 'builder', owner_builder_id: 1, documentCount: 4, learningCount: 0 }],
+      ['10', { owner_kind: 'builder', owner_builder_id: 77, documentCount: 0, learningCount: 2 }],
+      // 11 has no catalogue row: counted as nothing, and not treated as self-authored.
+    ]);
+  };
+  try {
+    store.adoptions = [
+      row({ id: 9, name: 'Economics', contract_md: 'Mine.' }),
+      row({ id: 10, name: 'Law', discipline: 'engineer', contract_md: 'Theirs.' }),
+      row({ id: 11, name: 'Music', discipline: 'artist', contract_md: 'Gone.' }),
+      row({ id: 12, name: 'Old', discipline: 'ui', active: false }),
+    ];
+    const out = await port.describeActiveFor(1);
+    assert.equal(calls.length, 1, 'one batched read, not one per adoption');
+    assert.deepEqual(calls[0], ['9', '10', '11'], 'only ACTIVE adoptions are asked about');
+    const by = Object.fromEntries(out.map((d) => [d.name, d]));
+    assert.deepEqual(Object.keys(by).sort(), ['Economics', 'Law', 'Music']);
+    assert.match(by.Economics.contract, /4 document\(s\)/);
+    assert.doesNotMatch(by.Economics.contract, /stated working preferences/, 'your own speciality stays unfenced');
+    assert.match(by.Law.contract, /2 learning\(s\)/);
+    assert.match(by.Law.contract, /stated working preferences/, 'another builder\'s speciality carries its provenance');
+    assert.match(by.Music.contract, /stated working preferences/, 'a row the read did not return is never self-authored');
+  } finally { db.describeTrainingFor = saved; }
+});
+
+await test('no active adoption asks the database nothing more', async () => {
+  const saved = db.describeTrainingFor;
+  let called = 0;
+  db.describeTrainingFor = async () => { called++; return new Map(); };
+  try {
+    store.adoptions = [row({ active: false })];
+    assert.deepEqual(await port.describeActiveFor(1), []);
+    assert.equal(called, 0);
+  } finally { db.describeTrainingFor = saved; }
+});
+
 summary();