@bongos/core 1.24.10 → 1.24.11

package/tests/pay_terms.mjs

@@ -0,0 +1,254 @@
+// tests/pay_terms.mjs — a task carries the project's own pay terms, and a builder
+// sees them before claiming (task 1004990, goal 1000092; ADR 0385 decision 3).
+//
+// What is real: modules/lifecycle/pay-terms.js (the checker, the writer, the
+// reads), the lifecycle tasks router (PATCH /tasks/:id, GET /tasks/:id,
+// GET /pay-terms), the project-settings router (PATCH /project-settings/pay-terms
+// and the settings row), and `bongos start`'s pay line. What is faked: the caller
+// (requireBuilder), the permission check — keyed on the ATOM each route asks for,
+// so a case can withhold exactly that one — and Postgres, a recording stand-in
+// that keeps the pay_term_sets / pay_terms history in memory.
+//
+// Run:  node tests/pay_terms.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+process.env.NODE_ENV = 'test';
+
+// ── the stand-in Postgres: a history of sets, nothing ever updated ────────────
+let sets = [];
+let terms = [];
+let statements = [];
+const query = async (sql, params = []) => {
+  statements.push(sql);
+  if (/^\s*(BEGIN|COMMIT|ROLLBACK)/i.test(sql)) return { rows: [] };
+  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);
+    return { rows: [row] };
+  }
+  if (/INSERT INTO lifecycle_pay_terms/.test(sql)) {
+    // The writer sends one statement of parallel arrays (unnest WITH ORDINALITY).
+    const [set_id, types, amounts, units, notes] = params;
+    types.forEach((pay_type, i) => terms.push({ set_id, position: i, pay_type, amount: amounts[i], unit: units[i], note: notes[i] }));
+    return { rows: [] };
+  }
+  if (/FROM lifecycle_pay_term_sets s LEFT JOIN builders/.test(sql)) {
+    const rows = sets.filter((s) => s.task_id == null).sort((a, b) => b.id - a.id)
+      .slice(0, params[0]).map((s) => ({ ...s, set_by_login: 'owner' }));
+    return { rows };
+  }
+  if (/FROM lifecycle_pay_term_sets/.test(sql)) {
+    const ids = params[0].map(String);
+    const want = sets.filter((s) => s.task_id == null || ids.includes(String(s.task_id)));
+    const newest = new Map();
+    for (const s of want) newest.set(String(s.task_id), s); // ids ascend, so the last is newest
+    return { rows: [...newest.values()] };
+  }
+  if (/FROM lifecycle_pay_terms/.test(sql)) {
+    const ids = params[0].map(String);
+    return { rows: terms.filter((t) => ids.includes(String(t.set_id))).sort((a, b) => a.set_id - b.set_id || a.position - b.position) };
+  }
+  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 } };
+
+// ── the doorway: the caller, and a permission check keyed on the atom ─────────
+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 = { id: 7, rank: 'metic' }; next(); });
+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-terms.js');
+const start = require('../scripts/bongos/start.js');
+
+const express = require('express');
+const app = express();
+app.use(express.json());
+app.use((req, res, next) => {
+  res.fail = (code, statusOrOpts) => {
+    const o = typeof statusOrOpts === 'number' ? { status: statusOrOpts } : (statusOrOpts || {});
+    return res.status(o.status || 400).json({ error: code, message: o.message });
+  };
+  next();
+});
+app.use('/api', require('../modules/lifecycle/routes/tasks.js')());
+app.use('/api', require('../modules/lifecycle/routes/project-settings.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 = () => { sets = []; terms = []; statements = []; held = []; };
+
+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 terms (task 1004990):');
+
+await t('the checker takes exactly the six types, zero or more, and fills nothing in', () => {
+  assert.deepEqual(lib.PAY_TYPES, ['cash', 'equity', 'module_share', 'credit_pool', 'non_monetary', 'self_managed']);
+  assert.deepEqual(lib.normalizePayTerms([]), { terms: [] }, 'zero terms is a real answer');
+  const all = lib.normalizePayTerms(lib.PAY_TYPES.map((p) => ({ pay_type: p })));
+  assert.equal(all.terms.length, 6);
+  for (const term of all.terms) {
+    assert.deepEqual([term.amount, term.unit, term.note], [null, null, null], `${term.pay_type}: nothing stated stays nothing — no default amount`);
+  }
+  const stated = lib.normalizePayTerms([{ pay_type: 'cash', amount: ' 500 ', unit: 'USD', note: '' }]).terms[0];
+  assert.deepEqual(stated, { pay_type: 'cash', amount: '500', unit: 'USD', note: null }, 'the project\'s words, trimmed, never converted');
+  for (const bad of [null, {}, 'cash', [{ pay_type: 'eu_labour' }], [{ pay_type: 'cash', amount: 500 }],
+    [{ pay_type: 'cash', rate: '1' }], [{}], new Array(11).fill({ pay_type: 'cash' }), [{ pay_type: 'cash', note: 'x'.repeat(501) }]]) {
+    assert.ok(lib.normalizePayTerms(bad).error, `refused: ${JSON.stringify(bad).slice(0, 60)}`);
+  }
+});
+
+await t('a self-managed term always carries the "Bongos does not move or guarantee" label', () => {
+  assert.equal(lib.SELF_MANAGED_LABEL, 'Paid by the project on its own systems. Bongos does not move or guarantee this money.');
+  assert.equal(lib.displayTerm({ pay_type: 'self_managed' }).label, lib.SELF_MANAGED_LABEL);
+  for (const p of lib.PAY_TYPES.filter((x) => x !== 'self_managed')) assert.equal(lib.displayTerm({ pay_type: p }).label, null);
+});
+
+await t('PATCH /tasks/:id pay_terms: REFUSED without task.edit, and nothing is written', async () => {
+  held = ['project.settings.manage'];
+  const r = await call('PATCH', `/tasks/${TASK.id}`, { pay_terms: [{ pay_type: 'cash', amount: '500', unit: 'USD' }] });
+  assert.equal(r.status, 403);
+  assert.match(r.body.message, /task\.edit/);
+  assert.deepEqual([sets.length, terms.length], [0, 0], 'no set, no term');
+});
+
+await t('PATCH /tasks/:id pay_terms: someone who may edit the task sets them, as a new set in the history', async () => {
+  held = ['task.edit'];
+  const first = await call('PATCH', `/tasks/${TASK.id}`, { pay_terms: [{ pay_type: 'cash', amount: '500', unit: 'USD' }, { pay_type: 'self_managed', note: 'paid monthly' }] });
+  assert.equal(first.status, 200, JSON.stringify(first.body));
+  assert.equal(first.body.task.id, TASK.id);
+  assert.equal(first.body.pay_terms.terms.length, 2);
+  assert.equal(first.body.pay_terms.terms[1].label, lib.SELF_MANAGED_LABEL);
+  const second = await call('PATCH', `/tasks/${TASK.id}`, { pay_terms: [] });
+  assert.equal(second.status, 200);
+  assert.equal(sets.length, 2, 'the old set stays; a change is a new set');
+  assert.ok(sets.every((s) => s.set_by === 7), 'each set names who set it');
+  assert.ok(!statements.some((s) => /UPDATE lifecycle_pay_|DELETE FROM lifecycle_pay_/.test(s)), 'nothing is ever edited or deleted');
+  const bad = await call('PATCH', `/tasks/${TASK.id}`, { pay_terms: [{ pay_type: 'wages' }] });
+  assert.equal(bad.status, 400);
+  assert.equal(bad.body.error, 'bad_pay_terms');
+  const gone = await call('PATCH', '/tasks/999', { pay_terms: [] });
+  assert.equal(gone.status, 404);
+  assert.equal(sets.length, 2, 'a refused or missing task writes nothing');
+});
+
+await t('POST /tasks does not take pay terms: create is task.create, and only an editor sets pay', async () => {
+  held = ['task.create'];
+  const r = await call('POST', '/tasks', { title: 'x', version_id: 'BONGOS-V2', pay_terms: [{ pay_type: 'cash', amount: '1' }] });
+  assert.equal(r.status, 400, JSON.stringify(r.body));
+  assert.equal(r.body.error, 'validation_failed', 'the strict validator refuses the field');
+  // ...and it is the FIELD that is refused: the same body without it gets past validation.
+  const without = await call('POST', '/tasks', { title: 'x', version_id: 'BONGOS-V2' });
+  assert.notEqual(without.body && without.body.error, 'validation_failed', JSON.stringify(without.body));
+  assert.equal(sets.length, 0);
+});
+
+await t('a builder sees the terms BEFORE claiming: GET /pay-terms, the read the hall task page and bongos start make', async () => {
+  held = ['task.edit', 'project.settings.manage'];
+  const one = async () => (await call('GET', `/pay-terms?task_ids=${TASK.id}`)).body.pay_terms[String(TASK.id)];
+  assert.equal((await one()).source, 'none', 'nothing stated anywhere: nothing shown, no amount suggested');
+  // The project's standing terms first, then this task's own.
+  assert.equal((await call('PATCH', '/project-settings/pay-terms', { terms: [{ pay_type: 'equity', note: 'per the project agreement' }] })).status, 200);
+  let read = await one();
+  assert.equal(read.source, 'project', 'a task with none of its own shows the project\'s standing terms');
+  assert.equal(read.terms[0].pay_type, 'equity');
+  await call('PATCH', `/tasks/${TASK.id}`, { pay_terms: [{ pay_type: 'cash', amount: '500', unit: 'USD' }] });
+  read = await one();
+  assert.equal(read.source, 'task');
+  assert.deepEqual(read.terms.map((x) => [x.pay_type, x.amount, x.unit]), [['cash', '500', 'USD']]);
+  // A task the project set to "no pay terms" says so; the standing terms do not paper over it.
+  await call('PATCH', `/tasks/${TASK.id}`, { pay_terms: [] });
+  const list = await call('GET', `/pay-terms?task_ids=${TASK.id},77`);
+  assert.equal(list.status, 200);
+  assert.deepEqual([list.body.pay_terms[String(TASK.id)].source, list.body.pay_terms[String(TASK.id)].terms.length], ['task', 0]);
+  assert.equal(list.body.pay_terms['77'].source, 'project');
+  for (const q of ['', 'x', '1;2', new Array(51).fill(1).join(',')]) {
+    assert.equal((await call('GET', `/pay-terms?task_ids=${q}`)).status, 400, `task_ids=${q.slice(0, 20)}`);
+  }
+});
+
+await t('the project\'s pay policy: changed on the settings page, with who/when kept, REFUSED without the settings atom', async () => {
+  held = ['task.edit'];
+  const refused = await call('PATCH', '/project-settings/pay-terms', { terms: [{ pay_type: 'cash' }] });
+  assert.equal(refused.status, 403);
+  assert.equal(sets.length, 0);
+  held = ['project.settings.manage'];
+  await call('PATCH', '/project-settings/pay-terms', { terms: [{ pay_type: 'cash', amount: '20', unit: 'USD per hour' }] });
+  const second = await call('PATCH', '/project-settings/pay-terms', { terms: [{ pay_type: 'non_monetary', note: 'a mention in the credits' }] });
+  assert.equal(second.status, 200);
+  const row = second.body.row;
+  assert.equal(row.key, 'pay_terms');
+  assert.equal(row.editable, true);
+  assert.equal(row.value.terms[0].pay_type, 'non_monetary', 'the newest set is current');
+  assert.equal(row.value.history.length, 2, 'the audit trail: every change, newest first');
+  assert.deepEqual(row.value.history.map((h) => h.set_by_login), ['owner', 'owner']);
+  assert.ok(row.value.history[0].set_at, 'and when');
+  assert.deepEqual(row.value.types.map((x) => x.type), lib.PAY_TYPES);
+  held = ['project.settings.manage'];
+  const page = await call('GET', '/project-settings');
+  assert.ok(page.body.rows.some((r) => r.key === 'pay_terms'), 'the settings page draws the row');
+});
+
+await t('bongos start shows the pay line, the project\'s words only, with the self-managed label', async () => {
+  const view = {
+    source: 'task',
+    terms: [lib.displayTerm({ pay_type: 'cash', amount: '500', unit: 'USD' }), lib.displayTerm({ pay_type: 'self_managed' })],
+  };
+  const line = start.payTermsLine(view);
+  assert.match(line, /Cash: 500 USD/);
+  assert.match(line, /Paid by the project itself: amount not stated — Paid by the project on its own systems\. Bongos does not move or guarantee this money\./);
+  assert.equal(start.payTermsLine({ source: 'none', terms: [] }), null);
+  assert.match(start.payTermsLine({ source: 'project', terms: [lib.displayTerm({ pay_type: 'equity' })] }), /^project terms · /);
+  // The CLI asks for the whole list in one read, and an older server degrades to no line.
+  const asked = [];
+  const fakeApi = { payTerms: { getPayTerms: async (a) => { asked.push(a); return { ok: true, data: { pay_terms: { 1: view } } }; } } };
+  const rows = await start.withPayTerms(fakeApi, [{ id: 1 }, { id: 2 }]);
+  assert.deepEqual(asked, [{ query: { task_ids: '1,2' } }]);
+  assert.equal(rows[0].pay_terms, view);
+  assert.equal(rows[1].pay_terms, undefined);
+  assert.deepEqual(await start.withPayTerms({}, [{ id: 1 }]), [{ id: 1 }], 'no route, no change');
+});
+
+await t('the hall task page draws the terms verbatim and the self-managed label (the real payTermsHtml)', async () => {
+  const fs = require('node:fs');
+  const path = require('node:path');
+  const src = fs.readFileSync(path.join(process.cwd(), 'modules/hall-ui/public/task.js'), 'utf8');
+  const at = src.indexOf('  function payTermsHtml(view) {');
+  const end = src.indexOf('\n  }\n', at);
+  assert.ok(at > 0 && end > at);
+  const esc = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+  const payTermsHtml = new Function('escapeHtml', `${src.slice(at, end + 4)}; return payTermsHtml;`)(esc);
+  const html = payTermsHtml({ source: 'project', terms: [lib.displayTerm({ pay_type: 'self_managed', amount: '<b>9</b>' }), lib.displayTerm({ pay_type: 'cash' })] });
+  assert.match(html, /Paid by the project on its own systems\. Bongos does not move or guarantee this money\./);
+  assert.match(html, /&lt;b&gt;9&lt;\/b&gt;/, 'escaped, verbatim');
+  assert.match(html, /amount not stated/);
+  assert.match(html, /standing terms/);
+  assert.equal(payTermsHtml({ source: 'none', terms: [] }), '', 'nothing stated draws nothing');
+});
+
+server.close();
+console.log(`\npay_terms: ${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);

package/tests/pay_terms_db.mjs

@@ -0,0 +1,86 @@
+// tests/pay_terms_db.mjs — task 1004990 (ADR 0385 D3). Real DB.
+// The pay terms tables built from the real migration (lifecycle_018) in a throwaway
+// schema, written and read through the real modules/lifecycle/pay-terms.js, proving
+// the DATABASE holds the history: an unknown pay type, an over-long amount and a
+// position past ten are refused; any UPDATE or DELETE is refused; and the writer's
+// one-statement insert and the reads' SQL (the newest set per task, the project's standing set, the history with
+// who set it) does what the DB-free tests/pay_terms.mjs assumes.
+// Self-skips without a reachable Postgres.
+// Run:  DATABASE_URL=... node tests/pay_terms_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_terms_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pgPool.end().catch(() => {});
+  process.exit(0);
+}
+const SCHEMA = `t1004990_${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('CREATE TABLE tasks (id bigserial PRIMARY KEY)');
+  await client.query(readFileSync(join(here, '..', 'modules', 'lifecycle', 'migrations', 'lifecycle_018_pay_terms.sql'), 'utf8'));
+  await client.query("INSERT INTO builders (github_login) VALUES ('owner'), ('lead')");
+  await client.query('INSERT INTO tasks DEFAULT VALUES'); // 1
+  await client.query('INSERT INTO tasks DEFAULT VALUES'); // 2
+  await client.query('BEGIN');
+
+  const lib = require('../modules/lifecycle/pay-terms.js');
+  const o = { db: client };
+  const norm = (list) => lib.normalizePayTerms(list).terms;
+
+  await lib.setPayTerms({ taskId: null, terms: norm([{ pay_type: 'equity', note: 'per the agreement' }]), builderId: 1 }, o);
+  await lib.setPayTerms({ taskId: 1, terms: norm([{ pay_type: 'cash', amount: '500', unit: 'USD' }, { pay_type: 'self_managed' }]), builderId: 2 }, o);
+  let map = await lib.readPayTerms([1, 2], o);
+  ok(map.get('1').source === 'task' && map.get('1').terms.length === 2, 'a task reads its own newest set, in order');
+  ok(map.get('1').terms[1].label === lib.SELF_MANAGED_LABEL, 'the self-managed term carries its label');
+  ok(map.get('2').source === 'project' && map.get('2').terms[0].pay_type === 'equity', 'a task with none reads the standing terms');
+  await lib.setPayTerms({ taskId: 1, terms: [], builderId: 1 }, o);
+  map = await lib.readPayTerms([1], o);
+  ok(map.get('1').source === 'task' && map.get('1').terms.length === 0, 'an empty newest set means "no pay terms", not the standing ones');
+  const policy = await lib.readProjectPayTerms(o);
+  ok(policy.history.length === 1 && policy.history[0].set_by_login === 'owner', 'the history names who set the project terms');
+
+  const { rows: [aTerm] } = await client.query('SELECT id FROM lifecycle_pay_terms LIMIT 1');
+  const { rows: [aSet] } = await client.query('SELECT id FROM lifecycle_pay_term_sets LIMIT 1');
+  await refused('UPDATE lifecycle_pay_terms SET amount = $1 WHERE id = $2', ['9999', aTerm.id], 'a term cannot be edited');
+  await refused('DELETE FROM lifecycle_pay_terms WHERE id = $1', [aTerm.id], 'a term cannot be deleted');
+  await refused('UPDATE lifecycle_pay_term_sets SET set_by = 2 WHERE id = $1', [aSet.id], 'who set a set cannot be rewritten');
+  await refused('DELETE FROM lifecycle_pay_term_sets WHERE id = $1', [aSet.id], 'a set cannot be deleted');
+  await refused("INSERT INTO lifecycle_pay_terms (set_id, position, pay_type) VALUES ($1, 5, 'wages')", [aSet.id], 'an unknown pay type is refused');
+  await refused("INSERT INTO lifecycle_pay_terms (set_id, position, pay_type, amount) VALUES ($1, 6, 'cash', $2)", [aSet.id, 'x'.repeat(65)], 'an amount over 64 characters is refused');
+  await refused("INSERT INTO lifecycle_pay_terms (set_id, position, pay_type) VALUES ($1, 10, 'cash')", [aSet.id], 'an eleventh position is refused');
+  await refused("INSERT INTO lifecycle_pay_terms (set_id, position, pay_type, amount) VALUES ($1, 7, 'cash', '')", [aSet.id], 'an empty amount is refused: absent is NULL, never a blank');
+  const { rows: defaults } = await client.query(
+    "SELECT column_name FROM information_schema.columns WHERE table_schema = $1 AND table_name = 'lifecycle_pay_terms' AND column_default IS NOT NULL AND column_name <> 'id'", [SCHEMA]);
+  ok(defaults.length === 0, 'no pay_terms column has a default: Bongos suggests no amount');
+
+  await client.query('ROLLBACK');
+  console.log(`pay_terms_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();
+}

package/tests/project_settings_page.mjs

@@ -58,7 +58,8 @@ const fakeRes = () => ({
 // the two calls that would reach Postgres are swapped. Stubbing the row builders
 // instead would prove nothing about the shape the page actually receives.
 const WORKING_REWARD = { rewardConfig: () => ({ marginPct: 20, costScale: 1, mode: 'cost-plus-only', perTaskCredit: false, ideatorCredit: true }) };
-function buildRouterWithStubs({ timer, categories, reward = WORKING_REWARD }) {
+const payTerms = require(path.join(ROOT, 'modules', 'lifecycle', 'pay-terms.js'));
+function buildRouterWithStubs({ timer, categories, reward = WORKING_REWARD, payPolicy = { terms: [], history: [] } }) {
   const saved = {
     resolveRotDays: api.resolveRotDays,
     resolveOptional: api.resolveOptional,
@@ -77,6 +78,9 @@ function buildRouterWithStubs({ timer, categories, reward = WORKING_REWARD }) {
   api.resolveOptional = (port) => (port === 'reward' ? rewardPort : null);
   gc.listCategories = async () => categories;
   api.projectSettings.set = async () => ({ key: 'attention.rot_days', value: '45' });
+  // task 1004990: the project's standing pay terms, read from their own table.
+  saved.readPay = payTerms.readProjectPayTerms;
+  payTerms.readProjectPayTerms = async () => (payPolicy instanceof Error ? Promise.reject(payPolicy) : payPolicy);
 
   delete require.cache[require.resolve(path.join(ROOT, 'modules', 'lifecycle', 'routes', 'project-settings.js'))];
   const router = require(path.join(ROOT, 'modules', 'lifecycle', 'routes', 'project-settings.js'))();
@@ -87,6 +91,7 @@ function buildRouterWithStubs({ timer, categories, reward = WORKING_REWARD }) {
     api.projectSettings.set = saved.set;
     api.projectSettings.resolveShipMode = saved.resolveShipMode;
     api.projectSettings.resolveTweakAutopickup = saved.resolveTweak;
+    payTerms.readProjectPayTerms = saved.readPay;
   };
   // The handler is the LAST layer on the matching route (requireBuilder and the
   // permission gate sit in front); calling it directly is what keeps this a unit test
@@ -106,22 +111,36 @@ const CATS = [
   { id: 2, slug: 'retired-thing', label: 'Retired thing', sort_order: 20, active: false },
 ];
 
-test('one read returns all seven fundamentals, each naming where its value came from', async () => {
+test('an unreadable pay terms table degrades that row, named, and the page still draws (task 1004990)', async () => {
+  const { handlerFor, restore } = buildRouterWithStubs({ timer: TIMER_OK, categories: CATS, payPolicy: new Error('pay boom') });
+  try {
+    const res = fakeRes();
+    await handlerFor('get', '/project-settings')({ query: {} }, res);
+    assert.equal(res.statusCode, 200);
+    const pay = res.payload.rows.find((r) => r.key === 'pay_terms');
+    assert.equal(pay.state, 'unavailable');
+    assert.equal(pay.editable, false, 'nothing to edit over a set it could not read');
+    assert.equal(res.payload.rows.length, 8);
+  } finally { restore(); }
+});
+
+test('one read returns all eight fundamentals, each naming where its value came from', async () => {
   const { handlerFor, restore } = buildRouterWithStubs({ timer: TIMER_OK, categories: CATS });
   try {
     const res = fakeRes();
     await handlerFor('get', '/project-settings')({ query: {} }, res);
     const rows = res.payload.rows;
-    assert.equal(rows.length, 7, 'the page draws seven rows, so the read returns seven');
+    assert.equal(rows.length, 8, 'the page draws eight rows, so the read returns eight');
     assert.deepEqual(rows.map((r) => r.key),
-      ['ship_mode', 'tweak_round_cap', 'rot_timer', 'work_categories', 'credit_calculation', 'equity_calculation', 'upmarket_percent']);
+      ['ship_mode', 'tweak_round_cap', 'rot_timer', 'work_categories', 'pay_terms', 'credit_calculation', 'equity_calculation', 'upmarket_percent']);
     // Provenance is the point of the page: every row says where its value came from.
     for (const r of rows) {
       assert.ok(r.reads && r.reads.file, `${r.key} names no file`);
       assert.ok(r.sentence && r.sentence.length > 20, `${r.key} has no readable sentence`);
     }
-    // Four knobs: the criterion's two, ship mode (task 1004628) and the monthly tweak-round cap (task 1005003).
-    assert.deepEqual(rows.filter((r) => r.editable).map((r) => r.key), ['ship_mode', 'tweak_round_cap', 'rot_timer', 'work_categories']);
+    // Five knobs: the criterion's two, ship mode (task 1004628), the monthly tweak-round cap
+    // (task 1005003) and the project's standing pay terms (task 1004990).
+    assert.deepEqual(rows.filter((r) => r.editable).map((r) => r.key), ['ship_mode', 'tweak_round_cap', 'rot_timer', 'work_categories', 'pay_terms']);
     // A no-store receipt: a cached settings read is wrong the moment a knob turns.
     assert.equal(res.headers['Cache-Control'], 'no-store');
   } finally { restore(); }