@bongos/core 1.24.14 → 1.24.15

package/tests/market_watch_rules.mjs

@@ -45,7 +45,7 @@ const V1 = {
 
 // ── the in-memory database ─────────────────────────────────────────────────────
 function makeDb() {
-  const t = { versions: [], proposals: [], items: [], scores: [], runs: [{ id: 50, project: P, status: 'done' }], seq: 100 };
+  const t = { versions: [], proposals: [], items: [], scores: [], entries: [], runs: [{ id: 50, project: P, status: 'done' }], seq: 100 };
   const nextId = () => ++t.seq;
   t.versions.push({ id: nextId(), project: P, ...JSON.parse(JSON.stringify(V1)), approved_at: new Date('2026-10-28'), created_at: new Date('2026-10-28') });
   t.items.push({ id: nextId(), project: P, kind: 'competitor', name: 'OpenHands', url: 'https://openhands.dev', status: 'active', why_tracked: '' });
@@ -76,7 +76,11 @@ function makeDb() {
       case 'mw:proposal-lock':
       case 'mw:proposal-get-open': {
         const p = prop(a, b);
-        return one(p && (tag === 'mw:proposal-lock' || p.status === 'open') ? p : null);
+        if (!p || !(tag === 'mw:proposal-lock' || p.status === 'open')) return one(null);
+        // Hand back only the columns the real SELECT names (task 1005026): returning the
+        // whole row hid a lock that never read log_entry_id, so every correction failed.
+        const cols = String(sql).match(/SELECT\s+([\s\S]+?)\s+FROM/)[1].split(',').map((x) => x.trim());
+        return one(Object.fromEntries(cols.map((k) => [k, p[k]])));
       }
       case 'mw:rules-max-version':
         return one({ v: Math.max(0, ...t.versions.filter((v) => v.project === a).map((v) => v.version)) });
@@ -131,6 +135,18 @@ function makeDb() {
         Object.assign(p, { status: c, decided_by: d, decided_at: new Date(), rule_version_id: e ?? p.rule_version_id, item_id: f ?? p.item_id, payload: { ...p.payload, ...JSON.parse(g) } });
         return one(p);
       }
+      case 'mw:entry-lock': {
+        // the entry, only through an item of this project, and only the proposal's item
+        const e = t.entries.find((x) => String(x.id) === String(a) && String(x.item_id) === String(c));
+        const it = e && t.items.find((x) => x.id === e.item_id && x.project === b);
+        return one(e && it ? { ...e } : null);
+      }
+      case 'mw:entry-correct': {
+        const e = t.entries.find((x) => String(x.id) === String(a));
+        if (!e || t.entries.some((o) => o.id !== e.id && o.item_id === e.item_id && o.run_id === e.run_id && o.takeaway === b)) return one(null);
+        e.takeaway = b;
+        return one({ id: e.id });
+      }
       case 'mw:proposal-at-vote': {
         const p = prop(a, b);
         if (p && p.status === 'open') p.payload = { ...p.payload, matter_id: c };
@@ -282,15 +298,71 @@ test('an approved add-item proposal creates the tracked item; the run\'s and the
   assert.equal(proposals.itemFromPayload({}), null);
 });
 
-test('remove_item takes the item off the watch; a correct_entry is recorded as approved, not applied', async () => {
+test('remove_item takes the item off the watch', async () => {
   const { t, pool, withTx } = makeDb();
   const itemId = t.items[0].id;
   const filed = await proposals.createProposal(pool, { project: P, step: 'names', change: { op: 'remove', item_id: itemId }, reason: 'not a rival', proposedBy: ADA });
   await proposals.decideProposal({ project: P, id: filed.proposal.id, decision: 'approve', decidedBy: OWNER, withTx });
   assert.equal(t.items[0].status, 'removed');
-  t.proposals.push({ id: 900, project: P, kind: 'correct_entry', origin: 'member', item_id: itemId, log_entry_id: 7, payload: {}, status: 'open', proposed_by: ADA });
+});
+
+// task 1005016: an approved correct_entry corrects the entry it names.
+function withEntries() {
+  const d = makeDb();
+  const itemId = d.t.items[0].id;
+  d.t.items.push({ id: 300, project: P, kind: 'competitor', name: 'Other', url: 'https://other.dev', status: 'active' });
+  d.t.items.push({ id: 400, project: 'https://other.example', kind: 'competitor', name: 'Theirs', url: 'https://theirs.dev', status: 'active' });
+  d.t.entries.push(
+    { id: 7, item_id: itemId, run_id: 50, takeaway: 'OpenHands raised a Series B.' },
+    { id: 8, item_id: itemId, run_id: 50, takeaway: 'OpenHands shut down.' },
+    { id: 9, item_id: 300, run_id: 50, takeaway: 'Another item\'s entry.' },
+    { id: 10, item_id: 400, run_id: 50, takeaway: 'Another project\'s entry.' },
+  );
+  const file = (id, payload, { item = itemId, entry = 7 } = {}) => d.t.proposals.push({
+    id, project: P, kind: 'correct_entry', origin: 'member', item_id: item, log_entry_id: entry, payload, reason: 'their post says seed', status: 'open', proposed_by: ADA,
+  });
+  return { ...d, itemId, file };
+}
+
+test('CORRECT AN ENTRY: approving rewrites the entry, and keeps who, when, why and the old text', async () => {
+  const { t, withTx, file } = withEntries();
+  file(900, { takeaway: 'OpenHands raised a seed round, not a Series B.' });
   const out = await proposals.decideProposal({ project: P, id: 900, decision: 'approve', decidedBy: OWNER, withTx });
-  assert.deepEqual([out.status, out.applied], ['approved', false]);
+  assert.deepEqual([out.ok, out.status, out.applied, out.log_entry_id], [true, 'applied', true, 7]);
+  assert.equal(t.entries.find((e) => e.id === 7).takeaway, 'OpenHands raised a seed round, not a Series B.', 'the entry itself now reads corrected');
+  const p = t.proposals.find((x) => x.id === 900);
+  assert.equal(p.status, 'applied');
+  assert.equal(p.proposed_by, ADA, 'who proposed it');
+  assert.equal(p.decided_by, OWNER, 'who approved it');
+  assert.ok(p.decided_at instanceof Date, 'when');
+  assert.equal(p.reason, 'their post says seed', 'why');
+  assert.equal(p.payload.was, 'OpenHands raised a Series B.', 'the text it replaced is never lost');
+});
+
+test('CORRECT AN ENTRY: a wrong flag leaves the text as found and applies the flag', async () => {
+  const { t, withTx, file } = withEntries();
+  file(901, { wrong: true }, { entry: 8 });
+  const out = await proposals.decideProposal({ project: P, id: 901, decision: 'approve', decidedBy: OWNER, withTx });
+  assert.deepEqual([out.status, out.applied], ['applied', true]);
+  assert.equal(t.entries.find((e) => e.id === 8).takeaway, 'OpenHands shut down.');
+  assert.deepEqual([t.proposals.find((x) => x.id === 901).payload.wrong, t.proposals.find((x) => x.id === 901).payload.was], [true, 'OpenHands shut down.']);
+});
+
+test('CORRECT AN ENTRY: refused, and left open, when it names nothing it may change', async () => {
+  const { t, withTx, file } = withEntries();
+  const decide = (id) => proposals.decideProposal({ project: P, id, decision: 'approve', decidedBy: OWNER, withTx });
+  file(902, {}); // filed before task 1005016: the reason was the correction
+  assert.equal((await decide(902)).reason, 'no_correction');
+  file(903, { takeaway: 'x' }, { entry: 9 }); // another item's entry
+  assert.equal((await decide(903)).reason, 'entry_gone');
+  file(904, { takeaway: 'x' }, { item: 400, entry: 10 }); // another project's item and entry
+  assert.equal((await decide(904)).reason, 'entry_gone');
+  file(905, { takeaway: 'OpenHands shut down.' }); // would duplicate entry 8 in the same run
+  assert.equal((await decide(905)).reason, 'same_as_another_entry');
+  for (const id of [902, 903, 904, 905]) assert.equal(t.proposals.find((x) => x.id === id).status, 'open', `proposal ${id} stays open`);
+  assert.deepEqual(t.entries.map((e) => e.takeaway), ['OpenHands raised a Series B.', 'OpenHands shut down.', 'Another item\'s entry.', 'Another project\'s entry.'], 'no entry changed');
+  // a decline of the old kind still works
+  assert.equal((await proposals.decideProposal({ project: P, id: 902, decision: 'decline', decidedBy: OWNER, withTx })).status, 'rejected');
 });
 
 test('a project cannot decide another project\'s proposal', async () => {
@@ -422,6 +494,24 @@ test('OWNER ONLY: a member who is not the owner gets 403 and nothing changes; th
   assert.equal((await call(OWNER, 'POST', `/market-watch/proposals/${id}/decide`, { decision: 'maybe' })).status, 400);
 });
 
+test('OWNER ONLY, correcting an entry: a member gets 403 and the entry is untouched; the owner\'s approval corrects it', async () => {
+  const itemId = RT.t.items[0].id;
+  RT.t.entries.push({ id: 70, item_id: itemId, run_id: 50, takeaway: 'Old words.' });
+  RT.t.proposals.push({ id: 970, project: P, kind: 'correct_entry', origin: 'member', item_id: itemId, log_entry_id: 70, payload: { takeaway: 'New words.' }, reason: 'r', status: 'open', proposed_by: ADA });
+  const denied = await call(ADA, 'POST', '/market-watch/proposals/970/decide', { decision: 'approve' });
+  assert.deepEqual([denied.status, denied.code], [403, 'owner_only']);
+  assert.equal(RT.t.entries.find((e) => e.id === 70).takeaway, 'Old words.');
+  assert.equal(RT.t.proposals.find((p) => p.id === 970).status, 'open');
+  assert.equal((await call(null, 'POST', '/market-watch/proposals/970/decide', { decision: 'approve' })).status, 401);
+  const ok = await call(OWNER, 'POST', '/market-watch/proposals/970/decide', { decision: 'approve' });
+  assert.equal(ok.status, 200, JSON.stringify(ok.json));
+  assert.equal(RT.t.entries.find((e) => e.id === 70).takeaway, 'New words.');
+  RT.t.proposals.push({ id: 971, project: P, kind: 'correct_entry', origin: 'member', item_id: itemId, log_entry_id: 70, payload: {}, reason: 'r', status: 'open', proposed_by: ADA });
+  const old = await call(OWNER, 'POST', '/market-watch/proposals/971/decide', { decision: 'approve' });
+  assert.deepEqual([old.status, old.code], [409, 'no_correction'], 'an old proposal with no correction says so in words');
+  assert.match(old.json.error.message, /does not say how the entry should read/);
+});
+
 test('a government that hands Rules to a sitting: the owner cannot decide alone (409), the page offers the vote', async () => {
   const filed = await proposals.createProposal(RT.pool, { project: P, step: 'brief', change: { op: 'set', text: 'Five lines.' }, reason: 'r', proposedBy: ADA });
   const sitting = {
@@ -553,4 +643,10 @@ test('the payloads the item page files are the ones an approval applies', () =>
     assert.ok(n.ok, body.kind);
     assert.ok(proposals.itemChange(n.value.kind, n.value.payload), `${body.kind}: pages.js writes a payload proposals.js applies`);
   }
+  // correct_entry (task 1005016): both shapes the item page files are ones an approval applies
+  const fix = pages.normalizeProposal({ kind: 'correct_entry', log_entry_id: '7', takeaway: ' seed,\nnot B ', reason: 'r' }, { item });
+  assert.deepEqual(proposals.entryCorrection(fix.value.payload), { takeaway: 'seed, not B' });
+  const wrong = pages.normalizeProposal({ kind: 'correct_entry', log_entry_id: '7', wrong: true, reason: 'r' }, { item });
+  assert.deepEqual(proposals.entryCorrection(wrong.value.payload), { wrong: true, takeaway: null });
+  assert.equal(proposals.entryCorrection({}), null);
 });

package/tests/market_watch_rules_db.mjs

@@ -27,11 +27,14 @@ const seed = require('../modules/market-watch/seed.js');
 const store = require('../modules/market-watch/store.js');
 const proposals = require('../modules/market-watch/proposals.js');
 const view = require('../modules/market-watch/rules-view.js');
+const pages = require('../modules/market-watch/pages.js');
+const db = require('../modules/market-watch/db.js');
 const research = require('../modules/market-watch/research.js');
 const pricing = require('../src/bongos/llm-pricing.js');
 
 const MIGRATION = readFileSync(new URL('../modules/market-watch/migrations/market_watch_001_tables.sql', import.meta.url), 'utf8');
 const MIGRATION_002 = readFileSync(new URL('../modules/market-watch/migrations/market_watch_002_run.sql', import.meta.url), 'utf8');
+const MIGRATION_004 = readFileSync(new URL('../modules/market-watch/migrations/market_watch_004_entry_corrections.sql', import.meta.url), 'utf8');
 
 const pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
 try {
@@ -60,6 +63,8 @@ const withTx = async (fn) => {
 
 async function cleanup() {
   await q(`DELETE FROM market_watch_proposals WHERE project = $1`, [P]).catch(() => {});
+  await q(`DELETE FROM market_watch_log_entries WHERE item_id IN (SELECT id FROM market_watch_items WHERE project = $1)`, [P]).catch(() => {});
+  await q(`DELETE FROM market_watch_runs WHERE project = $1`, [P]).catch(() => {});
   await q(`DELETE FROM market_watch_items WHERE project = $1`, [P]).catch(() => {});
   await q(`DELETE FROM market_watch_rule_versions WHERE project = $1`, [P]).catch(() => {});
   await q(`DELETE FROM builders WHERE id = ANY($1::bigint[])`, [[OWNER, ADA]]).catch(() => {});
@@ -73,6 +78,7 @@ async function check(name, fn) {
 try {
   await q(MIGRATION);
   await q(MIGRATION_002);
+  await q(MIGRATION_004);
   await cleanup();
   await insertTestBuilders(pool, [{ id: OWNER, login: 't1004941-owner' }, { id: ADA, login: 't1004941-ada' }]);
   const r = seed.RULES_V1;
@@ -112,6 +118,42 @@ try {
     assert.deepEqual([it.kind, it.url, it.added_via, String(it.added_by), it.status], ['competitor', 'https://algora.io', 'proposal', String(ADA), 'active']);
   });
 
+  // task 1005016: an approved correct_entry rewrites the entry, keeps who/when/why and
+  // the old text on the proposal, and the case file reads the correction; a wrong flag
+  // leaves the text and reads as marked wrong.
+  await check('an approved correct_entry corrects the log entry, and the case file shows it', async () => {
+    const { rows: [it] } = await q(`SELECT id FROM market_watch_items WHERE project = $1 AND name = 'Algora'`, [P]);
+    const { rows: [run] } = await q(`INSERT INTO market_watch_runs (project, status, trigger) VALUES ($1, 'done', 'manual') RETURNING id`, [P]);
+    const { rows: [e1] } = await q(`INSERT INTO market_watch_log_entries (item_id, run_id, type, takeaway, source_url, confidence)
+                                    VALUES ($1, $2, 'news', 'Algora raised a Series B.', 'https://algora.io/blog', 2) RETURNING id`, [it.id, run.id]);
+    const { rows: [e2] } = await q(`INSERT INTO market_watch_log_entries (item_id, run_id, type, takeaway, source_url, confidence)
+                                    VALUES ($1, $2, 'news', 'Algora shut down.', 'https://algora.io/x', 1) RETURNING id`, [it.id, run.id]);
+    const file = async (body) => {
+      const n = pages.normalizeProposal({ kind: 'correct_entry', item_id: it.id, ...body }, { item: { id: Number(it.id), kind: 'competitor' } });
+      assert.equal(n.ok, true, JSON.stringify(n));
+      return pages.insertProposal(pool, { project: P, proposal: n.value, builderId: ADA });
+    };
+    const fix = await file({ log_entry_id: String(e1.id), takeaway: 'Algora raised a seed round, not a Series B.', reason: 'their post says seed' });
+    const out = await proposals.decideProposal({ project: P, id: fix.id, decision: 'approve', decidedBy: OWNER, withTx });
+    assert.deepEqual([out.ok, out.status], [true, 'applied'], JSON.stringify(out));
+    const { rows: [e] } = await q(`SELECT takeaway FROM market_watch_log_entries WHERE id = $1`, [e1.id]);
+    assert.equal(e.takeaway, 'Algora raised a seed round, not a Series B.');
+    const { rows: [p] } = await q(`SELECT status, proposed_by, decided_by, decided_at, reason, payload FROM market_watch_proposals WHERE id = $1`, [fix.id]);
+    assert.deepEqual([p.status, String(p.proposed_by), String(p.decided_by), p.reason, p.payload.was],
+      ['applied', String(ADA), String(OWNER), 'their post says seed', 'Algora raised a Series B.']);
+    assert.ok(p.decided_at instanceof Date);
+    const wrong = await file({ log_entry_id: String(e2.id), wrong: true, reason: 'they are still running' });
+    assert.equal((await proposals.decideProposal({ project: P, id: wrong.id, decision: 'approve', decidedBy: OWNER, withTx })).status, 'applied');
+    const cf = await db.caseFile(pool, { project: P, itemId: it.id });
+    const byId = new Map(cf.map((x) => [String(x.id), x]));
+    assert.equal(byId.get(String(e1.id)).correction_reason, 'their post says seed');
+    assert.equal(byId.get(String(e1.id)).marked_wrong, false);
+    assert.equal(byId.get(String(e2.id)).marked_wrong, true);
+    assert.equal(byId.get(String(e2.id)).takeaway, 'Algora shut down.', 'a wrong entry keeps its text');
+    const shaped = pages.shapeItem({ item: { id: it.id }, entries: cf, history: {}, rules: null });
+    assert.equal(shaped.entries.find((x) => x.id === Number(e2.id)).corrected.wrong, true);
+  });
+
   await check('the page read runs on the real schema', async () => {
     await proposals.createProposal(pool, { project: P, step: 'brief', change: { op: 'set', text: 'Write five lines.' }, reason: 'shorter', proposedBy: ADA });
     const page = await view.readView(pool, { project: P, decide: { mode: 'owner' }, pricing, model: research.MODEL });

package/tests/nav_permission_atoms.mjs

@@ -94,7 +94,7 @@ test('the hall-preview fixture carries every atom /me resolves', () => {
 // "Upgraded to core X" notice after a move; task 1004826: Standing is Accomplishments;
 // task 1004846: the new logo (its bump landed late, in task 1004852); task 1004938: the
 // Market Watch settings nav item and its fuel glyph.
-const SHELL_SHA = 'b89fd877947ae9f8';
+const SHELL_SHA = '1a23b1cf13567eff';
 
 test('shell.js has not changed without its cache-bust being bumped', () => {
   const actual = crypto.createHash('sha256').update(SHELL).digest('hex').slice(0, 16);

package/tests/pay_terms.mjs

@@ -23,6 +23,14 @@ let statements = [];
 const query = async (sql, params = []) => {
   statements.push(sql);
   if (/^\s*(BEGIN|COMMIT|ROLLBACK)/i.test(sql)) return { rows: [] };
+  if (/FROM lifecycle_pay_type_gates/.test(sql)) {
+    // task 1004991: these cases are about the terms, so every gate reads as cleared;
+    // tests/pay_type_gates.mjs is where an open gate refuses.
+    const gates = require('../modules/lifecycle/pay-type-gates.js');
+    const at = new Date(Date.UTC(2026, 9, 30));
+    return { rows: params[0].flatMap((pay_type) => gates.requirementIds(pay_type).map((requirement) => (
+      { pay_type, requirement, state: 'cleared', evidence_ref: 'test', decided_by: 1, decided_at: at }))) };
+  }
   if (/INSERT INTO lifecycle_pay_term_sets/.test(sql)) {
     const row = { id: sets.length + 1, task_id: params[0], set_by: params[1], set_at: new Date(Date.UTC(2026, 9, 30, 0, sets.length)) };
     sets.push(row);

package/tests/pay_type_gates.mjs

@@ -0,0 +1,234 @@
+// tests/pay_type_gates.mjs — a pay type can be put on a task only after its gate is
+// cleared for the project (task 1004991, goal 1000092; ADR 0385 "Pay-type gates").
+//
+// What is real: modules/lifecycle/pay-type-gates.js (the list, the verdict, the checker,
+// the writer), the pay-type-gates router, the lifecycle tasks router (PATCH /tasks/:id)
+// and the project-settings router (the standing terms). What is faked: the caller
+// (requireBuilder, requireRank, requirePermission) and Postgres, a recording stand-in
+// holding the gate history and the pay-term sets in memory.
+//
+// Run:  node tests/pay_type_gates.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+process.env.NODE_ENV = 'test';
+
+let gateRows = [];
+let sets = [];
+let terms = [];
+const query = async (sql, params = []) => {
+  if (/^\s*(BEGIN|COMMIT|ROLLBACK)/i.test(sql)) return { rows: [] };
+  if (/INSERT INTO lifecycle_pay_type_gates/.test(sql)) {
+    const [pay_type, requirement, state, evidence_ref, decided_by] = params;
+    gateRows.push({ id: gateRows.length + 1, pay_type, requirement, state, evidence_ref, decided_by, decided_at: new Date(Date.UTC(2026, 9, 30, 0, gateRows.length)) });
+    return { rows: [] };
+  }
+  if (/FROM lifecycle_pay_type_gates/.test(sql)) {
+    const newest = new Map();
+    for (const r of gateRows.filter((x) => params[0].includes(x.pay_type))) newest.set(`${r.pay_type}/${r.requirement}`, r);
+    return { rows: [...newest.values()] };
+  }
+  if (/INSERT INTO lifecycle_pay_term_sets/.test(sql)) {
+    const row = { id: sets.length + 1, task_id: params[0], set_by: params[1], set_at: new Date() };
+    sets.push(row);
+    return { rows: [row] };
+  }
+  if (/INSERT INTO lifecycle_pay_terms/.test(sql)) {
+    params[1].forEach((pay_type, i) => terms.push({ set_id: params[0], pay_type, position: i }));
+    return { rows: [] };
+  }
+  if (/FROM lifecycle_pay_term_sets s LEFT JOIN builders/.test(sql)) return { rows: [] };
+  return { rows: [] };
+};
+const pool = { query, connect: async () => ({ query, release() {} }) };
+const poolPath = require.resolve('../src/bongos/pool.js');
+require.cache[poolPath] = { id: poolPath, filename: poolPath, loaded: true, exports: { pool } };
+
+let caller = { id: 7, rank: 'archon' };
+let held = [];
+const api = require('../src/module-api.js');
+const set = (k, v) => Object.defineProperty(api, k, { value: v, configurable: true, writable: true });
+set('requireBuilder', (req, _res, next) => { req.builder = { ...caller }; next(); });
+set('requireRank', (rank) => (req, res, next) => (req.builder.rank === rank ? next() : res.fail('rank_forbidden', { status: 403, message: `needs ${rank}` })));
+set('requirePermission', (atom) => (req, res, next) => (held.includes(atom) ? next() : res.fail('permission_denied', { status: 403, message: `needs ${atom}` })));
+set('requireActAlone', () => (_req, _res, next) => next());
+set('withTx', async (fn) => fn({ query }));
+
+const db = require('../modules/lifecycle/db.js');
+const TASK = { id: 5150, title: 'a task', status: 'ready', version_id: 'BONGOS-V2' };
+db.getTask = async (id) => (Number(id) === TASK.id ? { ...TASK } : null);
+db.getTaskDependencies = async () => [];
+db.getTaskDependents = async () => [];
+
+const lib = require('../modules/lifecycle/pay-type-gates.js');
+const payTerms = require('../modules/lifecycle/pay-terms.js');
+
+const express = require('express');
+const app = express();
+app.use(express.json());
+app.use((req, res, next) => {
+  res.fail = (code, o) => {
+    const opts = typeof o === 'number' ? { status: o } : (o || {});
+    return res.status(opts.status || 400).json({ error: code, message: opts.message });
+  };
+  next();
+});
+app.use('/api', require('../modules/lifecycle/routes/tasks.js')());
+app.use('/api', require('../modules/lifecycle/routes/project-settings.js')());
+app.use('/api', require('../modules/lifecycle/routes/pay-type-gates.js')());
+const server = app.listen(0);
+await new Promise((r) => server.once('listening', r));
+const base = `http://127.0.0.1:${server.address().port}/api`;
+const call = async (method, path, body) => {
+  const r = await fetch(base + path, { method, headers: { 'content-type': 'application/json' }, body: body ? JSON.stringify(body) : undefined });
+  return { status: r.status, body: await r.json().catch(() => null) };
+};
+const reset = () => { gateRows = []; sets = []; terms = []; held = ['task.edit', 'project.settings.manage', 'payout.approve']; caller = { id: 7, rank: 'archon' }; };
+const clear = (payType) => Promise.all(lib.requirementIds(payType).map((requirement) => call('PUT', `/pay-type-gates/${payType}/${requirement}`,
+  requirement === lib.ACKNOWLEDGEMENT ? { state: 'cleared', acknowledged: true } : { state: 'cleared', evidence_ref: `doc for ${requirement}` })));
+
+let passed = 0;
+let failed = 0;
+async function t(name, fn) {
+  reset();
+  try { await fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.stack}`); }
+}
+
+console.log('pay-type gates (task 1004991):');
+
+await t('every pay type a term can carry has a requirement list, and nothing else does', () => {
+  assert.deepEqual(Object.keys(lib.REQUIREMENTS).sort(), [...payTerms.PAY_TYPES].sort());
+  for (const p of payTerms.PAY_TYPES) assert.ok(lib.requirementIds(p).length > 0, `${p} has requirements`);
+  assert.deepEqual(lib.requirementIds('self_managed'), ['bongos_moves_and_guarantees_nothing']);
+  assert.ok(!('eu_labour' in lib.REQUIREMENTS), 'eu_labour has no list to clear');
+});
+
+await t('a pay term whose gate is not cleared is refused, and nothing is written', async () => {
+  const r = await call('PATCH', `/tasks/${TASK.id}`, { pay_terms: [{ pay_type: 'cash', amount: '500', unit: 'USD' }] });
+  assert.equal(r.status, 409);
+  assert.equal(r.body.error, 'pay_type_gate_not_cleared');
+  assert.match(r.body.message, /processor_onboarding/);
+  assert.deepEqual([sets.length, terms.length], [0, 0]);
+});
+
+await t('the project\'s standing terms obey the same gate', async () => {
+  const r = await call('PATCH', '/project-settings/pay-terms', { terms: [{ pay_type: 'equity' }] });
+  assert.equal(r.status, 409);
+  assert.equal(r.body.error, 'pay_type_gate_not_cleared');
+  assert.equal(sets.length, 0);
+});
+
+await t('a half-cleared gate still refuses; the last requirement opens it', async () => {
+  const [first, ...rest] = lib.requirementIds('cash');
+  assert.equal((await call('PUT', `/pay-type-gates/cash/${first}`, { state: 'cleared', evidence_ref: 'processor verdict 41' })).status, 200);
+  let r = await call('PATCH', `/tasks/${TASK.id}`, { pay_terms: [{ pay_type: 'cash' }] });
+  assert.equal(r.status, 409);
+  for (const req of rest) await call('PUT', `/pay-type-gates/cash/${req}`, { state: 'cleared', evidence_ref: 'on file' });
+  r = await call('PATCH', `/tasks/${TASK.id}`, { pay_terms: [{ pay_type: 'cash', amount: '500', unit: 'USD' }] });
+  assert.equal(r.status, 200);
+  assert.equal(terms.length, 1);
+});
+
+await t('revoking a requirement closes the gate again', async () => {
+  await clear('cash');
+  const req = lib.requirementIds('cash')[0];
+  assert.equal((await call('PUT', `/pay-type-gates/cash/${req}`, { state: 'revoked', evidence_ref: 'processor paused us' })).status, 200);
+  const r = await call('PATCH', `/tasks/${TASK.id}`, { pay_terms: [{ pay_type: 'cash' }] });
+  assert.equal(r.status, 409);
+});
+
+await t('self_managed clears with only the acknowledgement', async () => {
+  const req = lib.ACKNOWLEDGEMENT;
+  let r = await call('PUT', `/pay-type-gates/self_managed/${req}`, { state: 'cleared', evidence_ref: 'anything' });
+  assert.equal(r.status, 400, 'evidence alone is not the acknowledgement');
+  r = await call('PUT', `/pay-type-gates/self_managed/${req}`, { state: 'cleared', acknowledged: true });
+  assert.equal(r.status, 200);
+  assert.equal(r.body.gate.cleared, true);
+  assert.equal(r.body.gate.requirements[0].evidence_ref, payTerms.SELF_MANAGED_LABEL, 'the label is what was acknowledged');
+  const t1 = await call('PATCH', `/tasks/${TASK.id}`, { pay_terms: [{ pay_type: 'self_managed' }] });
+  assert.equal(t1.status, 200);
+});
+
+await t('eu_labour can never be cleared, by any route, and never reaches a term', async () => {
+  const w = await call('PUT', '/pay-type-gates/eu_labour/anything', { state: 'cleared', evidence_ref: 'counsel says so' });
+  assert.equal(w.status, 409);
+  assert.equal(w.body.error, 'pay_type_never_clearable');
+  assert.equal(gateRows.length, 0, 'no row written');
+  const p = await call('PATCH', `/tasks/${TASK.id}`, { pay_terms: [{ pay_type: 'eu_labour' }] });
+  assert.equal(p.status, 400);
+  assert.equal(sets.length, 0);
+  const all = (await call('GET', '/pay-type-gates')).body.gates.find((g) => g.pay_type === 'eu_labour');
+  assert.deepEqual([all.cleared, all.never], [false, true]);
+  assert.deepEqual(lib.gateVerdict('eu_labour', [{ pay_type: 'eu_labour', requirement: 'x', state: 'cleared' }]).cleared, false);
+});
+
+await t('a forged client request that claims a cleared gate is refused', async () => {
+  for (const forged of [
+    { pay_type: 'cash', gate_cleared: true },
+    { pay_type: 'cash', cleared: true, cleared_by: 7 },
+    { pay_type: 'cash', gate: { state: 'cleared' } },
+  ]) {
+    const r = await call('PATCH', `/tasks/${TASK.id}`, { pay_terms: [forged] });
+    assert.equal(r.status, 400, JSON.stringify(forged));
+  }
+  const top = await call('PATCH', `/tasks/${TASK.id}`, { gate_cleared: true, pay_terms: [{ pay_type: 'cash' }] });
+  assert.ok(top.status >= 400, 'a top-level claim does not open it either');
+  assert.deepEqual([sets.length, terms.length, gateRows.length], [0, 0, 0]);
+});
+
+await t('only the owner records a requirement, and who recorded it is the caller, not the body', async () => {
+  const req = lib.requirementIds('cash')[0];
+  caller = { id: 9, rank: 'metic' }; held = held.filter((a) => a !== 'payout.approve');
+  let r = await call('PUT', `/pay-type-gates/cash/${req}`, { state: 'cleared', evidence_ref: 'x' });
+  assert.equal(r.status, 403);
+  assert.equal(gateRows.length, 0);
+  caller = { id: 7, rank: 'archon' }; held = [...held, 'payout.approve'];
+  r = await call('PUT', `/pay-type-gates/cash/${req}`, { state: 'cleared', evidence_ref: 'x', decided_by: 99 });
+  assert.equal(r.status, 400, 'a recorder in the body is refused');
+  r = await call('PUT', `/pay-type-gates/cash/${req}`, { state: 'cleared', evidence_ref: 'x' });
+  assert.equal(r.status, 200);
+  assert.equal(gateRows[0].decided_by, 7);
+  assert.equal(r.body.gate.requirements[0].cleared_by, 7);
+});
+
+await t('a non-owner sees met or missing, never the evidence or who cleared it', async () => {
+  await clear('cash');
+  const owner = (await call('GET', '/pay-type-gates')).body.gates.find((g) => g.pay_type === 'cash');
+  assert.ok(owner.requirements[0].evidence_ref && owner.requirements[0].cleared_by, 'the owner sees both');
+  caller = { id: 9, rank: 'metic' }; held = held.filter((a) => a !== 'payout.approve');
+  const other = (await call('GET', '/pay-type-gates')).body.gates.find((g) => g.pay_type === 'cash');
+  assert.equal(other.cleared, true);
+  for (const r of other.requirements) {
+    assert.equal(r.met, true);
+    assert.ok(!('evidence_ref' in r) && !('cleared_by' in r) && !('cleared_at' in r));
+  }
+});
+
+await t('a write needs a known requirement, a state and evidence', async () => {
+  const req = lib.requirementIds('cash')[0];
+  assert.equal((await call('PUT', '/pay-type-gates/wages/x', { state: 'cleared', evidence_ref: 'x' })).status, 404);
+  assert.equal((await call('PUT', '/pay-type-gates/cash/not_a_requirement', { state: 'cleared', evidence_ref: 'x' })).status, 404);
+  assert.equal((await call('PUT', `/pay-type-gates/cash/${req}`, { state: 'maybe', evidence_ref: 'x' })).status, 400);
+  assert.equal((await call('PUT', `/pay-type-gates/cash/${req}`, { state: 'cleared', evidence_ref: '   ' })).status, 400);
+  assert.equal((await call('PUT', `/pay-type-gates/cash/${req}`, { state: 'cleared', evidence_ref: 'x'.repeat(501) })).status, 400);
+  assert.equal(gateRows.length, 0);
+});
+
+await t('a stray row for a requirement not on the list cannot clear a gate', () => {
+  const rows = [{ pay_type: 'cash', requirement: 'made_up', state: 'cleared', evidence_ref: 'x', decided_by: 1, decided_at: new Date() }];
+  assert.equal(lib.gateVerdict('cash', rows).cleared, false);
+});
+
+await t('no terms means no gate read; clearing every type then lets a mixed list through', async () => {
+  const r0 = await call('PATCH', `/tasks/${TASK.id}`, { pay_terms: [] });
+  assert.equal(r0.status, 200);
+  for (const p of payTerms.PAY_TYPES) await clear(p);
+  const all = await call('PATCH', `/tasks/${TASK.id}`, { pay_terms: payTerms.PAY_TYPES.map((pay_type) => ({ pay_type })) });
+  assert.equal(all.status, 200);
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+server.close();
+process.exit(failed ? 1 : 0);

package/tests/pay_type_gates_db.mjs

@@ -0,0 +1,84 @@
+// tests/pay_type_gates_db.mjs — task 1004991 (ADR 0385 "Pay-type gates"). Real DB.
+// The gate table built from the real migration (lifecycle_019) in a throwaway schema,
+// written and read through the real modules/lifecycle/pay-type-gates.js, proving the
+// DATABASE holds the rules the DB-free tests/pay_type_gates.mjs assumes: the history
+// cannot be edited or deleted, a row for eu_labour or an unknown type is refused, a
+// state or evidence the writer would never send is refused, and the read SQL resolves
+// the newest record per requirement into a verdict.
+// Self-skips without a reachable Postgres.
+// Run:  DATABASE_URL=... node tests/pay_type_gates_db.mjs
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { strict as assert } from 'node:assert';
+const require = createRequire(import.meta.url);
+const { Pool } = require('pg');
+const here = dirname(fileURLToPath(import.meta.url));
+
+const pgPool = new Pool({ connectionString: process.env.DATABASE_URL || undefined, max: 1 });
+let client;
+try { client = await pgPool.connect(); } catch (e) {
+  console.log(`pay_type_gates_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pgPool.end().catch(() => {});
+  process.exit(0);
+}
+const SCHEMA = `t1004991_${process.pid}`;
+let pass = 0;
+const ok = (c, m) => { assert.ok(c, m); pass++; console.log(`  ok - ${m}`); };
+const refused = async (sql, params, m) => {
+  await client.query('SAVEPOINT s');
+  let threw = false;
+  try { await client.query(sql, params); } catch { threw = true; }
+  await client.query('ROLLBACK TO SAVEPOINT s');
+  ok(threw, m);
+};
+
+try {
+  await client.query(`CREATE SCHEMA ${SCHEMA}`);
+  await client.query(`SET search_path TO ${SCHEMA}`);
+  await client.query('CREATE TABLE builders (id bigserial PRIMARY KEY, github_login text NOT NULL)');
+  await client.query(readFileSync(join(here, '..', 'modules', 'lifecycle', 'migrations', 'lifecycle_019_pay_type_gates.sql'), 'utf8'));
+  await client.query("INSERT INTO builders (github_login) VALUES ('owner'), ('lead')");
+  await client.query('BEGIN');
+
+  const lib = require('../modules/lifecycle/pay-type-gates.js');
+  const o = { db: client };
+  const rec = (payType, requirement, state, evidenceRef, builderId = 1) =>
+    lib.recordRequirement({ payType, requirement, state, evidenceRef, builderId }, o);
+
+  let v = await rec('self_managed', lib.ACKNOWLEDGEMENT, 'cleared', 'acknowledged');
+  ok(v.cleared === true && Number(v.requirements[0].cleared_by) === 1, 'the one self-managed requirement clears its gate, naming who cleared it');
+
+  for (const req of lib.requirementIds('cash')) v = await rec('cash', req, 'cleared', `ref ${req}`, 2);
+  ok(v.cleared === true, 'every cash requirement cleared opens the gate');
+  v = await rec('cash', 'tax_details', 'revoked', 'details withdrawn');
+  ok(v.cleared === false && v.missing.join() === 'tax_details', 'the newest record per requirement wins: a revoke closes it again');
+  v = await rec('cash', 'tax_details', 'cleared', 'collected again');
+  ok(v.cleared === true, 'a later clearing reopens it');
+
+  const refusal = await lib.refuseUnclearedGates([{ pay_type: 'equity' }, { pay_type: 'cash' }], o);
+  ok(refusal && refusal.pay_type === 'equity', 'the checker names the first type whose gate is open');
+  ok((await lib.refuseUnclearedGates([{ pay_type: 'cash' }, { pay_type: 'self_managed' }], o)) === null, 'cleared types pass');
+
+  const all = await lib.readGates(o);
+  ok(all.length === 7 && all.find((g) => g.pay_type === 'eu_labour').never === true, 'the owner view lists eu_labour as never clearable');
+
+  const { rows: [aRow] } = await client.query('SELECT id FROM lifecycle_pay_type_gates LIMIT 1');
+  await refused('UPDATE lifecycle_pay_type_gates SET state = $1 WHERE id = $2', ['revoked', aRow.id], 'a record cannot be edited');
+  await refused('DELETE FROM lifecycle_pay_type_gates WHERE id = $1', [aRow.id], 'a record cannot be deleted');
+  await refused("INSERT INTO lifecycle_pay_type_gates (pay_type, requirement, state, evidence_ref, decided_by) VALUES ('eu_labour', 'x', 'cleared', 'y', 1)", [], 'the database refuses any row for eu_labour');
+  await refused("INSERT INTO lifecycle_pay_type_gates (pay_type, requirement, state, evidence_ref, decided_by) VALUES ('wages', 'x', 'cleared', 'y', 1)", [], 'an unknown pay type is refused');
+  await refused("INSERT INTO lifecycle_pay_type_gates (pay_type, requirement, state, evidence_ref, decided_by) VALUES ('cash', 'x', 'pending', 'y', 1)", [], 'a state other than cleared or revoked is refused');
+  await refused("INSERT INTO lifecycle_pay_type_gates (pay_type, requirement, state, evidence_ref, decided_by) VALUES ('cash', 'x', 'cleared', '', 1)", [], 'a record with no evidence reference is refused');
+  await refused("INSERT INTO lifecycle_pay_type_gates (pay_type, requirement, state, evidence_ref, decided_by) VALUES ('cash', 'x', 'cleared', 'y', 999)", [], 'a recorder who is not a builder is refused');
+
+  await client.query('ROLLBACK');
+  console.log(`pay_type_gates_db: ${pass} passed`);
+} finally {
+  await client.query('ROLLBACK').catch(() => {});
+  await client.query('SET search_path TO public').catch(() => {});
+  await client.query(`DROP SCHEMA IF EXISTS ${SCHEMA} CASCADE`).catch(() => {});
+  client.release();
+  await pgPool.end();
+}