@bongos/core 1.17.0

package/tests/conductor.mjs

@@ -0,0 +1,496 @@
+// tests/conductor.mjs
+//
+// Unit tests for the MAS Phase 3 Conductor (#427). Covers the pure trigger
+// core — evaluateTriggers + isCovered + matchSensitive + fingerprint — which
+// is the whole decision surface. The git / fetch / stdin plumbing around it
+// is thin and degradable-by-design (silent exit 0); it's exercised by the
+// live smoke at ship time, not here.
+//
+// Run:  node tests/conductor.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const conductor = require('../.claude/hooks/conductor.js');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try {
+    fn();
+    passed++;
+    console.log(`  ok  ${name}`);
+  } catch (err) {
+    failed++;
+    console.log(`  FAIL ${name}`);
+    console.log(`     ${err.message}`);
+  }
+}
+
+const ids = (advisories) => advisories.map((a) => a.id).sort();
+
+// ---------- isCovered ----------
+
+test('isCovered: exact path match', () => {
+  assert.equal(conductor.isCovered('src/bongos/grader.js', ['src/bongos/grader.js']), true);
+});
+
+test('isCovered: directory prefix (trailing slash)', () => {
+  assert.equal(conductor.isCovered('migrations/053_x.sql', ['migrations/']), true);
+});
+
+test('isCovered: directory prefix (no trailing slash)', () => {
+  assert.equal(conductor.isCovered('src/bongos/routes/tasks.js', ['src/bongos/routes']), true);
+});
+
+test('isCovered: not covered', () => {
+  assert.equal(conductor.isCovered('server.js', ['src/bongos/grader.js', 'migrations/']), false);
+});
+
+test('isCovered: empty / absent touches → nothing covered', () => {
+  assert.equal(conductor.isCovered('any.js', []), false);
+  assert.equal(conductor.isCovered('any.js', null), false);
+});
+
+// ---------- matchSensitive ----------
+
+test('matchSensitive: detects migrations, routes, auth', () => {
+  const hits = conductor.matchSensitive([
+    'migrations/053_x.sql', 'src/bongos/routes/tasks.js', 'src/bongos/auth.js', 'public/game/main.js',
+  ]);
+  assert.deepEqual(hits.sort(), ['auth', 'migrations/', 'src/bongos/routes/']);
+});
+
+test('matchSensitive: nothing sensitive → empty', () => {
+  assert.deepEqual(conductor.matchSensitive(['public/game/main.js', 'art/foo.png']), []);
+});
+
+// ---------- evaluateTriggers: claim-aware ----------
+
+test('no-claim-but-changes fires only when claims definitively empty', () => {
+  const a = conductor.evaluateTriggers({
+    changedFiles: ['src/bongos/db.js'],
+    prompt: 'keep going',
+    activeClaims: [],
+  });
+  assert.ok(ids(a).includes('no-claim'));
+});
+
+test('no-claim does NOT fire when claim state is unknown (null = offline)', () => {
+  const a = conductor.evaluateTriggers({
+    changedFiles: ['src/bongos/db.js'],
+    prompt: 'keep going',
+    activeClaims: null,
+  });
+  assert.ok(!ids(a).includes('no-claim'));
+});
+
+test('no-claim does NOT fire with no changes (clean tree)', () => {
+  const a = conductor.evaluateTriggers({
+    changedFiles: [],
+    prompt: 'what should I do next',
+    activeClaims: [],
+  });
+  assert.ok(!ids(a).includes('no-claim'));
+});
+
+// ---------- evaluateTriggers: wandering knob (task 1268) ----------
+
+test('wandering: a constraining level (inject:true) emits the focus contract', () => {
+  const a = conductor.evaluateTriggers({
+    wandering: { inject: true, contract: 'Focus mode (wandering: Locked).', effective_level: 0 },
+  });
+  const w = a.find((x) => x.id === 'wandering');
+  assert.ok(w, 'expected a wandering advisory');
+  assert.match(w.text, /Focus mode/);
+});
+
+test('wandering: a permissive level (inject:false) emits nothing', () => {
+  const a = conductor.evaluateTriggers({
+    wandering: { inject: false, contract: 'Wandering: Exploratory.', effective_level: 3 },
+  });
+  assert.ok(!ids(a).includes('wandering'));
+});
+
+test('wandering: null / missing knob emits nothing and never breaks other triggers', () => {
+  assert.ok(!ids(conductor.evaluateTriggers({})).includes('wandering'));
+  const a = conductor.evaluateTriggers({ wandering: null, activeClaims: [], changedFiles: ['x.js'] });
+  assert.ok(!ids(a).includes('wandering'));
+  assert.ok(ids(a).includes('no-claim'), 'existing triggers still fire alongside a null knob');
+});
+
+test('wandering: lowest priority — emitted after methodology/status advisories', () => {
+  const a = conductor.evaluateTriggers({
+    prompt: '/builder-ship',
+    wandering: { inject: true, contract: 'Focus mode.', effective_level: 1 },
+  });
+  assert.equal(a[a.length - 1].id, 'wandering', 'wandering is emitted last');
+});
+
+test('outside-touches fires for files outside the claim touches[]', () => {
+  const a = conductor.evaluateTriggers({
+    changedFiles: ['src/bongos/grader.js', 'server.js'],
+    prompt: 'edits',
+    activeClaims: [{ task_id: 1, title: 't', touches: ['src/bongos/grader.js'] }],
+  });
+  const outside = a.find((x) => x.id === 'outside-touches');
+  assert.ok(outside, 'expected outside-touches advisory');
+  assert.match(outside.text, /server\.js/);
+});
+
+test('outside-touches does NOT fire when all changes are covered', () => {
+  const a = conductor.evaluateTriggers({
+    changedFiles: ['src/bongos/grader.js', 'migrations/053_x.sql'],
+    prompt: 'edits',
+    activeClaims: [{ task_id: 1, title: 't', touches: ['src/bongos/grader.js', 'migrations/'] }],
+  });
+  assert.ok(!ids(a).includes('outside-touches'));
+});
+
+test('outside-touches does NOT fire when the claim has empty touches[] (fresh task, no noise)', () => {
+  const a = conductor.evaluateTriggers({
+    changedFiles: ['src/bongos/grader.js'],
+    prompt: 'edits',
+    activeClaims: [{ task_id: 1, title: 't', touches: [] }],
+  });
+  assert.ok(!ids(a).includes('outside-touches'));
+});
+
+// ---------- evaluateTriggers: local ----------
+
+test('sensitive-surface fires on routes/migrations/auth + carries dispatch metadata (Phase 4)', () => {
+  const a = conductor.evaluateTriggers({
+    changedFiles: ['src/bongos/routes/tasks.js'],
+    prompt: 'x',
+    activeClaims: [{ task_id: 1, title: 't', touches: ['src/bongos/routes/tasks.js'] }],
+  });
+  const s = a.find((x) => x.id === 'sensitive-surface');
+  assert.ok(s);
+  // Phase 4: the advisory now carries actionable dispatch metadata.
+  assert.ok(s.dispatch, 'expected dispatch metadata');
+  assert.equal(s.dispatch.specialist, 'hacker');
+  assert.deepEqual(s.dispatch.files, ['src/bongos/routes/tasks.js']);
+  assert.match(s.dispatch.command, /conductor-dispatch\.js hacker/);
+});
+
+test('index-doc-edit fires on CLAUDE.md / architecture.md', () => {
+  const a = conductor.evaluateTriggers({
+    changedFiles: ['CLAUDE.md'],
+    prompt: 'x',
+    activeClaims: [{ task_id: 1, title: 't', touches: ['CLAUDE.md'] }],
+  });
+  assert.ok(ids(a).includes('index-doc-edit'));
+});
+
+test('ship-intent fires on /builder-ship and "ship it"', () => {
+  for (const p of ['/builder-ship 427', 'ok ship it', "I'm done here", 'mark this complete']) {
+    const a = conductor.evaluateTriggers({ changedFiles: [], prompt: p, activeClaims: null });
+    assert.ok(ids(a).includes('ship-intent'), `expected ship-intent for prompt: ${p}`);
+  }
+});
+
+test('ship-intent does NOT fire on unrelated prompt', () => {
+  const a = conductor.evaluateTriggers({ changedFiles: [], prompt: 'how does the grader work?', activeClaims: null });
+  assert.ok(!ids(a).includes('ship-intent'));
+});
+
+// ---------- priority + composition ----------
+
+test('clean state with active claim + no intent → no advisories (silent)', () => {
+  const a = conductor.evaluateTriggers({
+    changedFiles: [],
+    prompt: 'explain the architecture',
+    activeClaims: [{ task_id: 1, title: 't', touches: ['x'] }],
+  });
+  assert.equal(a.length, 0);
+});
+
+test('methodology (no-claim) is first in priority order', () => {
+  const a = conductor.evaluateTriggers({
+    changedFiles: ['src/bongos/routes/tasks.js', 'CLAUDE.md'],
+    prompt: 'ship it',
+    activeClaims: [],
+  });
+  assert.equal(a[0].id, 'no-claim');
+  // and the others still surface
+  const idSet = ids(a);
+  assert.ok(idSet.includes('sensitive-surface'));
+  assert.ok(idSet.includes('index-doc-edit'));
+  assert.ok(idSet.includes('ship-intent'));
+});
+
+// ---------- fingerprint (dedupe key) ----------
+
+test('fingerprint is order-independent + stable', () => {
+  const a = conductor.evaluateTriggers({
+    changedFiles: ['src/bongos/routes/x.js', 'CLAUDE.md'],
+    prompt: 'x',
+    activeClaims: null,
+  });
+  // reversed input order → same fingerprint
+  const fp1 = conductor.fingerprint(a);
+  const fp2 = conductor.fingerprint([...a].reverse());
+  assert.equal(fp1, fp2);
+});
+
+test('fingerprint differs when the advisory set changes', () => {
+  const a1 = conductor.evaluateTriggers({ changedFiles: ['CLAUDE.md'], prompt: 'x', activeClaims: null });
+  const a2 = conductor.evaluateTriggers({ changedFiles: ['CLAUDE.md', 'src/bongos/auth.js'], prompt: 'x', activeClaims: null });
+  assert.notEqual(conductor.fingerprint(a1), conductor.fingerprint(a2));
+});
+
+test('render produces the [otb] 🎼 Conductor block', () => {
+  const a = conductor.evaluateTriggers({ changedFiles: [], prompt: 'ship it', activeClaims: null });
+  const text = conductor.render(a);
+  assert.match(text, /\[otb\] 🎼 Conductor:/);
+  assert.match(text, /panel/i);
+});
+
+// ---------- status-intent trigger (#435) ----------
+
+test('status-intent: "what tasks are remaining to complete the memory criteria (C8)" fires + extracts C8', () => {
+  const a = conductor.evaluateTriggers({
+    changedFiles: [], activeClaims: null,
+    prompt: 'What tasks are remaining to complete the memory criteria (C8)?',
+  });
+  assert.ok(ids(a).includes('status-intent'));
+  const t = a.find((x) => x.id === 'status-intent').text;
+  assert.match(t, /\/status C8/);
+});
+
+test('status-intent: "what\'s the status of GDS-V3" fires with bare /status', () => {
+  const a = conductor.evaluateTriggers({ changedFiles: [], activeClaims: null, prompt: "what's the status of GDS-V3?" });
+  assert.ok(ids(a).includes('status-intent'));
+  assert.match(a.find((x) => x.id === 'status-intent').text, /`\/status`/);
+});
+
+test('status-intent: "is R56 shipped" fires', () => {
+  const a = conductor.evaluateTriggers({ changedFiles: [], activeClaims: null, prompt: 'is R56 shipped yet?' });
+  assert.ok(ids(a).includes('status-intent'));
+});
+
+test('status-intent: does NOT fire on an unrelated prompt', () => {
+  const a = conductor.evaluateTriggers({ changedFiles: [], activeClaims: null, prompt: 'add a new tile to the world map' });
+  assert.ok(!ids(a).includes('status-intent'));
+});
+
+test('status-intent: zero LLM/network — pure on prompt alone (no claim, no files)', () => {
+  // evaluateTriggers is synchronous + pure; if this returns, no awaiting happened.
+  const a = conductor.evaluateTriggers({ changedFiles: [], activeClaims: null, prompt: "what's left for C2?" });
+  assert.ok(ids(a).includes('status-intent'));
+  assert.match(a.find((x) => x.id === 'status-intent').text, /\/status C2/);
+});
+
+// ========================================================================
+// Phase 4 — dispatch (#439)
+// ========================================================================
+
+test('dispatchFingerprint: empty when no dispatchable advisory', () => {
+  const a = conductor.evaluateTriggers({ changedFiles: ['CLAUDE.md'], prompt: 'x', activeClaims: null });
+  assert.equal(conductor.dispatchFingerprint(a), '');
+});
+
+test('dispatchFingerprint: sorted sensitive-file set', () => {
+  const a = conductor.evaluateTriggers({
+    changedFiles: ['src/bongos/routes/b.js', 'migrations/053_x.sql', 'src/bongos/routes/a.js'],
+    prompt: 'x', activeClaims: null,
+  });
+  assert.equal(conductor.dispatchFingerprint(a), 'migrations/053_x.sql,src/bongos/routes/a.js,src/bongos/routes/b.js');
+});
+
+test('dispatchFingerprint: changes when a NEW sensitive file appears (re-dispatch signal)', () => {
+  const a1 = conductor.evaluateTriggers({ changedFiles: ['src/bongos/routes/a.js'], prompt: 'x', activeClaims: null });
+  const a2 = conductor.evaluateTriggers({ changedFiles: ['src/bongos/routes/a.js', 'src/bongos/auth.js'], prompt: 'x', activeClaims: null });
+  assert.notEqual(conductor.dispatchFingerprint(a1), conductor.dispatchFingerprint(a2));
+});
+
+test('sensitiveFiles: returns only the security-surface files', () => {
+  assert.deepEqual(
+    conductor.sensitiveFiles(['public/game/main.js', 'src/bongos/routes/x.js', 'migrations/1.sql', 'README.md']).sort(),
+    ['migrations/1.sql', 'src/bongos/routes/x.js']
+  );
+});
+
+test('render: showDispatch=true emits an actionable DISPATCH directive', () => {
+  const a = conductor.evaluateTriggers({ changedFiles: ['src/bongos/auth.js'], prompt: 'x', activeClaims: null });
+  const text = conductor.render(a, { showDispatch: true });
+  assert.match(text, /🚨 DISPATCH/);
+  assert.match(text, /Bringing in the hacker/i);
+  assert.match(text, /conductor-dispatch\.js hacker/);
+  assert.match(text, /run .* now and surface/i);
+});
+
+test('render: showDispatch=false emits the milder already-reviewed form', () => {
+  const a = conductor.evaluateTriggers({ changedFiles: ['src/bongos/auth.js'], prompt: 'x', activeClaims: null });
+  const text = conductor.render(a, { showDispatch: false });
+  assert.doesNotMatch(text, /🚨 DISPATCH/);
+  assert.match(text, /already reviewed/i);
+});
+
+// pickSpecialists lives in the dispatcher CLI (pure, exported).
+const dispatch = require('../scripts/gds/conductor-dispatch.js');
+
+test('pickSpecialists: hacker when a security surface is in the diff', () => {
+  assert.deepEqual(dispatch.pickSpecialists(['src/bongos/routes/tasks.js']), ['hacker']);
+  assert.deepEqual(dispatch.pickSpecialists(['migrations/053_x.sql']), ['hacker']);
+  assert.deepEqual(dispatch.pickSpecialists(['src/bongos/auth.js', 'public/x.js']), ['hacker']);
+});
+
+test('pickSpecialists: nothing auto-picked when no security surface changed', () => {
+  assert.deepEqual(dispatch.pickSpecialists(['public/game/main.js', 'docs/notes.md']), []);
+  assert.deepEqual(dispatch.pickSpecialists([]), []);
+});
+
+// bestMatchingClaim (#439 first-ship fix — was untested, the major the panel flagged).
+test('bestMatchingClaim: picks the claim whose touches[] best overlap the diff', () => {
+  const claims = [
+    { task_id: 415, touches: ['migrations/'] },                       // 0 overlap
+    { task_id: 439, touches: ['scripts/gds/conductor-dispatch.js', '.claude/hooks/conductor.js'] }, // 2
+  ];
+  const changed = ['scripts/gds/conductor-dispatch.js', '.claude/hooks/conductor.js'];
+  assert.equal(dispatch.bestMatchingClaim(claims, changed).task_id, 439);
+});
+
+test('bestMatchingClaim: zero overlap across all → falls back to first claim', () => {
+  const claims = [{ task_id: 1, touches: ['migrations/'] }, { task_id: 2, touches: ['art/'] }];
+  assert.equal(dispatch.bestMatchingClaim(claims, ['server.js']).task_id, 1);
+});
+
+test('bestMatchingClaim: ties keep the earlier claim', () => {
+  const claims = [
+    { task_id: 1, touches: ['src/bongos/'] },
+    { task_id: 2, touches: ['src/bongos/'] },
+  ];
+  assert.equal(dispatch.bestMatchingClaim(claims, ['src/bongos/db.js']).task_id, 1);
+});
+
+test('bestMatchingClaim: single claim returned; empty/null → null', () => {
+  assert.equal(dispatch.bestMatchingClaim([{ task_id: 7, touches: [] }], ['x']).task_id, 7);
+  assert.equal(dispatch.bestMatchingClaim([], ['x']), null);
+  assert.equal(dispatch.bestMatchingClaim(null, ['x']), null);
+});
+
+test('isCovered now delegates to the canonical matcher (still correct)', () => {
+  // Regression guard for the dedup: isCovered is a thin wrapper over
+  // path-match.matchOne (relocated from the deleted touches-scan in task 879),
+  // but its boolean contract is unchanged.
+  assert.equal(conductor.isCovered('src/bongos/routes/x.js', ['src/bongos/routes/']), true);
+  assert.equal(conductor.isCovered('server.js', ['migrations/']), false);
+  assert.equal(conductor.isCovered('migrations/1.sql', ['migrations/']), true);
+});
+
+test('hook + dispatcher share ONE security-surface source (no drift possible)', () => {
+  // Phase 4 dogfood fix: SENSITIVE_SURFACES now lives in one module that both
+  // the hook and the dispatcher import. Probe EVERY surface (incl. Caddyfile +
+  // server.js, which the old 4-item probe missed) through both modules'
+  // public functions — they must agree because they share the definition.
+  const surfaces = require('../src/bongos/sensitive-surfaces.js');
+  const probe = [
+    'src/bongos/routes/x.js',
+    'migrations/053_x.sql',
+    'src/bongos/auth.js',
+    'server.js',
+    'Caddyfile',
+    'src/bongos/sensitive-surfaces.js', // the defs file self-triggers (#439 fix)
+  ];
+  // Every canonical surface must be represented in the probe (guards against
+  // adding a surface without testing it).
+  assert.equal(surfaces.SENSITIVE_SURFACES.length, probe.length, 'probe must cover every surface');
+  for (const f of probe) {
+    assert.ok(surfaces.isSensitive(f), `shared module should flag ${f}`);
+    assert.equal(conductor.sensitiveFiles([f]).length, 1, `hook should flag ${f}`);
+    assert.equal(dispatch.pickSpecialists([f])[0], 'hacker', `dispatcher should auto-pick hacker for ${f}`);
+  }
+  // A non-surface file is flagged by none of them.
+  assert.ok(!surfaces.isSensitive('public/game/main.js'));
+  assert.equal(conductor.sensitiveFiles(['public/game/main.js']).length, 0);
+  assert.deepEqual(dispatch.pickSpecialists(['public/game/main.js']), []);
+});
+
+// ========================================================================
+// Phase 4.5 — autonomous background dispatch (#458)
+// ========================================================================
+
+test('selectAutonomousDispatch: NO-GO gate → no dispatch, carries the reason', () => {
+  const r = dispatch.selectAutonomousDispatch(
+    { decision: 'no-go', reason: 'spend brake' },
+    [{ id: 7, title: 't' }],
+  );
+  assert.equal(r.ok, false);
+  assert.match(r.reason, /spend brake/);
+});
+
+test('selectAutonomousDispatch: missing/empty gate → not ok', () => {
+  assert.equal(dispatch.selectAutonomousDispatch(null, [{ id: 1 }]).ok, false);
+  assert.equal(dispatch.selectAutonomousDispatch({}, [{ id: 1 }]).ok, false);
+});
+
+test('selectAutonomousDispatch: GO but empty feed → no dispatch', () => {
+  const r = dispatch.selectAutonomousDispatch({ decision: 'go', reason: 'signal' }, []);
+  assert.equal(r.ok, false);
+  assert.match(r.reason, /no claimable/i);
+  // null/undefined feed is treated the same (no crash)
+  assert.equal(dispatch.selectAutonomousDispatch({ decision: 'go' }, null).ok, false);
+});
+
+test('selectAutonomousDispatch: GO + feed → picks rows[0] and shapes the claim directive', () => {
+  const r = dispatch.selectAutonomousDispatch(
+    { decision: 'go', reason: 'signal' },
+    [
+      { id: 458, title: 'MAS Phase 4.5', version_id: 'GDS-V4', est_minutes: 120, discipline: 'engineer' },
+      { id: 999, title: 'lower priority' },
+    ],
+  );
+  assert.equal(r.ok, true);
+  assert.equal(r.task.id, 458, 'takes the top (already-ordered, protected-filtered) row');
+  assert.equal(r.command, 'node scripts/gds/claim.js 458');
+  assert.match(r.directive, /#458/);
+  assert.match(r.directive, /\/builder-ship/);
+});
+
+test('selectAutonomousDispatch: prefers calibrated estimate when present', () => {
+  const r = dispatch.selectAutonomousDispatch(
+    { decision: 'go' },
+    [{ id: 1, title: 't', est_minutes: 200, est_minutes_calibrated: 45 }],
+  );
+  assert.equal(r.task.est_minutes, 45);
+});
+
+test('autoDispatch: gate NO-GO short-circuits — never touches the claimable feed', async () => {
+  let feedCalled = 0;
+  const out = await dispatch.autoDispatch({
+    precheck: async () => ({ decision: 'no-go', reason: 'inert/no-signal' }),
+    listClaimableTasks: async () => { feedCalled++; return [{ id: 1 }]; },
+  });
+  assert.equal(out.ok, false);
+  assert.equal(feedCalled, 0, 'feed not fetched when the gate says NO-GO (no spend)');
+  assert.match(out.reason, /inert|no-signal/);
+});
+
+test('autoDispatch: GO → fetches the autonomous feed and emits a directive', async () => {
+  let feedOpts = null;
+  const out = await dispatch.autoDispatch({
+    precheck: async () => ({ decision: 'go', reason: 'signal present' }),
+    listClaimableTasks: async (opts) => { feedOpts = opts; return [{ id: 458, title: 'MAS Phase 4.5' }]; },
+  });
+  assert.deepEqual(feedOpts, { fit: 'autonomous' }, 'asks for the protected-filtered autonomous feed');
+  assert.equal(out.ok, true);
+  assert.equal(out.task.id, 458);
+  assert.equal(out.command, 'node scripts/gds/claim.js 458');
+});
+
+test('autoDispatch: a thrown precheck degrades to NO-GO (fail-safe, no dispatch)', async () => {
+  const out = await dispatch.autoDispatch({
+    precheck: async () => { throw new Error('db down'); },
+    listClaimableTasks: async () => [{ id: 1 }],
+  });
+  assert.equal(out.ok, false);
+  assert.match(out.gate.reason, /gate error/);
+});
+
+// ---------- Summary ----------
+
+console.log('');
+console.log(`Conductor tests: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/tests/confirm_attribution.mjs

@@ -0,0 +1,156 @@
+// tests/confirm_attribution.mjs
+//
+// Regression guard for #661 — when an Archon manual-confirms (POST
+// /tasks/:id/confirm) ANOTHER builder's completed task, BOTH the credit_log
+// row AND tasks.shipped_by must land with the CLAIM HOLDER (the builder who
+// did the work), never the confirming Archon.
+//
+// Before #661, confirmTask({ taskId, builderId }) used `builderId` (the
+// confirmer, = req.builder.id, the Archon) for both the credit and the
+// shipped_by COALESCE. Live repro 2026-06-04: Xenos (#25) shipped #660 from
+// Windows, the grader infra-errored so it stalled at `completed`, an Archon
+// (#1) manual-confirmed, and the 15c landed on #1 instead of #25. The fix
+// resolves the most-recent claim holder up front and threads it into both the
+// tasks UPDATE and the credit insert; it falls back to the confirmer only when
+// the task has no claim at all.
+//
+// confirmTask opens its own transaction via pool.connect(); the #538 `deps.pool`
+// injection seam (honored ONLY when NODE_ENV==='test') lets us drive it with a
+// SQL-aware fakeClient — no live DB — same posture as override_attribution.mjs.
+//
+// Run:  node tests/confirm_attribution.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { makeRunner, makeSqlAwareClient } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+
+const require = createRequire(import.meta.url);
+// Credit allocation carved into modules/economy/ (BV1.R77 / ADR 0093 §1-2):
+// confirmTask resolves the `reward` kernel port for the credit grant, so the
+// port must be registered before driving it. reward.js delegates to the live
+// achievements/credits objects (stubs would bite if used; confirmTask uses only
+// the credit path).
+const achievements = require('../modules/economy/achievements.js');
+achievements.evaluateAfterShip = async () => [];
+achievements.evaluateAfterCreditAward = async () => [];
+achievements.evaluateAfterClaim = async () => [];
+// task 1679: confirmTask (the skip-grade path) now reconciles achievements.
+achievements.reconcileBuilderAchievements = async () => [];
+const seams = require('../src/module-seams.js');
+if (!seams.hasProvider('reward')) seams.registerProvider('reward', require('../modules/economy/reward.js'));
+const db = require('../modules/lifecycle/db.js');
+const { confirmTask } = db;
+
+const { test, summary } = makeRunner();
+
+// SQL-aware fake: returns rows by matching the statement, records every call so
+// the test can inspect the exact params each query received. Order-independent.
+//   claimHolderId === null  → simulate a task with NO claims row (fallback path)
+//   priorCredit === true    → a 'task.confirmed' row already exists (idempotent)
+//   taskCompleted === false → the tasks UPDATE matches nothing (wrong state)
+function fakePool({ claimHolderId, task, priorCredit = false, taskCompleted = true }) {
+  return makeSqlAwareClient((s, params) => {
+      if (/SELECT builder_id FROM claims/.test(s)) {
+        return { rows: claimHolderId == null ? [] : [{ builder_id: claimHolderId }] };
+      }
+      if (/^UPDATE tasks/.test(s)) {
+        return {
+          rows: taskCompleted
+            ? [{ id: task.id, title: task.title, credits_reward: task.credits_reward, kind: task.kind }]
+            : [],
+        };
+      }
+      if (/SELECT 1 FROM credit_log .* 'task\.confirmed'/.test(s)) {
+        return { rows: priorCredit ? [{ '?column?': 1 }] : [] };
+      }
+      if (/SELECT 1 FROM credit_log .* 'idea_promotion_bonus'/.test(s)) return { rows: [] };
+      if (/FROM idea_inbox/.test(s)) return { rows: [] };   // no idea lineage
+      if (/INSERT INTO credit_log/.test(s)) return { rows: [] };
+      return { rows: [] };                                  // BEGIN / COMMIT / etc.
+  });
+}
+
+const find = (queries, re) => queries.find((q) => re.test(String(q.sql).replace(/\s+/g, ' ')));
+const all = (queries, re) => queries.filter((q) => re.test(String(q.sql).replace(/\s+/g, ' ')));
+
+// Arbitrary fixture IDs (not real prod row IDs) — encode the regression intent
+// without coupling to production primary keys (V3.R12).
+const ARCHON = 1;       // the confirmer
+const WORKER = 25;      // the claim holder who actually did the work
+const TASK = { id: 660, title: 'fixture task', credits_reward: 15, kind: 'feature' };
+
+// =========================================================================
+await test('confirm: credit_log.builder_id is the CLAIM HOLDER, not the confirming Archon', async () => {
+  const pool = fakePool({ claimHolderId: WORKER, task: TASK });
+  const out = await confirmTask({ taskId: TASK.id, builderId: ARCHON }, { pool });
+
+  assert.equal(out.taskStatus, 'confirmed', 'task should flip to confirmed');
+  assert.equal(out.creditedBuilderId, WORKER, 'creditedBuilderId must be the claim holder');
+  assert.ok(out.creditsAwarded > 0, 'a positive credit must be awarded');
+
+  const credit = find(pool._client.queries, /INSERT INTO credit_log/);
+  assert.ok(credit, 'a credit_log INSERT must run');
+  assert.equal(credit.params[0], WORKER, 'credit_log.builder_id must be the claim holder');
+  assert.notEqual(credit.params[0], ARCHON, 'credit_log.builder_id must NOT be the Archon');
+  assert.equal(credit.params[1], TASK.id, 'credit_log.task_id must be the task');
+});
+
+await test('confirm: tasks.shipped_by ($2 of the UPDATE) is attributed to the claim holder', async () => {
+  const pool = fakePool({ claimHolderId: WORKER, task: TASK });
+  await confirmTask({ taskId: TASK.id, builderId: ARCHON }, { pool });
+
+  const taskUpdate = find(pool._client.queries, /^UPDATE tasks/);
+  assert.ok(taskUpdate, 'a tasks UPDATE must run');
+  assert.deepEqual(taskUpdate.params, [TASK.id, WORKER],
+    `shipped_by must bind to the claim holder ${WORKER}, got ${JSON.stringify(taskUpdate.params)}`);
+  assert.notEqual(taskUpdate.params[1], ARCHON, 'shipped_by must NOT be the confirming Archon');
+});
+
+await test('confirm: the claim-holder lookup happens BEFORE the tasks UPDATE', async () => {
+  const pool = fakePool({ claimHolderId: WORKER, task: TASK });
+  await confirmTask({ taskId: TASK.id, builderId: ARCHON }, { pool });
+  const idxClaim = pool._client.queries.findIndex((q) => /SELECT builder_id FROM claims/.test(String(q.sql).replace(/\s+/g, ' ')));
+  const idxUpdate = pool._client.queries.findIndex((q) => /^UPDATE tasks/.test(String(q.sql).replace(/\s+/g, ' ')));
+  assert.ok(idxClaim >= 0 && idxUpdate >= 0, 'both queries must run');
+  assert.ok(idxClaim < idxUpdate, 'claim holder must be resolved before the tasks UPDATE binds shipped_by');
+});
+
+await test('confirm: NO claim on the task → falls back to the confirmer (never refuses a legit confirm)', async () => {
+  const pool = fakePool({ claimHolderId: null, task: TASK });
+  const out = await confirmTask({ taskId: TASK.id, builderId: ARCHON }, { pool });
+  assert.equal(out.creditedBuilderId, ARCHON, 'with no claim, the confirmer is the only candidate');
+  const credit = find(pool._client.queries, /INSERT INTO credit_log/);
+  assert.equal(credit.params[0], ARCHON, 'fallback credit goes to the confirmer');
+});
+
+await test('confirm: idempotent — a prior task.confirmed credit means no second credit insert', async () => {
+  const pool = fakePool({ claimHolderId: WORKER, task: TASK, priorCredit: true });
+  const out = await confirmTask({ taskId: TASK.id, builderId: ARCHON }, { pool });
+  assert.equal(out.creditsAwarded, 0, 'no fresh credit on a re-confirm');
+  assert.equal(all(pool._client.queries, /INSERT INTO credit_log/).length, 0, 'must not double-insert credit');
+});
+
+await test('confirm: transaction commits on the happy path (no rollback)', async () => {
+  const pool = fakePool({ claimHolderId: WORKER, task: TASK });
+  await confirmTask({ taskId: TASK.id, builderId: ARCHON }, { pool });
+  assert.ok(find(pool._client.queries, /^COMMIT/), 'must COMMIT');
+  assert.ok(!find(pool._client.queries, /^ROLLBACK/), 'must not ROLLBACK on the happy path');
+});
+
+await test('confirm: task not in completed state → throws TASK_NOT_COMPLETED and rolls back', async () => {
+  const pool = fakePool({ claimHolderId: WORKER, task: TASK, taskCompleted: false });
+  await assert.rejects(
+    () => confirmTask({ taskId: TASK.id, builderId: ARCHON }, { pool }),
+    (err) => err.code === 'TASK_NOT_COMPLETED',
+    'must throw TASK_NOT_COMPLETED when the UPDATE matches no completed row'
+  );
+  assert.equal(all(pool._client.queries, /INSERT INTO credit_log/).length, 0, 'must not award credit');
+  assert.ok(find(pool._client.queries, /^ROLLBACK/), 'must ROLLBACK');
+});
+
+// -------------------------------------------------------------------------
+// runner summary
+// -------------------------------------------------------------------------
+summary();