@bongos/core 1.21.112 → 1.21.114

package/tests/government_asks.mjs

@@ -0,0 +1,408 @@
+// tests/government_asks.mjs — THE ASK: one enforced shape for every request an
+// AI agent puts to a person (task 1004703, goal 1000111).
+//
+// WHAT IT GUARDS.
+//   1. Every rule of the shape (modules/government/asks.js checkAsk), one case
+//      each: the question (≤ 12 words, one, ends '?', no markup), the answers (2
+//      or 3; a key, a label of ≤ 4 words and a one-line result each; keys and acts
+//      in their grammar), the pick (one of the answers, a one-line why), the seat
+//      (a routable one), the "if nobody answers" line and the riding-along detail.
+//   2. A slop ask is refused with a plain reason: the prototype's 238-word
+//      override ask, sent as the question, names every fix in one paragraph.
+//   3. The server and the hall hold ONE rule set: gov-living.js askFormat and
+//      checkAsk give the same verdict, rule for rule, on every shared case, and
+//      every card in the past-asks corpus (tests/fixtures/government-ask-cards.json)
+//      is a valid stored ask.
+//   4. The table's CHECKs are the structural floor (government_028): twelve
+//      words, the question mark, two or three answers, the pick offered, the seat.
+//   5. The docket attaches each matter's stored ask, only to matters the viewer
+//      sees; a failing read attaches none and the city still stands. findMatter
+//      reads one matter through the same per-source gate.
+//   6. Through the real routers: POST /blockers refuses a slop ask and files
+//      nothing, stores a good one against blockers:<id>; GET /blockers carries it;
+//      POST /government/asks/check is a dry run; PUT /government/asks/:matter
+//      writes only onto a matter its writer can see.
+//
+// DB-free: every read and write is stubbed by property.
+// Run:  node --test --test-reporter=tap tests/government_asks.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 FX = path.join(ROOT, 'scripts', 'hall-preview', 'fixtures');
+const fx = (name) => JSON.parse(fs.readFileSync(path.join(FX, name + '.json'), 'utf8'));
+// real past asks as the cards they should have been (test data; the hall never reads it)
+const CARDS = JSON.parse(fs.readFileSync(path.join(ROOT, 'tests', 'fixtures', 'government-ask-cards.json'), 'utf8')).cards;
+
+const asks = require(path.join(GOV, 'asks.js'));
+const asksDb = require(path.join(GOV, 'asks-db.js'));
+const docket = require(path.join(GOV, 'docket.js'));
+const resolver = require(path.join(GOV, 'resolver.js'));
+const G = require(path.join(ROOT, 'modules', 'hall-ui', 'public', 'gov-living.js'));
+
+const GOOD = {
+  question: 'Turn unattended building back on?',
+  options: [
+    { key: 'on', label: 'Turn it on', result: 'Agents work through the night.', act: 'go ahead' },
+    { key: 'off', label: 'Keep it off', result: 'Nothing builds unless someone starts a session.' },
+  ],
+  recommend: { key: 'off', why: 'It was paused for a check.' },
+  waits_on: 'owner',
+  if_nobody_answers: 'It stays off.',
+};
+const card = (over) => ({ ...JSON.parse(JSON.stringify(GOOD)), ...over });
+const rulesOf = (r) => r.errors.map((e) => `${e.field}:${e.rule}`).sort();
+
+// ── 1. every rule ───────────────────────────────────────────────────────────
+
+test('a good ask passes, and comes back in its stored form', () => {
+  const r = asks.checkAsk({ ...card({ question: '  Turn unattended building back on?  ' }), detail: '  The long story.  ', extra: 'dropped' });
+  assert.equal(r.ok, true, JSON.stringify(r.errors));
+  assert.deepEqual(r.errors, []);
+  assert.equal(r.question_words, 5);
+  assert.deepEqual(r.ask, {
+    question: 'Turn unattended building back on?',
+    options: [
+      { key: 'on', label: 'Turn it on', result: 'Agents work through the night.', act: 'go ahead' },
+      { key: 'off', label: 'Keep it off', result: 'Nothing builds unless someone starts a session.' },
+    ],
+    recommend: { key: 'off', why: 'It was paused for a check.' },
+    waits_on: 'owner',
+    if_nobody_answers: 'It stays off.',
+    detail: 'The long story.',
+  });
+  assert.equal(asks.checkAsk(card({ question: 'Upgrade the setup service, version 1.20.82, now?' })).ok, true, 'a version number is not a sentence break');
+  assert.equal(asks.checkAsk(card({ options: [...GOOD.options, { key: 'later', label: 'Ask me later', result: 'It comes back tomorrow.' }] })).ok, true, 'three answers');
+  for (const seat of ['owner', 'lead:planning', 'board:charter', 'committee:review.testers']) assert.equal(asks.checkAsk(card({ waits_on: seat })).ok, true, seat);
+});
+
+// One case per rule: the ask that breaks exactly that rule, and the error it gets.
+const RULE_CASES = {
+  'ask:missing': null,
+  'question:missing': card({ question: '' }),
+  'question:too_long': card({ question: 'Should we turn the unattended building back on now that the evaluation is done?' }),
+  'question:not_a_question': card({ question: 'Turn unattended building back on.' }),
+  'question:more_than_one': card({ question: 'It is off. Turn it on?' }),
+  'question:markup': card({ question: 'Turn **unattended** building on?' }),
+  'options:count': card({ options: [GOOD.options[1]] }),
+  'options[1]:missing': card({ options: [GOOD.options[0], 'off'], recommend: { key: 'on', why: 'x' } }),
+  'options[1]:no_key': card({ options: [GOOD.options[0], { ...GOOD.options[1], key: '' }], recommend: { key: 'on', why: 'x' } }),
+  'options[1]:duplicate': card({ options: [GOOD.options[0], { ...GOOD.options[1], key: 'on' }], recommend: { key: 'on', why: 'x' } }),
+  'options[1]:bad_key': card({ options: [GOOD.options[0], { ...GOOD.options[1], key: 'Keep It Off' }], recommend: { key: 'on', why: 'x' } }),
+  'options[1]:no_label': card({ options: [GOOD.options[0], { ...GOOD.options[1], label: ' ' }] }),
+  'options[0]:label_too_long': card({ options: [{ key: 'on', label: 'Turn it on right now please', result: 'On.' }, GOOD.options[1]] }),
+  'options[1].result:missing': card({ options: [GOOD.options[0], { key: 'off', label: 'Keep it off' }] }),
+  'options[1].result:not_one_line': card({ options: [GOOD.options[0], { key: 'off', label: 'Keep it off', result: 'Off.\nAnd quiet.' }] }),
+  'options[1].result:markup': card({ options: [GOOD.options[0], { key: 'off', label: 'Keep it off', result: 'See https://example.com for why.' }] }),
+  'options[0]:bad_act': card({ options: [{ ...GOOD.options[0], act: 'DROP TABLE;' }, GOOD.options[1]] }),
+  'recommend:missing': card({ recommend: null }),
+  'recommend:unknown_key': card({ recommend: { key: 'maybe', why: 'It was paused.' } }),
+  'recommend:no_why': card({ recommend: { key: 'off', why: '' } }),
+  'recommend:why_too_long': card({ recommend: { key: 'off', why: 'It was paused for a check that took a long time and is not finished yet so we should wait a bit longer.' } }),
+  'waits_on:missing': card({ waits_on: '' }),
+  'waits_on:unknown_seat': card({ waits_on: 'whoever is around' }),
+  'if_nobody_answers:missing': card({ if_nobody_answers: '' }),
+  'if_nobody_answers:not_one_line': card({ if_nobody_answers: 'It stays off until somebody comes back and turns it on again by hand, which could be weeks.' }),
+  'detail:not_text': { ...card({}), detail: { long: true } },
+  'detail:too_long': { ...card({}), detail: 'x'.repeat(asks.CAPS.detail + 1) },
+};
+
+test('each rule of the shape refuses the ask that breaks it, and names it', () => {
+  for (const [rule, c] of Object.entries(RULE_CASES)) {
+    const r = asks.checkAsk(c);
+    assert.equal(r.ok, false, rule);
+    assert.equal(r.ask, null, `${rule}: nothing to store`);
+    assert.deepEqual(rulesOf(r), [rule], `${rule}: exactly that rule, got ${JSON.stringify(r.errors)}`);
+    for (const e of r.errors) assert.match(e.message, /^[A-Z"0-9].*\.$/, `${rule}: a plain sentence`);
+  }
+  assert.equal(asks.checkAsk(card({ options: [...GOOD.options, GOOD.options[0], GOOD.options[1]] })).errors.some((e) => e.rule === 'count'), true, 'four answers is too many');
+  assert.equal(asks.checkAsk(card({ options: [] })).errors[0].message, 'Offer 2 or 3 tap answers, not 0.');
+  // the rules are the prototype's, number for number
+  assert.deepEqual(asks.ASK_RULES, G.ASK_RULES);
+});
+
+// ── 2. the slop ask, refused in plain words ─────────────────────────────────
+
+test('the prototype\'s 238-word override ask, sent as the question, is refused with a plain reason', () => {
+  const m = fx('government__docket').matters.find((x) => x.id === 'override_requests:1000017');
+  const text = [m.title, m.detail].filter(Boolean).join('\n\n');
+  assert.ok(asks.words(text).length >= 200, 'it is the long one');
+  const r = asks.checkAsk({ question: text, options: [], recommend: null, waits_on: '', if_nobody_answers: '' });
+  assert.equal(r.ok, false);
+  const rules = new Set(r.errors.map((e) => e.rule));
+  for (const rule of ['too_long', 'more_than_one', 'count', 'missing']) assert.ok(rules.has(rule), rule);
+  const line = asks.refusalLine(r.errors);
+  assert.match(line, /^This ask was refused: a person must be able to answer it at a glance\. /);
+  assert.match(line, /The question is \d+ words; 12 at most\./);
+  assert.match(line, /Offer 2 or 3 tap answers, not 0\./);
+  assert.match(line, /Say who this waits on\./);
+  assert.doesNotMatch(line, /undefined|\[object/);
+  assert.equal(asks.refusalLine([]), '');
+});
+
+// ── 3. one rule set: the server's and the hall's ────────────────────────────
+
+test('the server and the hall give the same verdict on every shared rule', () => {
+  // the server-only rules (a stored ask's grammar and caps) are not the hall's
+  const SERVER_ONLY = new Set(['options[1]:bad_key', 'options[0]:bad_act', 'waits_on:unknown_seat', 'detail:not_text', 'detail:too_long', 'ask:missing']);
+  let compared = 0;
+  for (const [rule, c] of Object.entries(RULE_CASES)) {
+    if (SERVER_ONLY.has(rule)) continue;
+    const server = asks.checkAsk(c);
+    const hall = G.askFormat(c);
+    assert.equal(server.ok, hall.ok, `${rule}: same ok`);
+    assert.deepEqual(rulesOf(server), rulesOf(hall), `${rule}: same rules`);
+    assert.deepEqual(server.errors.map((e) => e.message).sort(), hall.errors.map((e) => e.message).sort(), `${rule}: same words`);
+    compared += 1;
+  }
+  assert.ok(compared >= 20, `${compared} rules compared`);
+  assert.equal(G.askFormat(null).ok, false, 'no card is refused by both');
+});
+
+test('every card in the past-asks corpus is a valid stored ask', () => {
+  const all = CARDS;
+  assert.ok(all.length >= 20);
+  for (const a of all) {
+    const r = asks.checkAsk(a);
+    assert.equal(r.ok, true, `${a.id}: ${JSON.stringify(r.errors)}`);
+    assert.equal(G.askFormat(a).ok, true, `${a.id}: the hall agrees`);
+  }
+});
+
+// ── 4. the table's floor ────────────────────────────────────────────────────
+
+test('government_028: the table refuses a slop row on its own', () => {
+  const sql = fs.readFileSync(path.join(GOV, 'migrations', 'government_028_asks.sql'), 'utf8');
+  assert.match(sql, /CREATE TABLE IF NOT EXISTS government_asks/);
+  assert.match(sql, /matter_id\s+text\s+PRIMARY KEY/);
+  assert.match(sql, /array_length\(regexp_split_to_array\(btrim\(question\), '\\s\+'\), 1\) <= 12/, 'twelve words');
+  assert.match(sql, /question ~ '\\\?\$'/, 'a question mark');
+  assert.match(sql, /question !~ '\[\\r\\n\]'/, 'one line');
+  assert.match(sql, /jsonb_array_length\(options\) BETWEEN 2 AND 3/, 'two or three answers');
+  assert.match(sql, /options @> jsonb_build_array\(jsonb_build_object\('key', recommend_key\)\)/, 'the pick is offered');
+  // the seat grammar is the module's, building for building
+  const seat = /waits_on ~ '([^']+)'/.exec(sql)[1];
+  for (const b of asks.BUILDINGS) assert.ok(seat.includes(b), b);
+  const re = new RegExp(seat);
+  for (const s of ['owner', 'lead:planning', 'board:charter', 'committee:review.testers']) assert.equal(re.test(s), true, s);
+  for (const s of ['the owner', 'lead:nowhere', 'you', '']) assert.equal(re.test(s), false, s);
+  for (const s of ['owner', 'lead:planning', 'committee:review.testers', 'lead:nowhere', 'you']) assert.equal(asks.SEAT.test(s), re.test(s), `${s}: the module and the table agree`);
+  assert.doesNotMatch(sql, /\bINSERT INTO\b/, 'no ask is seeded');
+});
+
+// ── 5. the docket carries asks ──────────────────────────────────────────────
+
+const VIEWER = { id: 42, rank: 'metic' };
+const NOW = Date.parse('2026-10-09T12:00:00Z');
+function contributions(rows) {
+  return {
+    sources: new Map([
+      ['blockers', { source: 'blockers', building: 'planning', gate: { anyBuilder: true }, read: async () => rows.blockers || [] }],
+      ['override_requests', { source: 'override_requests', building: 'release', gate: { permission: 'override_request.decide' }, read: async () => rows.overrides || [] }],
+    ]),
+    readings: new Map(), floors: new Map(), histories: new Map(), desks: new Map(),
+  };
+}
+const ROWS = {
+  blockers: [{ id: 7, title: 'Pick a host', state: 'needs', rule: 'decide', opened_at: '2026-10-01T00:00:00Z' }, { id: 8, title: 'No ask here', state: 'needs', rule: 'decide' }],
+  overrides: [{ id: 5, title: 'Merge without review', state: 'needs', rule: 'decide' }],
+};
+const STORED = { ...asks.checkAsk(GOOD).ask, written_at: '2026-10-09T11:00:00.000Z' };
+
+test('the docket attaches each matter\'s stored ask, only to the matters the viewer sees', async () => {
+  const asked = [];
+  const readAsks = async (ids) => { asked.push(...ids); return new Map([['blockers:7', STORED], ['override_requests:5', STORED]]); };
+  const seen = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: contributions(ROWS), now: NOW, readAsks });
+  const by = Object.fromEntries(seen.matters.map((m) => [m.id, m]));
+  assert.deepEqual(by['blockers:7'].ask, STORED, 'the matter carries its ask');
+  assert.equal('ask' in by['blockers:8'], false, 'a matter with no ask carries none');
+  assert.equal(by['override_requests:5'], undefined, 'a matter the viewer cannot see is not there');
+  assert.ok(!asked.includes('override_requests:5'), 'nor is its ask read');
+  // with the atom, it is there and carries its ask
+  const metic = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast', 'override_request.decide'], contributions: contributions(ROWS), now: NOW, readAsks });
+  assert.deepEqual(metic.matters.find((m) => m.id === 'override_requests:5').ask, STORED);
+  // a failing read attaches none, and the docket still stands
+  const broken = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: contributions(ROWS), now: NOW, readAsks: async () => { throw new Error('db down'); } });
+  assert.equal(broken.matters.length, 2);
+  assert.ok(broken.matters.every((m) => !('ask' in m)));
+  // and with no reader (a test, or a docket built without the db) none is attached
+  const none = await docket.buildDocket({ viewer: VIEWER, permissions: ['board.vote.cast'], contributions: contributions(ROWS), now: NOW });
+  assert.ok(none.matters.every((m) => !('ask' in m)));
+});
+
+test('findMatter reads one matter through the same gate the docket applies', async () => {
+  const c = contributions(ROWS);
+  const find = (matterId, permissions = ['board.vote.cast']) => docket.findMatter({ viewer: VIEWER, permissions, matterId, contributions: c, now: NOW });
+  assert.equal((await find('blockers:7')).matter.id, 'blockers:7');
+  assert.equal((await find('blockers:9')).reason, 'not_found');
+  assert.equal((await find('override_requests:5')).reason, 'not_yours');
+  assert.equal((await find('override_requests:5', ['override_request.decide'])).matter.title, 'Merge without review');
+  assert.equal((await find('nowhere:1')).reason, 'no_such_source');
+  assert.equal((await find('access_requests:1')).reason, 'no_such_source', 'a declared source no module contributes');
+  const failing = { ...c, sources: new Map([['blockers', { building: 'planning', gate: { anyBuilder: true }, read: async () => { throw new Error('x'); } }]]) };
+  assert.equal((await docket.findMatter({ viewer: VIEWER, permissions: [], matterId: 'blockers:7', contributions: failing })).reason, 'unavailable');
+});
+
+// ── 6. through the real routers ─────────────────────────────────────────────
+
+const api = require(path.join(ROOT, 'src', 'module-api.js'));
+const seams = require(path.join(ROOT, 'src', 'module-seams.js'));
+const authMod = require(path.join(ROOT, 'src', 'bongos', 'auth.js'));
+const { attachFail } = require(path.join(ROOT, 'src', 'bongos', 'middleware', 'error-envelope.js'));
+const blockersDb = require(path.join(ROOT, 'modules', 'ideas', 'blockers.js'));
+const express = require('express');
+
+// The viewer's atoms, per request (the header stands in for the resolver).
+let perms = ['board.vote.cast'];
+const real = {
+  apiRequireBuilder: api.requireBuilder, authRequireBuilder: authMod.requireBuilder, requirePermission: authMod.requirePermission,
+  resolve: resolver.resolveBuilderPermissions, saveAsk: asksDb.saveAsk, asksFor: asksDb.asksFor,
+  create: blockersDb.createBlocker, list: blockersDb.listOpenBlockers, count: blockersDb.countOpenBlockers, get: blockersDb.getBlocker,
+};
+const fakeBuilder = (req, res, next) => { req.builder = { id: 42, rank: 'metic', github_login: 'someone' }; next(); };
+api.requireBuilder = fakeBuilder;
+authMod.requireBuilder = fakeBuilder;
+authMod.requirePermission = (...atoms) => (req, res, next) => (atoms.every((a) => perms.includes(a)) ? next() : res.fail('forbidden', 403));
+resolver.resolveBuilderPermissions = async () => perms.slice();
+
+// an in-memory government_asks and blockers table
+const store = new Map();
+const filed = [];
+asksDb.saveAsk = async ({ matterId, ask, builderId }) => { const row = { ...ask, written_at: '2026-10-09T12:00:00.000Z' }; store.set(matterId, { row, builderId }); return row; };
+asksDb.asksFor = async (ids) => new Map(ids.filter((id) => store.has(id)).map((id) => [id, store.get(id).row]));
+let nextId = 100;
+blockersDb.createBlocker = async ({ title, bodyMd }) => { const b = { id: String(nextId++), title, body_md: bodyMd, status: 'open', created_at: '2026-10-09T12:00:00.000Z', blocking_task_ids: [] }; filed.push(b); return b; };
+blockersDb.listOpenBlockers = async () => filed.slice();
+blockersDb.countOpenBlockers = async () => filed.length;
+blockersDb.getBlocker = async (id) => filed.find((b) => String(b.id) === String(id)) || null;
+
+seams._reset();
+const app = express();
+app.use(express.json());
+app.use(attachFail);
+app.use(require(path.join(GOV, 'routes', 'government.js'))());
+app.use(require(path.join(ROOT, 'modules', 'ideas', 'routes', 'blockers.js'))());
+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 = real.apiRequireBuilder; authMod.requireBuilder = real.authRequireBuilder; authMod.requirePermission = real.requirePermission;
+  resolver.resolveBuilderPermissions = real.resolve; asksDb.saveAsk = real.saveAsk; asksDb.asksFor = real.asksFor;
+  blockersDb.createBlocker = real.create; blockersDb.listOpenBlockers = real.list; blockersDb.countOpenBlockers = real.count; blockersDb.getBlocker = real.get;
+  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 SLOP = { question: 'I have been looking at the deploy and there are several things you should know. First the pipeline is red. Can you look?', options: [], waits_on: '', if_nobody_answers: '' };
+
+test('POST /blockers refuses a slop ask in plain words and files nothing', async () => {
+  const before = filed.length;
+  const r = await call('POST', '/blockers', { title: 'The deploy is red', body_md: 'Long story.', ask: SLOP });
+  assert.equal(r.status, 400);
+  assert.equal(r.json.error.code, 'ask_refused');
+  assert.match(r.json.error.message, /^This ask was refused: /);
+  assert.match(r.json.error.message, /The question is \d+ words; 12 at most\./);
+  assert.ok(r.json.error.details.errors.some((e) => e.field === 'options' && e.rule === 'count'));
+  assert.equal(filed.length, before, 'no blocker was filed');
+});
+
+test('POST /blockers stores a good ask against blockers:<id>, and GET /blockers carries it', async () => {
+  const r = await call('POST', '/blockers', { title: 'The deploy is red', body_md: 'The long story rides along here.', ask: { ...GOOD, detail: 'The long story rides along here.' } });
+  assert.equal(r.status, 201, JSON.stringify(r.json));
+  const id = r.json.blocker.id;
+  assert.equal(r.json.ask.question, GOOD.question);
+  assert.deepEqual(store.get(`blockers:${id}`).row.options, asks.checkAsk(GOOD).ask.options);
+  assert.equal(store.get(`blockers:${id}`).builderId, 42, 'who wrote it');
+  const list = await call('GET', '/blockers');
+  const row = list.json.blockers.find((b) => b.id === id);
+  assert.equal(row.ask.question, GOOD.question);
+  const one = await call('GET', `/blockers/${id}`);
+  assert.equal(one.json.blocker.ask.recommend.key, 'off');
+  // a blocker filed without an ask still files, and carries none
+  const plain = await call('POST', '/blockers', { title: 'Plain blocker' });
+  assert.equal(plain.status, 201);
+  assert.equal(plain.json.ask, null);
+  assert.equal((await call('GET', '/blockers')).json.blockers.find((b) => b.id === plain.json.blocker.id).ask, null);
+});
+
+test('POST /government/asks/check is a dry run: the verdict, nothing stored', async () => {
+  const size = store.size;
+  const ok = await call('POST', '/government/asks/check', GOOD);
+  assert.equal(ok.status, 200);
+  assert.equal(ok.json.ok, true);
+  assert.equal(ok.json.question_words, 5);
+  const wrapped = await call('POST', '/government/asks/check', { ask: GOOD });
+  assert.equal(wrapped.json.ok, true, 'wrapped as { ask } too');
+  const bad = await call('POST', '/government/asks/check', SLOP);
+  assert.equal(bad.status, 400);
+  assert.equal(bad.json.error.code, 'ask_refused');
+  assert.deepEqual(bad.json.error.details.rules, asks.ASK_RULES);
+  assert.equal(store.size, size, 'nothing stored');
+});
+
+test('PUT /government/asks/:matter writes only onto a matter its writer can see, and refuses slop', async () => {
+  const id = filed[filed.length - 1].id;
+  perms = ['board.vote.cast'];
+  assert.equal((await call('PUT', `/government/asks/blockers:${id}`, SLOP)).json.error.code, 'ask_refused');
+  assert.equal(store.has(`blockers:${id}`), false, 'the slop ask was not stored');
+  const ok = await call('PUT', `/government/asks/blockers:${id}`, GOOD);
+  assert.equal(ok.status, 200, JSON.stringify(ok.json));
+  assert.equal(ok.json.matter_id, `blockers:${id}`);
+  assert.equal(store.get(`blockers:${id}`).row.question, GOOD.question);
+  // replaced whole by the next card
+  await call('PUT', `/government/asks/blockers:${id}`, card({ question: 'Ship the fix tonight?' }));
+  assert.equal(store.get(`blockers:${id}`).row.question, 'Ship the fix tonight?');
+  assert.equal((await call('PUT', '/government/asks/blockers:999999', GOOD)).status, 404, 'no such matter');
+  assert.equal((await call('PUT', '/government/asks/not-a-matter', GOOD)).json.error.code, 'bad_matter_id');
+  assert.equal((await call('PUT', '/government/asks/nowhere:1', GOOD)).status, 404, 'no such source');
+  perms = [];
+  assert.equal((await call('PUT', `/government/asks/blockers:${id}`, GOOD)).status, 403, 'without the docket\'s atom');
+  perms = ['board.vote.cast'];
+});
+
+// ── 7. passing an ask on (task 1004705, the direction desk) ─────────────────
+
+test('POST /government/asks/:matter/pass: only whoever it waits on hands it to another seat; the words stay', async () => {
+  const govDb = require(path.join(GOV, 'db.js'));
+  const realSeats = { leads: govDb.listLeads, archons: govDb.listActiveArchons };
+  // the viewer (42) leads Planning; the owner seat is Archon 1
+  govDb.listLeads = async () => [{ id: 1, building: 'planning', builder_id: 42, removed_at: null }];
+  govDb.listActiveArchons = async () => [{ id: 1, github_login: 'founder' }];
+  // the blocker needs a person only for one who may resolve it (blocker.review)
+  perms = ['board.vote.cast', 'blocker.review'];
+  try {
+    const b = await call('POST', '/blockers', { title: 'Which provider' });
+    const id = `blockers:${b.json.blocker.id}`;
+    assert.equal((await call('POST', `/government/asks/${id}/pass`, { seat: 'owner' })).json.error.code, 'no_ask', 'nothing stored yet');
+    await call('PUT', `/government/asks/${id}`, card({ waits_on: 'owner' }));
+    assert.equal((await call('POST', `/government/asks/${id}/pass`, { seat: 'lead:planning' })).json.error.code, 'not_yours', 'it waits on the owner, not on the viewer');
+    await call('PUT', `/government/asks/${id}`, card({ waits_on: 'lead:planning' }));
+    assert.equal((await call('POST', `/government/asks/${id}/pass`, { seat: 'the boss' })).json.error.code, 'unknown_seat');
+    assert.equal((await call('POST', `/government/asks/${id}/pass`, {})).status, 400, 'a seat is required');
+    const ok = await call('POST', `/government/asks/${id}/pass`, { seat: 'owner' });
+    assert.equal(ok.status, 200, JSON.stringify(ok.json));
+    assert.equal(store.get(id).row.waits_on, 'owner');
+    assert.equal(store.get(id).row.question, card({}).question, 'the ask\'s words are kept');
+    assert.deepEqual([ok.json.route.seat, ok.json.route.yours], ['owner', false], 'it left the viewer\'s to do');
+    assert.equal((await call('POST', `/government/asks/${id}/pass`, { seat: 'lead:planning' })).json.error.code, 'not_yours', 'and the viewer cannot take it back');
+    perms = [];
+    assert.equal((await call('POST', `/government/asks/${id}/pass`, { seat: 'owner' })).status, 403, 'without the docket\'s atom');
+    perms = ['board.vote.cast'];
+  } finally {
+    perms = ['board.vote.cast'];
+    govDb.listLeads = realSeats.leads;
+    govDb.listActiveArchons = realSeats.archons;
+  }
+});