@bongos/core 1.17.0

package/tests/discord_foundation.mjs

@@ -0,0 +1,76 @@
+// tests/discord_foundation.mjs
+//
+// Unit tests for the Discord bot foundation (Phase 3 F1, ADR 0033).
+//
+// The load-bearing invariant: requireDiscordBot is an IDENTITY gate, NOT a rank
+// gate. Only the Discord bot service principal (system_role='discord_bot')
+// passes; an Archon token — the highest human rank — is REJECTED (403), and so
+// is a DIFFERENT system principal (the BFG). This is the same trust-boundary
+// discipline the BFG principal uses (ADR 0026 §6C), and it is what stops a
+// Discord reaction from ever escalating past the linked builder's real rank.
+//
+// Run:  node tests/discord_foundation.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const auth = require('../src/bongos/auth.js');
+const { attachFail } = require('../src/bongos/middleware/error-envelope.js');
+
+let passed = 0;
+let failed = 0;
+function t(name, fn) {
+  return Promise.resolve()
+    .then(fn)
+    .then(() => { passed++; console.log(`  PASS  ${name}`); })
+    .catch((e) => { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); });
+}
+
+function runGate(builder) {
+  const req = { builder };
+  let code = null, body = null, nexted = false;
+  const res = {
+    status(c) { code = c; return this; },
+    json(b) { body = b; return this; },
+  };
+  attachFail({}, res, () => {}); // install res.fail() as the router does (task 1991)
+  auth.requireDiscordBot(req, res, () => { nexted = true; });
+  return { nexted, code, body };
+}
+
+console.log('requireDiscordBot (identity gate — NOT a rank gate):');
+
+await t('the Discord bot principal (system_role="discord_bot") passes', () => {
+  const r = runGate({ id: 7, system_role: 'discord_bot', rank: 'xenos' });
+  assert.equal(r.nexted, true);
+  assert.equal(r.code, null);
+});
+
+await t('an ARCHON token is REJECTED (403 not_discord_bot_principal)', () => {
+  const r = runGate({ id: 1, rank: 'archon', system_role: null });
+  assert.equal(r.nexted, false, 'an archon must NOT reach the bot write path');
+  assert.equal(r.code, 403);
+  assert.equal(r.body.error.code, 'not_discord_bot_principal');
+});
+
+await t('the BFG principal is REJECTED — system_role must match EXACTLY (bfg != discord_bot)', () => {
+  const r = runGate({ id: 9, system_role: 'bfg', rank: 'xenos' });
+  assert.equal(r.nexted, false);
+  assert.equal(r.code, 403);
+});
+
+await t('metic, xenos, and tokens with no builder are all rejected', () => {
+  for (const b of [
+    { id: 2, rank: 'metic', system_role: null },
+    { id: 3, rank: 'xenos', system_role: null },
+    null,
+    {},
+  ]) {
+    const r = runGate(b);
+    assert.equal(r.nexted, false);
+    assert.equal(r.code, 403);
+  }
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);

package/tests/discord_inbound.mjs

@@ -0,0 +1,190 @@
+// tests/discord_inbound.mjs
+//
+// Unit tests for Discord inbound → idea_inbox (Phase 3 F6 part 1, ADR 0033 §5).
+// Pure derivation + orchestration via injected fakes — no Discord, no DB:
+//   - deriveIdea: message → { title, bodyMd }; blank → null; title capped.
+//   - recordInboundIdea: files via captureIdea, attributes to the linked builder
+//     (captured_by) or NULL when unlinked, audits surface='discord_bot', never
+//     throws, and ignores bad/empty input.
+//
+// Run:  node tests/discord_inbound.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const ib = require('../modules/discord/discord-inbound.js');
+
+let passed = 0, failed = 0;
+function t(name, fn) {
+  return Promise.resolve().then(fn)
+    .then(() => { passed++; console.log(`  PASS  ${name}`); })
+    .catch((e) => { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); });
+}
+
+const GOOD_ID = '123456789012345678';
+
+console.log('Discord inbound → idea_inbox (Phase 3 F6):');
+
+// ---- deriveIdea ------------------------------------------------------------
+await t('deriveIdea: first line is the title, full text is the body', () => {
+  const d = ib.deriveIdea('Add a dark mode\n\nplayers asked for it');
+  assert.equal(d.title, 'Add a dark mode');
+  assert.equal(d.bodyMd, 'Add a dark mode\n\nplayers asked for it');
+});
+await t('deriveIdea: blank / non-string → null', () => {
+  for (const c of ['', '   ', '\n\n', null, undefined, 42]) assert.equal(ib.deriveIdea(c), null);
+});
+await t('deriveIdea: skips leading blank lines for the title', () => {
+  assert.equal(ib.deriveIdea('\n\n  the real first line  \nmore').title, 'the real first line');
+});
+await t('deriveIdea: long first line is capped (≤200, ellipsis)', () => {
+  const long = 'x'.repeat(300);
+  const d = ib.deriveIdea(long);
+  assert.ok(d.title.length <= 200, `title len ${d.title.length}`);
+  assert.ok(d.title.endsWith('…'));
+});
+
+// ---- recordInboundIdea (fakes) --------------------------------------------
+function makeDeps(over = {}) {
+  const calls = { capture: [], audit: [], persist: [] };
+  const deps = {
+    getBuilderByDiscordUserId: async () => (over.builder === undefined ? null : over.builder),
+    captureIdea: async (a) => { calls.capture.push(a); if (over.captureThrows) throw new Error('db boom'); return { id: over.ideaId ?? 77 }; },
+    insertAuditLog: async (a) => { calls.audit.push(a); if (over.auditThrows) throw new Error('audit boom'); return { id: 1 }; },
+    persistImages: async (urls, opts) => {
+      calls.persist.push({ urls, opts });
+      if (over.persistThrows) throw new Error('persist boom');
+      return over.stored ?? urls.map((u, i) => ({ file: `bug-x-${i}.png`, url: `/api/gds/bug-attachments/bug-x-${i}.png` }));
+    },
+  };
+  return { deps, calls };
+}
+
+await t('recordInboundIdea: linked author → idea attributed to builder + audited', async () => {
+  const { deps, calls } = makeDeps({ builder: { id: 9, github_login: 'mona' } });
+  const r = await ib.recordInboundIdea({ discordUserId: GOOD_ID, content: 'Idea: faster boats', messageId: 'm1' }, deps);
+  assert.equal(r.outcome, 'filed');
+  assert.equal(r.ideaId, 77);
+  assert.equal(calls.capture[0].capturedBy, 9);
+  assert.match(calls.capture[0].bodyMd, /filed from Discord #ideas by mona/);
+  assert.equal(calls.audit[0].surface, 'discord_bot');
+  assert.equal(calls.audit[0].builderId, 9);
+});
+
+await t('recordInboundIdea: unlinked author → captured_by NULL, still filed + audited', async () => {
+  const { deps, calls } = makeDeps({ builder: null });
+  const r = await ib.recordInboundIdea({ discordUserId: GOOD_ID, content: 'anonymous idea', messageId: 'm2' }, deps);
+  assert.equal(r.outcome, 'filed');
+  assert.equal(calls.capture[0].capturedBy, null);
+  assert.match(calls.capture[0].bodyMd, /unlinked author/);
+  assert.equal(calls.audit[0].surface, 'discord_bot');
+  assert.equal(calls.audit[0].builderId, null);
+});
+
+await t('recordInboundIdea: never produces the rank-gated criterion-proposal kind', async () => {
+  const { deps, calls } = makeDeps({ builder: { id: 9, github_login: 'mona' } });
+  await ib.recordInboundIdea({ discordUserId: GOOD_ID, content: 'x', messageId: 'm' }, deps);
+  // kind is omitted (auto-classified downstream); must not be forced to the gated kind
+  assert.notEqual(calls.capture[0].kind, 'criterion-proposal');
+});
+
+await t('recordInboundIdea: empty content → ignored, nothing filed', async () => {
+  const { deps, calls } = makeDeps();
+  const r = await ib.recordInboundIdea({ discordUserId: GOOD_ID, content: '   ', messageId: 'm' }, deps);
+  assert.equal(r.outcome, 'ignored');
+  assert.equal(calls.capture.length, 0);
+});
+
+await t('recordInboundIdea: bad discord id → ignored, nothing filed', async () => {
+  const { deps, calls } = makeDeps();
+  const r = await ib.recordInboundIdea({ discordUserId: 'nope', content: 'hi', messageId: 'm' }, deps);
+  assert.equal(r.outcome, 'ignored');
+  assert.equal(calls.capture.length, 0);
+});
+
+await t('recordInboundIdea: audit failure does NOT undo the filing', async () => {
+  const { deps, calls } = makeDeps({ builder: { id: 9, github_login: 'mona' }, auditThrows: true });
+  const r = await ib.recordInboundIdea({ discordUserId: GOOD_ID, content: 'idea', messageId: 'm' }, deps);
+  assert.equal(r.outcome, 'filed');
+  assert.equal(calls.capture.length, 1);
+});
+
+await t('recordInboundIdea: a DB error returns {error}, never throws', async () => {
+  const { deps } = makeDeps({ builder: { id: 9, github_login: 'mona' }, captureThrows: true });
+  const r = await ib.recordInboundIdea({ discordUserId: GOOD_ID, content: 'idea', messageId: 'm' }, deps);
+  assert.equal(r.outcome, 'error');
+});
+
+// ---- images (task #979) ----------------------------------------------------
+await t('deriveIdea: image-only (no text) → default title, empty body', () => {
+  const d = ib.deriveIdea('', { hasImages: true });
+  assert.equal(d.title, 'Idea (image)');
+  assert.equal(d.bodyMd, '');
+});
+await t('deriveIdea: blank text AND no images → still null', () => {
+  assert.equal(ib.deriveIdea('   ', { hasImages: false }), null);
+  assert.equal(ib.deriveIdea('', {}), null);
+});
+
+await t('recordInboundIdea: text + images → persists + embeds durable links', async () => {
+  const { deps, calls } = makeDeps({ builder: { id: 9, github_login: 'mona' } });
+  const r = await ib.recordInboundIdea(
+    { discordUserId: GOOD_ID, content: 'Mockup of the new vendor UI', imageUrls: ['https://cdn.discordapp.com/a.png'], messageId: 'm1' },
+    deps
+  );
+  assert.equal(r.outcome, 'filed');
+  assert.equal(r.images, 1);
+  assert.equal(calls.persist.length, 1);
+  assert.match(calls.capture[0].bodyMd, /Attachments \(1\)/);
+  assert.match(calls.capture[0].bodyMd, /!\[attachment 1\]\(\/api\/gds\/bug-attachments\//);
+});
+
+await t('recordInboundIdea: UNLINKED author with image → still re-hosted (guards, not identity)', async () => {
+  const { deps, calls } = makeDeps({ builder: null });
+  const r = await ib.recordInboundIdea(
+    { discordUserId: GOOD_ID, content: '', imageUrls: ['https://cdn.discordapp.com/b.png'], messageId: 'm2' },
+    deps
+  );
+  assert.equal(r.outcome, 'filed');
+  assert.equal(r.images, 1);
+  assert.equal(calls.capture[0].capturedBy, null);
+  assert.equal(calls.capture[0].title, 'Idea (image)');
+  assert.match(calls.capture[0].bodyMd, /unlinked author/);
+});
+
+await t('recordInboundIdea: image persist failure → still files (without images)', async () => {
+  const { deps, calls } = makeDeps({ builder: { id: 9, github_login: 'mona' }, persistThrows: true });
+  const r = await ib.recordInboundIdea(
+    { discordUserId: GOOD_ID, content: 'an idea with a broken upload', imageUrls: ['https://cdn.discordapp.com/c.png'], messageId: 'm3' },
+    deps
+  );
+  assert.equal(r.outcome, 'filed');
+  assert.equal(r.images, 0);
+  assert.doesNotMatch(calls.capture[0].bodyMd, /Attachments/);
+});
+
+// ---- createIdeaAggregator (fake timers) -----------------------------------
+function fakeTimers() {
+  let seq = 0; const jobs = new Map();
+  return {
+    setTimeout: (fn) => { const id = ++seq; jobs.set(id, fn); return { id }; },
+    clearTimeout: (h) => { if (h && jobs.has(h.id)) jobs.delete(h.id); },
+    runAll: () => { for (const [, fn] of jobs) fn(); jobs.clear(); },
+  };
+}
+await t('createIdeaAggregator: a burst from one author flushes as ONE combined idea', async () => {
+  const flushed = [];
+  const timers = fakeTimers();
+  const agg = ib.createIdeaAggregator({ onFlush: async (c) => { flushed.push(c); }, windowMs: 1000, timers });
+  agg.enqueue({ discordUserId: GOOD_ID, content: 'here is a mockup', imageUrls: ['i1'], messageId: 'm1' });
+  agg.enqueue({ discordUserId: GOOD_ID, content: '', imageUrls: ['i2'], messageId: 'm2' });
+  assert.equal(flushed.length, 0, 'nothing files until the window elapses');
+  timers.runAll();
+  await new Promise((r) => setImmediate(r));
+  assert.equal(flushed.length, 1);
+  assert.equal(flushed[0].content, 'here is a mockup');
+  assert.deepEqual(flushed[0].imageUrls, ['i1', 'i2']);
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);

package/tests/discord_message_buffer.mjs

@@ -0,0 +1,87 @@
+// tests/discord_message_buffer.mjs
+//
+// Unit tests for the shared per-author burst aggregator (task #979) used by both
+// the #bugs and #ideas intakes. Pure combineParts + the aggregator driven by
+// injected fake timers (no real time).
+//
+// Run:  node tests/discord_message_buffer.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const mb = require('../modules/discord/discord-message-buffer.js');
+
+let passed = 0, failed = 0;
+function t(name, fn) {
+  return Promise.resolve().then(fn)
+    .then(() => { passed++; console.log(`  PASS  ${name}`); })
+    .catch((e) => { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); });
+}
+
+function fakeTimers() {
+  let seq = 0; const jobs = new Map();
+  return {
+    setTimeout: (fn) => { const id = ++seq; jobs.set(id, fn); return { id }; },
+    clearTimeout: (h) => { if (h && jobs.has(h.id)) jobs.delete(h.id); },
+    runAll: () => { for (const [, fn] of jobs) fn(); jobs.clear(); },
+    size: () => jobs.size,
+  };
+}
+
+console.log('Discord message-burst aggregator (task #979):');
+
+await t('combineParts: joins text, concatenates images, anchors on first id', () => {
+  const c = mb.combineParts([
+    { content: '', imageUrls: ['i1'], messageId: 'first' },
+    { content: 'caption', imageUrls: ['i2'], messageId: 'second' },
+  ]);
+  assert.equal(c.content, 'caption');
+  assert.deepEqual(c.imageUrls, ['i1', 'i2']);
+  assert.equal(c.messageId, 'first');
+});
+
+await t('combineParts: empty burst → empty content, no images, undefined id', () => {
+  const c = mb.combineParts([]);
+  assert.equal(c.content, '');
+  assert.deepEqual(c.imageUrls, []);
+  assert.equal(c.messageId, undefined);
+});
+
+await t('aggregator: a fresh message resets the window (debounce, not fixed delay)', async () => {
+  const flushed = [];
+  const timers = fakeTimers();
+  const agg = mb.createMessageAggregator({ onFlush: async (c) => { flushed.push(c); }, windowMs: 1000, timers });
+  agg.enqueue({ discordUserId: 'a', content: 'one', imageUrls: [], messageId: 'm1' });
+  agg.enqueue({ discordUserId: 'a', content: 'two', imageUrls: [], messageId: 'm2' });
+  // Only the latest timer should be live (the first was cleared on re-enqueue).
+  assert.equal(timers.size(), 1);
+  timers.runAll();
+  await new Promise((r) => setImmediate(r));
+  assert.equal(flushed.length, 1);
+  assert.equal(flushed[0].content, 'one\n\ntwo');
+});
+
+await t('aggregator: independent authors flush as separate records', async () => {
+  const flushed = [];
+  const timers = fakeTimers();
+  const agg = mb.createMessageAggregator({ onFlush: async (c) => { flushed.push(c); }, windowMs: 1000, timers });
+  agg.enqueue({ discordUserId: 'a', content: 'A', imageUrls: [], messageId: 'a1' });
+  agg.enqueue({ discordUserId: 'b', content: 'B', imageUrls: [], messageId: 'b1' });
+  assert.equal(timers.size(), 2);
+  agg.flushAll();
+  await new Promise((r) => setImmediate(r));
+  assert.equal(flushed.length, 2);
+});
+
+await t('aggregator: a throwing onFlush is caught (never escapes the gateway)', async () => {
+  const timers = fakeTimers();
+  const agg = mb.createMessageAggregator({ onFlush: async () => { throw new Error('boom'); }, windowMs: 1000, timers });
+  agg.enqueue({ discordUserId: 'a', content: 'x', imageUrls: [], messageId: 'm' });
+  timers.runAll();
+  await new Promise((r) => setImmediate(r));
+  // reaching here without an unhandled rejection crashing the test is the assertion
+  assert.ok(true);
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);

package/tests/discord_oauth.mjs

@@ -0,0 +1,55 @@
+// tests/discord_oauth.mjs
+//
+// Unit tests for the Discord account-linking OAuth helpers (Phase 3 F2, ADR
+// 0033 §2). Pure-function coverage — no creds, no network:
+//   - discordAuthorizeUrl carries the right params, including the CSRF `state`.
+//   - isValidDiscordUserId enforces the snowflake format (the F1 Hacker advisory:
+//     a malformed/oversized id must never reach db.linkDiscord).
+//
+// The route-level CSRF state-mismatch rejection mirrors the GitHub web-callback
+// pattern in routes/auth.js (the state cookie must equal the state Discord echoes
+// back); that lives in the route and is reviewed by the grader.
+//
+// Run:  node tests/discord_oauth.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const auth = require('../src/bongos/auth.js');
+
+let passed = 0, failed = 0;
+function t(name, fn) {
+  return Promise.resolve().then(fn)
+    .then(() => { passed++; console.log(`  PASS  ${name}`); })
+    .catch((e) => { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); });
+}
+
+console.log('Discord OAuth helpers (Phase 3 F2):');
+
+await t('discordAuthorizeUrl carries client_id, identify+guilds.join scope, code response, state, redirect', () => {
+  const url = auth.discordAuthorizeUrl('123456789012345678', 'abc123state', 'https://amazonprimea.com/api/gds/auth/discord/callback');
+  const u = new URL(url);
+  assert.equal(u.origin + u.pathname, 'https://discord.com/api/oauth2/authorize');
+  assert.equal(u.searchParams.get('client_id'), '123456789012345678');
+  // F7 (ADR 0033): guilds.join is requested alongside identify so the server can
+  // auto-add the just-linked builder to the guild (the link-first onboarding gate).
+  assert.equal(u.searchParams.get('scope'), 'identify guilds.join');
+  assert.equal(u.searchParams.get('response_type'), 'code');
+  assert.equal(u.searchParams.get('state'), 'abc123state');
+  assert.equal(u.searchParams.get('redirect_uri'), 'https://amazonprimea.com/api/gds/auth/discord/callback');
+});
+
+await t('isValidDiscordUserId accepts a 17–20 digit snowflake', () => {
+  for (const id of ['12345678901234567', '123456789012345678', '12345678901234567890']) {
+    assert.equal(auth.isValidDiscordUserId(id), true, `should accept ${id}`);
+  }
+});
+
+await t('isValidDiscordUserId rejects junk: short, long, non-numeric, empty, non-string', () => {
+  for (const id of ['123', '123456789012345678901', 'abc', '12345abc8901234567', '', null, undefined, 12345678901234567]) {
+    assert.equal(auth.isValidDiscordUserId(id), false, `should reject ${String(id)}`);
+  }
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);

package/tests/discord_reaction.mjs

@@ -0,0 +1,170 @@
+// tests/discord_reaction.mjs
+//
+// Unit tests for Discord reaction → upvote/applause (Phase 3 F4, ADR 0033 §3).
+// The load-bearing logic is PURE and tested here exhaustively — no DB, no bot:
+//   - parseShipMarker: maps a #ship-feed line back to its task id, anchored to
+//     the LEADING #<id> so a summary mentioning another #id can't hijack it.
+//   - classifyReaction: the vote-vs-applause decision — a REAL peer-vote only
+//     for a linked Metic+ non-author on votable work; everyone else → applause.
+//     This is the trust-boundary branch (ADR 0033 §1/§3).
+//   - recordDiscordReaction: orchestration via injected fakes — confirms it
+//     re-derives authorization, records to the RIGHT store, audits every write
+//     with surface='discord_bot', and NEVER throws (the caller is a gateway
+//     event handler).
+//
+// Run:  node tests/discord_reaction.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const rx = require('../modules/discord/discord-reaction.js');
+
+// VOTABLE_TASK_STATUSES carved to the lifecycle module at BV1.R86 — discord-reaction
+// resolves it through the `lifecycle` kernel port now (the doorway leak retired).
+// Register the real port surface so classifyReaction sees the genuine votable set.
+const seams = require('../src/module-seams.js');
+seams._reset();
+seams.registerProvider('lifecycle', require('../modules/lifecycle/lifecycle.js'));
+
+let passed = 0, failed = 0;
+function t(name, fn) {
+  return Promise.resolve().then(fn)
+    .then(() => { passed++; console.log(`  PASS  ${name}`); })
+    .catch((e) => { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); });
+}
+
+console.log('Discord reaction → upvote/applause (Phase 3 F4):');
+
+// ---- parseShipMarker -------------------------------------------------------
+await t('parseShipMarker reads the LEADING #<id>', () => {
+  assert.equal(rx.parseShipMarker('#669 shipped — the bot connects'), 669);
+  assert.equal(rx.parseShipMarker('   #680 shipped — foo'), 680);   // leading ws ok
+  assert.equal(rx.parseShipMarker('#42'), 42);
+});
+
+await t('parseShipMarker ignores non-leading #ids (no hijack)', () => {
+  assert.equal(rx.parseShipMarker('this fixes #662 in the code'), null);
+  assert.equal(rx.parseShipMarker('shipped #669'), null); // marker not at start
+});
+
+await t('parseShipMarker rejects junk', () => {
+  assert.equal(rx.parseShipMarker('#0 nope'), null);          // id must be > 0
+  assert.equal(rx.parseShipMarker('no marker here'), null);
+  assert.equal(rx.parseShipMarker('#999999999999999 huge'), null); // > 12 digits
+  assert.equal(rx.parseShipMarker(''), null);
+  assert.equal(rx.parseShipMarker(null), null);
+  assert.equal(rx.parseShipMarker(42), null);                 // non-string
+});
+
+// ---- classifyReaction (the trust-boundary decision) ------------------------
+const shippedTask = { id: 100, status: 'shipped', shipped_by: 7 };
+const confirmedTask = { id: 101, status: 'confirmed', shipped_by: 7 };
+
+await t('classifyReaction: linked Metic non-author on shipped work → peer_vote', () => {
+  assert.equal(rx.classifyReaction({ builder: { id: 5, rank: 'metic' }, task: shippedTask }), 'peer_vote');
+});
+await t('classifyReaction: linked Archon non-author on confirmed work → peer_vote', () => {
+  assert.equal(rx.classifyReaction({ builder: { id: 5, rank: 'archon' }, task: confirmedTask }), 'peer_vote');
+});
+await t('classifyReaction: Xenos → applause (cannot vote)', () => {
+  assert.equal(rx.classifyReaction({ builder: { id: 5, rank: 'xenos' }, task: shippedTask }), 'applause');
+});
+await t('classifyReaction: unlinked (no builder) → applause', () => {
+  assert.equal(rx.classifyReaction({ builder: null, task: shippedTask }), 'applause');
+});
+await t('classifyReaction: author voting on own work → applause (anti-self)', () => {
+  assert.equal(rx.classifyReaction({ builder: { id: 7, rank: 'metic' }, task: shippedTask }), 'applause');
+  // string/number mismatch must not defeat the guard
+  assert.equal(rx.classifyReaction({ builder: { id: '7', rank: 'archon' }, task: { id: 100, status: 'shipped', shipped_by: 7 } }), 'applause');
+});
+await t('classifyReaction: non-votable status → applause', () => {
+  assert.equal(rx.classifyReaction({ builder: { id: 5, rank: 'metic' }, task: { id: 1, status: 'backlog', shipped_by: 7 } }), 'applause');
+});
+await t('classifyReaction: no shipping builder → applause', () => {
+  assert.equal(rx.classifyReaction({ builder: { id: 5, rank: 'metic' }, task: { id: 1, status: 'shipped', shipped_by: null } }), 'applause');
+});
+
+// ---- recordDiscordReaction (orchestration via fakes) -----------------------
+const GOOD_ID = '123456789012345678';
+
+function makeDeps(over = {}) {
+  const calls = { upvote: [], applause: [], audit: [] };
+  const deps = {
+    getBuilderByDiscordUserId: async () => over.builder ?? null,
+    getTask: async () => (over.task === undefined ? shippedTask : over.task),
+    castBotUpvote: async (a) => { calls.upvote.push(a); return { counted: over.counted ?? true }; },
+    recordApplause: async (a) => { calls.applause.push(a); return { counted: true }; },
+    insertAuditLog: async (a) => { calls.audit.push(a); if (over.auditThrows) throw new Error('audit boom'); return { id: 1 }; },
+  };
+  return { deps, calls };
+}
+
+await t('recordDiscordReaction: Metic non-author → casts peer-vote, audits surface=discord_bot', async () => {
+  const { deps, calls } = makeDeps({ builder: { id: 5, rank: 'metic' }, task: shippedTask });
+  const r = await rx.recordDiscordReaction({ discordUserId: GOOD_ID, taskId: 100 }, deps);
+  assert.equal(r.outcome, 'peer_vote');
+  assert.equal(calls.upvote.length, 1);
+  assert.deepEqual(calls.upvote[0], { voterBuilderId: 5, taskId: 100 });
+  assert.equal(calls.applause.length, 0);
+  assert.equal(calls.audit.length, 1);
+  assert.equal(calls.audit[0].surface, 'discord_bot');
+  assert.equal(calls.audit[0].builderId, 5);
+});
+
+await t('recordDiscordReaction: unlinked user → applause (never karma)', async () => {
+  const { deps, calls } = makeDeps({ builder: null });
+  const r = await rx.recordDiscordReaction({ discordUserId: GOOD_ID, taskId: 100 }, deps);
+  assert.equal(r.outcome, 'applause');
+  assert.equal(calls.applause.length, 1);
+  assert.equal(calls.upvote.length, 0);
+  assert.equal(calls.audit[0].surface, 'discord_bot');
+});
+
+await t('recordDiscordReaction: frozen (already-tallied) vote → peer_vote_frozen', async () => {
+  const { deps } = makeDeps({ builder: { id: 5, rank: 'metic' }, counted: false });
+  const r = await rx.recordDiscordReaction({ discordUserId: GOOD_ID, taskId: 100 }, deps);
+  assert.equal(r.outcome, 'peer_vote_frozen');
+});
+
+await t('recordDiscordReaction: bad discord id → ignored, no DB writes', async () => {
+  const { deps, calls } = makeDeps({ builder: { id: 5, rank: 'metic' } });
+  const r = await rx.recordDiscordReaction({ discordUserId: 'not-a-snowflake', taskId: 100 }, deps);
+  assert.equal(r.outcome, 'ignored');
+  assert.equal(calls.upvote.length + calls.applause.length + calls.audit.length, 0);
+});
+
+await t('recordDiscordReaction: bad task id → ignored', async () => {
+  const { deps } = makeDeps({ builder: { id: 5, rank: 'metic' } });
+  assert.equal((await rx.recordDiscordReaction({ discordUserId: GOOD_ID, taskId: 0 }, deps)).outcome, 'ignored');
+  assert.equal((await rx.recordDiscordReaction({ discordUserId: GOOD_ID, taskId: -3 }, deps)).outcome, 'ignored');
+  assert.equal((await rx.recordDiscordReaction({ discordUserId: GOOD_ID, taskId: 1.5 }, deps)).outcome, 'ignored');
+});
+
+await t('recordDiscordReaction: task not found → ignored, nothing recorded', async () => {
+  const { deps, calls } = makeDeps({ builder: { id: 5, rank: 'metic' }, task: null });
+  const r = await rx.recordDiscordReaction({ discordUserId: GOOD_ID, taskId: 100 }, deps);
+  assert.equal(r.outcome, 'ignored');
+  assert.equal(calls.upvote.length + calls.applause.length, 0);
+});
+
+await t('recordDiscordReaction: audit failure does NOT undo the vote', async () => {
+  const { deps, calls } = makeDeps({ builder: { id: 5, rank: 'metic' }, auditThrows: true });
+  const r = await rx.recordDiscordReaction({ discordUserId: GOOD_ID, taskId: 100 }, deps);
+  assert.equal(r.outcome, 'peer_vote');  // still succeeded
+  assert.equal(calls.upvote.length, 1);
+});
+
+await t('recordDiscordReaction: a DB error returns {error}, never throws', async () => {
+  const deps = {
+    getBuilderByDiscordUserId: async () => { throw new Error('db down'); },
+    getTask: async () => shippedTask,
+    castBotUpvote: async () => ({ counted: true }),
+    recordApplause: async () => ({ counted: true }),
+    insertAuditLog: async () => ({ id: 1 }),
+  };
+  const r = await rx.recordDiscordReaction({ discordUserId: GOOD_ID, taskId: 100 }, deps);
+  assert.equal(r.outcome, 'error');
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);