@bongos/core 1.21.112 → 1.21.114

package/tests/government_treasury.mjs

@@ -0,0 +1,394 @@
+// tests/government_treasury.mjs — THE TREASURY: a pot per goal, the reserve,
+// and the borrow a dry pot asks for (task 1004712, goal 1000111; ADR 0379).
+//
+// What this pins (the task's done-when lines, and the walls behind them):
+//   1. POTS ARE FILLED FROM REAL SPEND. A pot's spend is this month's cost_log
+//      rows on the goal's tasks; its budget is the stored one its holder gave
+//      it; the reserve is last month's real spend no pot was given, less loans.
+//   2. A DRY POT FILES A BORROW ASK. fileBorrows (the poller's one call) files
+//      an open borrow for every dry pot with nothing open and no "no" this
+//      month, and stores its ask in the ask shape on treasury_spending:<id>,
+//      waiting on lead:treasury. The docket carries it at the Treasury, routed
+//      to the Treasury's holder (the owner while it is unseated).
+//   3. THE CAP SETTING EXISTS AND IS OFF. project_settings['treasury.spend_cap_usd'];
+//      no row is off; the treasury says "no spend limit".
+//   4. THE WALLS. Only whoever answers for the Treasury sets a pot (403
+//      not_the_holder); only the seat a borrow waits on answers it (403
+//      not_yours); a borrow is answered once (409, and the trigger); a loan is
+//      never deleted.
+// DB-free: the pool's query is replaced by an in-memory fake that answers the
+// treasury's own statements by name, and refuses any it does not know.
+//
+// Run:  node --test tests/government_treasury.mjs
+
+import { strict as assert } from 'node:assert';
+import { test, after } from 'node:test';
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const GOV = path.join(ROOT, 'modules', 'government');
+const T = require(path.join(GOV, 'treasury.js'));
+const asks = require(path.join(GOV, 'asks.js'));
+const routing = require(path.join(GOV, 'routing.js'));
+const {
+  SETTING_KEYS, MAX_SPEND_CAP_USD, parseSpendCap, resolveSpendCap, setSpendCap, describeSpendCap,
+} = require('../src/bongos/project-settings.js');
+const { pool } = require(path.join(ROOT, 'src', 'bongos', 'pool.js'));
+
+const MIGRATION = fs.readFileSync(path.join(GOV, 'migrations', 'government_031_treasury.sql'), 'utf8');
+const NOW = Date.parse('2026-10-10T12:00:00.000Z'); // day 10 of 31
+
+// ── an in-memory project: goals, tasks' real spend, pots, borrows, asks, settings ──
+function project({ pots = [], borrows = [], cap = null, spend = {}, lastMonth = 0 } = {}) {
+  const st = {
+    goals: [{ id: 1, title: 'Project creation', status: 'open' }, { id: 2, title: 'Maintenance', status: 'open' }, { id: 3, title: 'Old goal', status: 'done' }],
+    pots: pots.map((p) => ({ set_by: null, set_at: '2026-10-01T00:00:00.000Z', ...p })),
+    borrows: borrows.map((b) => ({ ...b })),
+    asks: new Map(),
+    settings: cap == null ? new Map() : new Map([['treasury.spend_cap_usd', String(cap)]]),
+    spend, lastMonth, seq: 100, seen: [],
+  };
+  const q = async (sql, params = []) => {
+    const s = String(sql).replace(/\s+/g, ' ').trim();
+    st.seen.push(s);
+    if (/^SELECT key, value, updated_at, updated_by FROM project_settings WHERE key = \$1/.test(s)) {
+      const v = st.settings.get(params[0]);
+      return { rows: v == null ? [] : [{ key: params[0], value: v, updated_at: null, updated_by: null }] };
+    }
+    if (/^INSERT INTO project_settings/.test(s)) { st.settings.set(params[0], params[1]); return { rows: [{ key: params[0], value: params[1], updated_at: null, updated_by: params[2] }] }; }
+    if (/^DELETE FROM project_settings WHERE key = \$1/.test(s)) { st.settings.delete(params[0]); return { rows: [], rowCount: 1 }; }
+    if (/^SELECT to_char\(recorded_at, 'YYYY-MM'\) AS month/.test(s)) {
+      const thisMonth = Object.values(st.spend).reduce((t, v) => t + v, 0) + 50; // + untasked spend
+      return { rows: [{ month: params[0], total_usd: thisMonth }, ...(st.lastMonth ? [{ month: params[1], total_usd: st.lastMonth }] : [])] };
+    }
+    if (/^SELECT t\.goal_id, COALESCE\(SUM\(cl\.amount_usd\), 0\) AS total_usd FROM cost_log cl JOIN tasks t/.test(s)) {
+      assert.equal(params[0], '2026-10');
+      return { rows: Object.entries(st.spend).map(([goal_id, total_usd]) => ({ goal_id, total_usd })) };
+    }
+    if (/^SELECT goal_id, budget_usd, set_by, set_at FROM government_pots/.test(s)) return { rows: st.pots };
+    if (/^SELECT id, title, status FROM goals WHERE status = 'open'/.test(s)) return { rows: st.goals.filter((g) => g.status === 'open') };
+    if (/^SELECT id, title, status FROM goals WHERE id = \$1/.test(s)) return { rows: st.goals.filter((g) => String(g.id) === String(params[0])) };
+    if (/FROM government_pot_borrows WHERE month = \$1 OR state = 'open'/.test(s)) return { rows: st.borrows.filter((b) => b.month === params[0] || b.state === 'open') };
+    if (/^INSERT INTO government_pot_borrows/.test(s)) {
+      if (st.borrows.some((b) => String(b.goal_id) === String(params[0]) && b.state === 'open')) return { rows: [] };
+      const row = { id: ++st.seq, goal_id: params[0], month: params[1], amount_usd: params[2], budget_usd: params[3], spent_usd: params[4], state: 'open', filed_at: '2026-10-10T12:00:00.000Z', lent_usd: null, answer_key: null };
+      st.borrows.push(row);
+      return { rows: [{ id: row.id }] };
+    }
+    if (/^INSERT INTO government_asks/.test(s)) {
+      const row = { matter_id: params[0], question: params[1], options: JSON.parse(params[2]), recommend_key: params[3], recommend_why: params[4], waits_on: params[5], if_nobody_answers: params[6], detail: params[7], written_at: null };
+      st.asks.set(params[0], row);
+      return { rows: [row] };
+    }
+    if (/FROM government_asks WHERE matter_id = ANY/.test(s)) return { rows: params[0].map((id) => st.asks.get(id)).filter(Boolean) };
+    if (/FROM government_pot_borrows b JOIN goals g ON g\.id = b\.goal_id WHERE b\.state = 'open'/.test(s)) {
+      return { rows: st.borrows.filter((b) => b.state === 'open').map((b) => ({ ...b, title: st.goals.find((g) => String(g.id) === String(b.goal_id)).title })) };
+    }
+    if (/FROM government_pot_borrows b JOIN goals g ON g\.id = b\.goal_id WHERE b\.id = \$1/.test(s)) {
+      const b = st.borrows.find((x) => String(x.id) === String(params[0]));
+      return { rows: b ? [{ ...b, title: st.goals.find((g) => String(g.id) === String(b.goal_id)).title }] : [] };
+    }
+    if (/^UPDATE government_pot_borrows SET state = \$2/.test(s)) {
+      const b = st.borrows.find((x) => String(x.id) === String(params[0]) && x.state === 'open');
+      if (!b) return { rows: [] };
+      Object.assign(b, { state: params[1], lent_usd: params[2], answer_key: params[3], answered_by: params[4], answered_at: '2026-10-10T13:00:00.000Z' });
+      return { rows: [b] };
+    }
+    if (/^INSERT INTO government_pots/.test(s)) {
+      const row = { goal_id: params[0], budget_usd: params[1], set_by: params[2], set_at: '2026-10-10T12:00:00.000Z' };
+      st.pots = st.pots.filter((p) => String(p.goal_id) !== String(params[0])).concat(row);
+      return { rows: [row] };
+    }
+    if (/^DELETE FROM government_pots WHERE goal_id/.test(s)) {
+      const n = st.pots.length;
+      st.pots = st.pots.filter((p) => String(p.goal_id) !== String(params[0]));
+      return { rows: [], rowCount: n - st.pots.length };
+    }
+    throw new Error('the fake does not know this statement: ' + s.slice(0, 120));
+  };
+  return { st, q };
+}
+async function withPool(q, fn) {
+  const real = pool.query;
+  pool.query = q;
+  try { return await fn(); } finally { pool.query = real; }
+}
+
+const treasuryDb = require(path.join(GOV, 'treasury-db.js'));
+
+// ── 1. pots are filled from real spend ──────────────────────────────────────
+
+test('a pot is its stored budget against this month\'s REAL spend on the goal\'s tasks; the reserve is last month\'s spend no pot was given', async () => {
+  const { q } = project({ pots: [{ goal_id: 1, budget_usd: 300 }, { goal_id: 2, budget_usd: 500 }, { goal_id: 3, budget_usd: 100 }], spend: { 1: 412.5, 2: 120.25 }, lastMonth: 2000 });
+  const t = await withPool(q, () => treasuryDb.readTreasury({ now: NOW }));
+  assert.equal(t.month, '2026-10');
+  assert.deepEqual(t.pots.map((p) => [p.goal_id, p.spent_usd, p.budget_usd, p.dry]), [['1', 412.5, 300, true], ['2', 120.25, 500, false]], 'spend is cost_log\'s, per goal; a closed goal has no pot');
+  assert.equal(t.spend.month_usd, 582.75, 'this month: every real dollar, tasked or not');
+  assert.equal(t.spend.last_month_usd, 2000);
+  assert.equal(t.reserve.usd, 1200, 'last month\'s $2000, less the $800 given to pots');
+  assert.equal(t.pots[0].left_usd, -112.5);
+});
+
+test('a goal without a stored budget has no pot (a goal MAY have one); no month behind it leaves the reserve unknown, never invented', async () => {
+  const { q } = project({ pots: [], spend: { 1: 50 } });
+  const t = await withPool(q, () => treasuryDb.readTreasury({ now: NOW }));
+  assert.deepEqual(t.pots, []);
+  assert.equal(t.reserve.usd, null);
+  assert.match(t.reserve.line, /No month of spend/);
+});
+
+test('a loan this month tops its pot up and comes out of the reserve; a pot is dry at spend >= budget + lent', () => {
+  const t = T.buildTreasury({
+    now: NOW, goals: [{ id: 1, title: 'A', status: 'open' }], pots: [{ goal_id: 1, budget_usd: 300 }],
+    spend: { month_usd: 400, last_month_usd: 1000, by_goal: { 1: 400 } },
+    borrows: [{ id: 7, goal_id: 1, month: '2026-10', amount_usd: 200, budget_usd: 300, spent_usd: 320, state: 'lent', lent_usd: 200, answer_key: 'lend' }],
+  });
+  assert.equal(t.pots[0].lent_usd, 200);
+  assert.equal(t.pots[0].dry, false);
+  assert.equal(t.reserve.usd, 500, '$1000 less $300 given less $200 lent');
+  assert.equal(t.pots[0].borrow.state, 'lent');
+  const last = T.buildTreasury({
+    now: NOW, goals: [{ id: 1, title: 'A', status: 'open' }], pots: [{ goal_id: 1, budget_usd: 300 }],
+    spend: { month_usd: 400, last_month_usd: 1000, by_goal: { 1: 400 } },
+    borrows: [{ id: 6, goal_id: 1, month: '2026-09', amount_usd: 200, budget_usd: 300, spent_usd: 320, state: 'lent', lent_usd: 200, answer_key: 'lend' }],
+  });
+  assert.equal(last.pots[0].lent_usd, 0, 'last month\'s loan does not carry into this month');
+  assert.equal(last.pots[0].dry, true);
+});
+
+// ── 3. the cap setting exists and is off ────────────────────────────────────
+
+test('the spend cap is a project setting, and it is OFF by default: no limit', async () => {
+  assert.equal(SETTING_KEYS.SPEND_CAP, 'treasury.spend_cap_usd');
+  const off = await withPool(project().q, () => resolveSpendCap());
+  assert.deepEqual([off.on, off.usd, off.source], [false, null, 'default'], 'no row: off');
+  const t = await withPool(project().q, () => treasuryDb.readTreasury({ now: NOW }));
+  assert.equal(t.cap.on, false);
+  assert.match(t.cap.line, /no spend limit/);
+  const on = await withPool(project({ cap: 500 }).q, () => resolveSpendCap());
+  assert.deepEqual([on.on, on.usd], [true, 500], 'a stored value turns it on');
+  const junk = await withPool(project({ cap: 'lots' }).q, () => resolveSpendCap());
+  assert.equal(junk.on, false, 'an unusable stored value reads off, and says why');
+  assert.ok(junk.invalid);
+  assert.deepEqual(parseSpendCap(0).reason ? 'refused' : 'ok', 'refused', '$0 is not a cap; clearing is how it turns off');
+  assert.ok(parseSpendCap(MAX_SPEND_CAP_USD + 1).reason, 'past the ceiling is refused');
+  // set it, read it on, turn it off again: off is no row
+  const p = project();
+  await withPool(p.q, async () => {
+    await setSpendCap(800, 3);
+    const r = await resolveSpendCap();
+    assert.deepEqual([r.on, r.usd], [true, 800]);
+    assert.match(describeSpendCap(r), /^On:/);
+    await setSpendCap(null, 3);
+    assert.equal(p.st.settings.size, 0, 'turning it off deletes the row');
+    assert.match(describeSpendCap(await resolveSpendCap()), /no spend limit/);
+  });
+});
+
+// ── 2. a dry pot files a borrow ask ─────────────────────────────────────────
+
+test('a dry pot files ONE borrow, its ask stored in the ask shape on treasury_spending:<id>, waiting on the Treasury', async () => {
+  const { st, q } = project({ pots: [{ goal_id: 1, budget_usd: 300 }, { goal_id: 2, budget_usd: 500 }], spend: { 1: 412.5, 2: 120 }, lastMonth: 2000 });
+  const filed = await withPool(q, () => treasuryDb.fileBorrows({ now: NOW }));
+  assert.equal(filed.length, 1, 'only the dry pot asks');
+  assert.equal(filed[0].goal_id, '1');
+  // its pace: $412.50 over 10 of 31 days is ~$1279 for the month; it has $300 → ask $1000 (rounded up to $50)
+  assert.equal(filed[0].amount_usd, 1000);
+  const ask = st.asks.get('treasury_spending:' + filed[0].borrow_id);
+  assert.ok(ask, 'the ask is stored on the docket id');
+  assert.equal(ask.waits_on, 'lead:treasury');
+  assert.equal(ask.question, 'Lend Project creation $1000 from the reserve?');
+  assert.ok(asks.checkAsk(asks.fromRow(ask)).ok, 'it is a valid ask, by the server\'s own rules');
+  assert.deepEqual(asks.fromRow(ask).options.map((o) => o.act), ['answer:lend', 'answer:half', 'answer:no']);
+  // a second sweep files nothing: one open borrow per pot
+  const again = await withPool(q, () => treasuryDb.fileBorrows({ now: NOW }));
+  assert.deepEqual(again, []);
+  assert.equal(st.borrows.length, 1);
+});
+
+test('a "no" this month stands until the month turns; a refusal last month does not stop this month\'s ask', () => {
+  const pot = { goal_id: '1', dry: true };
+  assert.equal(T.needsBorrow(pot, [], '2026-10'), true);
+  assert.equal(T.needsBorrow(pot, [{ goal_id: 1, state: 'open', month: '2026-09' }], '2026-10'), false, 'one open at a time, whatever its month');
+  assert.equal(T.needsBorrow(pot, [{ goal_id: 1, state: 'refused', month: '2026-10' }], '2026-10'), false);
+  assert.equal(T.needsBorrow(pot, [{ goal_id: 1, state: 'refused', month: '2026-09' }], '2026-10'), true);
+  assert.equal(T.needsBorrow(pot, [{ goal_id: 1, state: 'lent', month: '2026-10' }], '2026-10'), true, 'lent and dry again: it asks again');
+  assert.equal(T.needsBorrow({ goal_id: '1', dry: false }, [], '2026-10'), false);
+});
+
+test('fileBorrows honours a "no": a pot the treasury refused this month files nothing until the month turns', async () => {
+  const refused = { id: 5, goal_id: 1, month: '2026-10', amount_usd: 400, budget_usd: 300, spent_usd: 320, state: 'refused', lent_usd: null, answer_key: 'no' };
+  const { st, q } = project({ pots: [{ goal_id: 1, budget_usd: 300 }], spend: { 1: 412.5 }, lastMonth: 2000, borrows: [refused] });
+  assert.deepEqual(await withPool(q, () => treasuryDb.fileBorrows({ now: NOW })), []);
+  assert.equal(st.borrows.length, 1);
+  const next = project({ pots: [{ goal_id: 1, budget_usd: 300 }], spend: { 1: 412.5 }, lastMonth: 2000, borrows: [{ ...refused, month: '2026-09' }] });
+  assert.equal((await withPool(next.q, () => treasuryDb.fileBorrows({ now: NOW }))).length, 1, 'a refusal from last month does not hold this month');
+});
+
+test('the borrow ask is never slop: a long or marked-up goal title falls back to "this goal"; past a cap it recommends no', () => {
+  const long = T.borrowAsk({ title: 'The very long goal title that would never fit a question', amount_usd: 400, spent_usd: 900, budget_usd: 750 });
+  assert.equal(long.question, 'Lend this goal $400 from the reserve?');
+  assert.equal(T.borrowAsk({ title: 'Working area 1 — Project creation', amount_usd: 400, spent_usd: 900, budget_usd: 750 }).question, 'Lend Project creation $400 from the reserve?', 'a working-area prefix is dropped');
+  assert.ok(asks.checkAsk(long).ok);
+  assert.equal(long.recommend.key, 'lend', 'no limit: lend by default');
+  const capped = T.borrowAsk({ title: 'Ops', amount_usd: 400, spent_usd: 900, budget_usd: 750, cap: { on: true, usd: 1000 }, month_usd: 800 });
+  assert.equal(capped.recommend.key, 'no');
+  assert.ok(asks.checkAsk(capped).ok);
+});
+
+test('the poller files through fileBorrows and is quiet when nothing is dry; a failed read is retried, never thrown', async () => {
+  const poller = require(path.join(GOV, 'pollers', 'treasury-borrow.js'));
+  const lines = [];
+  const quiet = await poller.runSweep({ fileFn: async () => [], log: (m) => lines.push(m) });
+  assert.deepEqual([quiet.filed, lines.length], [0, 0]);
+  const one = await poller.runSweep({ fileFn: async () => [{ goal_id: '1', borrow_id: '9', amount_usd: 400 }], log: (m) => lines.push(m) });
+  assert.equal(one.filed, 1);
+  assert.match(lines[0], /goal 1's pot is dry → borrow 9 asks the reserve for \$400/);
+  const errs = [];
+  const bad = await poller.runSweep({ fileFn: async () => { throw new Error('db down'); }, error: (m) => errs.push(m) });
+  assert.equal(bad.failed, true);
+  assert.match(errs[0], /next sweep retries/);
+  const manifest = JSON.parse(fs.readFileSync(path.join(GOV, 'module.json'), 'utf8'));
+  assert.ok(manifest.contributes.pollers.includes('treasury-borrow'), 'the module runs it');
+});
+
+// ── 4. the walls, in the table ──────────────────────────────────────────────
+
+test('government_031: a borrow is filed open, answered once, what it asked is never edited, and it is never deleted', () => {
+  const code = MIGRATION.replace(/--[^\n]*/g, '');
+  assert.match(code, /CREATE UNIQUE INDEX IF NOT EXISTS government_pot_borrows_one_open\s+ON government_pot_borrows \(goal_id\) WHERE state = 'open'/);
+  assert.match(code, /IF TG_OP = 'DELETE' THEN\s+RAISE EXCEPTION/);
+  assert.match(code, /IF OLD\.state <> 'open' THEN\s+RAISE EXCEPTION/);
+  assert.match(code, /NEW\.amount_usd IS DISTINCT FROM OLD\.amount_usd/);
+  assert.match(code, /BEFORE INSERT OR UPDATE OR DELETE ON government_pot_borrows/);
+  assert.match(code, /state IN \('open', 'lent', 'refused'\)/);
+  assert.doesNotMatch(code, /INSERT INTO/, 'nothing is seeded');
+});
+
+// ── the routes, through the real router ─────────────────────────────────────
+
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+const seams = require(path.join(ROOT, 'src', 'module-seams.js'));
+const rrc = require(path.join(ROOT, 'src', 'bongos', 'route-rank-check.js'));
+const resolver = require(path.join(GOV, 'resolver.js'));
+const db = require(path.join(GOV, 'db.js'));
+const { attachFail } = require(path.join(ROOT, 'src', 'bongos', 'middleware', 'error-envelope.js'));
+const express = require('express');
+
+const realRequireBuilder = api.requireBuilder;
+const realResolve = resolver.resolveBuilderPermissions;
+const realLeads = db.listLeads;
+const realArchons = db.listActiveArchons;
+let caller = 3;
+let held = ['board.vote.cast'];
+let leads = [];
+api.requireBuilder = (req, res, next) => { req.builder = { id: caller, rank: caller === 3 ? 'archon' : 'metic' }; next(); };
+resolver.resolveBuilderPermissions = async () => held;
+db.listLeads = async () => leads;
+db.listActiveArchons = async () => [{ id: '3', github_login: 'ada', display_name: 'Ada' }];
+seams._reset();
+seams.registerProvider('government', { resolveBuilderPermissions: async () => held });
+const buildGovernmentRouter = require(path.join(GOV, 'routes', 'government.js'));
+const app = express();
+app.use(express.json());
+app.use(attachFail);
+app.use(buildGovernmentRouter());
+const server = http.createServer(app);
+await new Promise((r) => server.listen(0, '127.0.0.1', r));
+const BASE = `http://127.0.0.1:${server.address().port}`;
+after(() => {
+  server.close(); api.requireBuilder = realRequireBuilder; resolver.resolveBuilderPermissions = realResolve;
+  db.listLeads = realLeads; db.listActiveArchons = realArchons; seams._reset();
+});
+async function call(method, p, body) {
+  const res = await fetch(`${BASE}${p}`, { method, headers: body === undefined ? {} : { 'content-type': 'application/json' }, body: body === undefined ? undefined : JSON.stringify(body) });
+  let json = null; try { json = await res.json(); } catch { /* none */ }
+  return { status: res.status, json };
+}
+const TREASURY_LEAD = { id: '9', building: 'treasury', builder_id: '45', charter: 'The money.', appointed_by_item_id: '40', appointed_at: '2026-10-09T12:00:00.000Z', removed_at: null, github_login: 'dee', display_name: 'Dee' };
+
+test('the treasury routes are pinned where the room reads; the walls are inside', () => {
+  const pins = rrc.MODULE_EXPECTED_RANKS.government;
+  assert.equal(pins['GET /government/treasury'], 'perm:board.vote.cast');
+  assert.equal(pins['PUT /government/treasury/pots/:goalId'], 'perm:board.vote.cast');
+  assert.equal(pins['POST /government/treasury/borrows/:borrowId/answer'], 'perm:board.vote.cast');
+});
+
+test('GET /government/treasury: the real treasury, the cap off, and who answers for it (the owner while unseated)', async () => {
+  const { q } = project({ pots: [{ goal_id: 1, budget_usd: 300 }], spend: { 1: 412.5 }, lastMonth: 1000 });
+  await withPool(q, async () => {
+    const r = await call('GET', '/government/treasury');
+    assert.equal(r.status, 200, JSON.stringify(r.json));
+    assert.equal(r.json.pots[0].dry, true);
+    assert.equal(r.json.cap.on, false);
+    assert.deepEqual([r.json.answers.seat, r.json.answers.yours, r.json.answers.fell_to_owner], ['owner', true, true]);
+  });
+  held = [];
+  try { assert.equal((await call('GET', '/government/treasury')).status, 403); } finally { held = ['board.vote.cast']; }
+});
+
+test('PUT /government/treasury/pots/:goalId: only whoever answers for the Treasury; a Lead seated there takes it from the owner', async () => {
+  const { st, q } = project();
+  await withPool(q, async () => {
+    caller = 3; // the owner, Treasury unseated
+    const ok = await call('PUT', '/government/treasury/pots/1', { budget_usd: 250 });
+    assert.equal(ok.status, 200, JSON.stringify(ok.json));
+    assert.equal(ok.json.pot.budget_usd, 250);
+    assert.equal(st.pots.length, 1);
+    assert.equal((await call('PUT', '/government/treasury/pots/1', { budget_usd: -5 })).status, 400);
+    assert.equal((await call('PUT', '/government/treasury/pots/3', { budget_usd: 50 })).json.error.code, 'goal_not_open');
+    assert.equal((await call('PUT', '/government/treasury/pots/99', { budget_usd: 50 })).status, 404);
+    leads = [TREASURY_LEAD];
+    const owner = await call('PUT', '/government/treasury/pots/1', { budget_usd: 999 });
+    assert.equal(owner.status, 403, 'Dee leads the Treasury now: the owner does not set pots');
+    assert.equal(owner.json.error.code, 'not_the_holder');
+    caller = 45;
+    const dee = await call('PUT', '/government/treasury/pots/1', { budget_usd: null });
+    assert.equal(dee.status, 200);
+    assert.equal(dee.json.removed, true, 'null takes the pot away');
+    assert.equal(st.pots.length, 0);
+  });
+  leads = []; caller = 3;
+});
+
+test('a filed borrow is a docket matter at the Treasury, with acts only for its seat; answering it writes the loan once', async () => {
+  const { st, q } = project({ pots: [{ goal_id: 1, budget_usd: 300 }], spend: { 1: 412.5 }, lastMonth: 2000 });
+  await withPool(q, async () => {
+    const [f] = await treasuryDb.fileBorrows({ now: NOW });
+    const docket = require(path.join(GOV, 'docket.js'));
+    const found = await docket.matterWithSeats({ id: 3, rank: 'archon' }, 'treasury_spending:' + f.borrow_id);
+    assert.ok(found.matter, 'the docket carries it');
+    assert.equal(found.matter.building, 'treasury');
+    assert.equal(found.matter.state, 'needs');
+    assert.equal(found.matter.ask.waits_on, 'lead:treasury');
+    assert.deepEqual(found.matter.acts[0].options.map((o) => o.key), ['lend', 'half', 'no']);
+    assert.equal(routing.routeMatter(found.matter, '3', found.seats).yours, true, 'unseated: the owner answers');
+    caller = 45; // not the owner, and the Treasury has no Lead
+    const notYours = await call('POST', `/government/treasury/borrows/${f.borrow_id}/answer`, { key: 'lend' });
+    assert.equal(notYours.status, 403);
+    assert.equal(notYours.json.error.code, 'not_yours');
+    const other = await docket.matterWithSeats({ id: 45, rank: 'metic' }, 'treasury_spending:' + f.borrow_id);
+    assert.equal(other.matter.acts, undefined, 'no acts for a viewer who does not sit there');
+    caller = 3;
+    assert.equal((await call('POST', `/government/treasury/borrows/${f.borrow_id}/answer`, { key: 'maybe' })).status, 400);
+    const half = await call('POST', `/government/treasury/borrows/${f.borrow_id}/answer`, { key: 'half' });
+    assert.equal(half.status, 200, JSON.stringify(half.json));
+    assert.deepEqual([half.json.borrow.state, half.json.borrow.lent_usd], ['lent', 500]);
+    const twice = await call('POST', `/government/treasury/borrows/${f.borrow_id}/answer`, { key: 'no' });
+    assert.equal(twice.status, 409);
+    const t = await treasuryDb.readTreasury({ now: NOW });
+    assert.deepEqual([t.pots[0].lent_usd, t.pots[0].dry], [500, false], 'the loan tops the pot up');
+    assert.equal(st.borrows[0].answered_by, 3);
+  });
+});
+
+test('the docket declares the treasury\'s spending matters as a live source, no longer "coming"', () => {
+  const docket = require(path.join(GOV, 'docket.js'));
+  assert.ok(docket.EXPECTED_SOURCES.some((s) => s.source === 'treasury_spending' && s.building === 'treasury'));
+  assert.ok(!docket.COMING_SOURCES.some((s) => s.source === 'treasury_spending'));
+});

package/tests/governor_docket.mjs

@@ -287,7 +287,9 @@ test('nothing is invented: coming / off / unavailable are each reported, with no
   assert.match(by.core_update.reason, /in time/);
   assert.equal(by.access_requests.status, 'off', 'no contributor registered → its module is off');
   assert.equal(by.module_rechecks.status, 'off', 'module re-checks are a real source now, never coming');
-  for (const k of ['grade_appeals', 'standing_rules', 'treasury_spending']) {
+  // task 1004712: the treasury's spending matters are a real source now (a dry pot's borrow)
+  assert.equal(by.treasury_spending.status, 'off', 'treasury spending is real now: with no contributor its module is off, never coming');
+  for (const k of ['grade_appeals', 'standing_rules']) {
     assert.equal(by[k].status, 'coming', k);
     assert.ok(by[k].reason, `${k} says why`);
   }
@@ -307,7 +309,9 @@ test('the response shape: counts, line, street-ordered buildings, sorted matters
   c.readings.set('flow', { reading: 'flow', gate: { anyBuilder: true }, read: async () => ({ value: 3, figure: '3 stuck', line: 'longest wait 4 days, waiting for review', hot: true }) });
   const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast', 'security.report.adjudicate'], contributions: c, now: NOW });
 
-  assert.deepEqual(Object.keys(d).sort(), ['buildings', 'counts', 'desks', 'floors', 'generated_at', 'history', 'history_sources', 'line', 'matters', 'readings', 'sources', 'viewer', 'vocabulary'].sort());
+  assert.deepEqual(Object.keys(d).sort(), ['buildings', 'counts', 'desks', 'floors', 'generated_at', 'history', 'history_sources', 'line', 'matters', 'readings', 'routed', 'sources', 'viewer', 'vocabulary'].sort());
+  assert.equal(d.routed, false, 'no seats were read, so nothing is routed (task 1004705)');
+  assert.ok(d.matters.every((m) => !('route' in m)));
   assert.deepEqual(d.viewer, { id: '7' });
   // board 11 (needs) + board 12 (settled, closed this week) + blocker + report; board 13 is too old
   assert.deepEqual(d.counts, { needs: 2, moving: 1, settled: 1 });
@@ -334,6 +338,26 @@ test('the response shape: counts, line, street-ordered buildings, sorted matters
   assert.deepEqual(d.vocabulary.rules.map((x) => x.key), ['decide', 'first', 'consent', 'majority', 'unanimous', 'signoff', 'rule']);
 });
 
+test('the direction desk: with the seats read, every matter carries its route and the line counts only what is yours (task 1004705)', async () => {
+  boardView = { open: [item()], closed: [] };
+  const c = none();
+  c.sources.set('blockers', contrib({ building: 'planning', read: async () => [{ id: 4, title: 'Which payment provider', state: 'needs', opened_at: '2026-09-20T00:00:00Z' }] }));
+  c.sources.set('redteam_reports', contrib({ building: 'disputes', read: async () => [{ id: 2, title: 'Security report: sign-in limits', state: 'needs', rule: 'decide', opened_at: '2026-09-29T00:00:00Z' }] }));
+  const seats = (ownerIds) => ({ leads: [{ building: 'planning', builder_id: 9 }], owner: { builders: ownerIds.map((id) => ({ id })) }, holders: {} });
+  const build = (ownerIds) => docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: c, now: NOW, seats: seats(ownerIds) });
+  const d = await build([7]);
+  assert.equal(d.routed, true);
+  const route = (id) => d.matters.find((m) => m.id === id).route;
+  assert.deepEqual([route('blockers:4').seat, route('blockers:4').yours], ['lead:planning', false], 'Planning has a Lead, and it is not the viewer');
+  assert.deepEqual([route('redteam_reports:2').seat, route('redteam_reports:2').fell_to_owner, route('redteam_reports:2').yours], ['owner', true, true], 'Disputes is unseated: the owner seat, which the viewer holds');
+  assert.deepEqual([route('board:11').seat, route('board:11').yours], ['board:charter', true], 'the sitting awaits the viewer\'s vote');
+  assert.deepEqual(d.counts, { needs: 3, moving: 0, settled: 0, yours: 2 });
+  assert.equal(d.line, '2 matters wait on you', 'the home line counts what is the viewer\'s, not all that needs somebody');
+  const other = await build([3]);
+  assert.equal(other.counts.yours, 1);
+  assert.equal(other.line, '1 matter waits on you');
+});
+
 test('fairness is not_yours when the viewer can see no Disputes source (never a false "0 open")', async () => {
   boardView = { open: [], closed: [] };
   const d = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: none(), now: NOW });