@bongos/core 1.19.811 → 1.19.812

package/tests/speciality_injection.mjs

@@ -0,0 +1,107 @@
+// tests/speciality_injection.mjs — the path a speciality contract takes to reach
+// a session (task 1003855).
+//
+// WHY THIS IS ITS OWN FILE. specialities.mjs covers the RULES; this covers the
+// PLUMBING, and the plumbing is where a silent failure lives: if the contract
+// never arrives, nothing errors — the session simply behaves as though the
+// builder had no speciality, which is indistinguishable from not having one.
+//
+// The Conductor is driven directly with fixtures rather than through a live /me,
+// so the craft-matching rule is asserted without a database or a server.
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const conductor = require(path.join(ROOT, '.claude', 'hooks', 'conductor.js'));
+
+const sp = (over = {}) => ({
+  inject: true,
+  contract: 'Speciality: Economics (under ideator).',
+  discipline: 'ideator',
+  name: 'Economics',
+  ...over,
+});
+const claim = (discipline) => ({ task_id: '1', title: 't', discipline });
+const ids = (out) => out.map((a) => a.id);
+
+test('the contract is injected when its craft matches the claim in hand', () => {
+  const out = conductor.evaluateTriggers({ activeClaims: [claim('ideator')], specialities: [sp()] });
+  assert.ok(ids(out).includes('speciality:ideator'), `expected the ideator contract, got ${JSON.stringify(ids(out))}`);
+  const entry = out.find((a) => a.id === 'speciality:ideator');
+  assert.match(entry.text, /Economics/);
+});
+
+test('a speciality for a DIFFERENT craft is not injected', () => {
+  // An artist's expert contract in an engineering session is noise at best and
+  // actively misleading at worst. This is the assertion that keeps the selection
+  // honest — without it, "inject everything active" would pass the test above.
+  const out = conductor.evaluateTriggers({
+    activeClaims: [claim('engineer')],
+    specialities: [sp({ discipline: 'artist', contract: 'Speciality: Pixel art (under artist).' })],
+  });
+  assert.equal(ids(out).filter((i) => String(i).startsWith('speciality:')).length, 0);
+});
+
+test('with no active claim there is no craft, so nothing is injected', () => {
+  // Silence beats guessing which expertise applies.
+  const out = conductor.evaluateTriggers({ activeClaims: [], specialities: [sp()] });
+  assert.equal(ids(out).filter((i) => String(i).startsWith('speciality:')).length, 0);
+});
+
+test('inject:false is honoured — an empty speciality spends no context', () => {
+  const out = conductor.evaluateTriggers({
+    activeClaims: [claim('ideator')],
+    specialities: [sp({ inject: false })],
+  });
+  assert.equal(ids(out).filter((i) => String(i).startsWith('speciality:')).length, 0);
+});
+
+test('one contract per craft, and two crafts in play get one each', () => {
+  const out = conductor.evaluateTriggers({
+    activeClaims: [claim('ideator'), claim('engineer')],
+    specialities: [sp(), sp({ discipline: 'engineer', contract: 'Speciality: Compilers (under engineer).' })],
+  });
+  const got = ids(out).filter((i) => String(i).startsWith('speciality:'));
+  assert.deepEqual(got.sort(), ['speciality:engineer', 'speciality:ideator']);
+});
+
+test('malformed entries are skipped rather than thrown on', () => {
+  const out = conductor.evaluateTriggers({
+    activeClaims: [claim('ideator')],
+    specialities: [null, { inject: true }, sp({ contract: '' }), sp()],
+  });
+  assert.equal(ids(out).filter((i) => String(i).startsWith('speciality:')).length, 1);
+});
+
+test('no specialities at all changes nothing about the hook', () => {
+  const before = conductor.evaluateTriggers({ activeClaims: [claim('ideator')] });
+  const after = conductor.evaluateTriggers({ activeClaims: [claim('ideator')], specialities: [] });
+  assert.deepEqual(ids(before), ids(after));
+});
+
+// ---------- the wiring the contract depends on, asserted against the source ----------
+// These are the three edits that make the path exist at all. Each one is invisible
+// when it breaks, so each is pinned rather than trusted.
+const src = (rel) => fs.readFileSync(path.join(ROOT, rel), 'utf8');
+
+test('the active-claims read carries the task craft — the Conductor cannot match without it', () => {
+  assert.match(src('modules/lifecycle/db-claim-reads.js'), /t\.discipline/);
+});
+
+test('GET /me resolves the port rather than requiring the module', () => {
+  const me = src('src/bongos/routes/me.js');
+  assert.match(me, /resolveOptional\('specialities'\)/);
+  assert.match(me, /describeActiveFor/);
+  assert.doesNotMatch(me, /require\([^)]*modules\/specialities/, 'the core must keep working with the module off');
+});
+
+test('the adoption read selects the contract itself', () => {
+  // It once did not, and the injected fragment silently lost the expert's terms
+  // while still looking well-formed.
+  assert.match(src('modules/specialities/db.js'), /SELECT s\.id, s\.slug, s\.name, s\.discipline, s\.summary, s\.contract_md/);
+});