@bongos/core 1.25.14 → 1.25.16

package/tests/genesis_work.mjs

@@ -0,0 +1,304 @@
+// tests/genesis_work.mjs — the founder's own work on a genesis stage (task 1005116)
+//
+// The DB-free half. It drives modules/onboarding/genesis-work.js against an in-memory
+// store with the same four-method contract as the Postgres one, so the rules run
+// everywhere: three doors onto ONE record (switching loses nothing), guided is the
+// default, an answer is stored as an answer, "not sure yet" / skipped / empty are three
+// different things, un-answering goes back to empty, a revision keeps its history, a
+// carried-over answer never overwrites the founder, and the read path a planning
+// session uses says what the founder said. Plus the assisted door's brief and the CLI's
+// argument parsing.
+//
+// The SAME contract runs against Postgres in tests/genesis_work_db.mjs (integration lane),
+// which imports `contract` from here. The tests below run only when this file is the
+// entry point.
+//
+// Run:  node tests/genesis_work.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import url from 'node:url';
+
+const require = createRequire(import.meta.url);
+const gw = require('../modules/onboarding/genesis-work.js');
+const { parseAnswer, formatStage } = require('../scripts/bongos/genesis.js');
+
+// An in-memory store honouring the contract pgStore implements.
+export function memStore() {
+  const work = new Map();
+  const answers = new Map();
+  const history = [];
+  let clock = 0;
+  const tick = () => new Date(1.7e12 + ++clock * 1000);
+  return {
+    work, answers, history,
+    async loadAll() { return { work: [...work.values()], answers: [...answers.values()] }; },
+    async upsertWork(stage, patch, by) {
+      const cur = work.get(stage) || { stage, door: 'guided', page_md: null, link_url: null };
+      work.set(stage, { ...cur, ...patch, updated_by: by, updated_at: tick() });
+    },
+    async writeAnswer(stage, q, v, by, { ifEmpty = false } = {}) {
+      const k = `${stage}|${q}`;
+      const cur = answers.get(k);
+      if (cur && ifEmpty) return { changed: false };
+      if (cur && cur.state === v.state && cur.answer_md === v.answer_md && cur.origin === v.origin) return { changed: false };
+      answers.set(k, { stage, question_id: q, ...v, updated_by: by, updated_at: tick() });
+      history.push({ stage, question_id: q, state: v.state, answer_md: v.answer_md, origin: v.origin, changed_by: by, changed_at: tick() });
+      return { changed: true };
+    },
+    async clearAnswer(stage, q, by) {
+      const k = `${stage}|${q}`;
+      if (!answers.has(k)) return { cleared: false };
+      answers.delete(k);
+      history.push({ stage, question_id: q, state: null, answer_md: null, origin: null, changed_by: by, changed_at: tick() });
+      return { cleared: true };
+    },
+    async history(stage, q) {
+      return history.filter((h) => h.stage === stage && h.question_id === q).reverse();
+    },
+  };
+}
+
+const qOf = (r, id) => r.work.questions.find((q) => q.id === id);
+
+// The contract both stores must satisfy. `deps` carries the store; `A` is a builder id.
+export async function contract(test, label, deps, A) {
+  await test(`${label}: an untouched stage reads guided, every question empty`, async () => {
+    const r = await gw.readStage('strategize', deps);
+    assert.equal(r.ok, true);
+    assert.equal(r.work.door, 'guided', 'guided is the default door');
+    assert.equal(r.work.adopted, true);
+    assert.deepEqual(r.work.counts, { total: 4, answered: 0, not_sure: 0, skipped: 0, empty: 4 });
+    assert.ok(r.work.questions.every((q) => q.answer === null));
+  });
+
+  await test(`${label}: an answer is stored as an answer, with its words and origin`, async () => {
+    const r = await gw.setAnswer('strategize', 'big_pieces', { text: '  Ledger first, then the importer, then the view.  ' }, A, deps);
+    assert.equal(r.changed, true);
+    const a = qOf(r, 'big_pieces').answer;
+    assert.equal(a.state, 'answered');
+    assert.equal(a.text, 'Ledger first, then the importer, then the view.');
+    assert.equal(a.origin, 'founder');
+    assert.equal(a.carried_over, false);
+  });
+
+  await test(`${label}: "not sure yet", skipped and empty are three different states`, async () => {
+    await gw.setAnswer('strategize', 'risks', { state: 'not_sure', text: 'depends on the bank API' }, A, deps);
+    await gw.setAnswer('strategize', 'try_first', { state: 'skipped' }, A, deps);
+    const r = await gw.readStage('strategize', deps);
+    assert.equal(qOf(r, 'risks').answer.state, 'not_sure');
+    assert.equal(qOf(r, 'risks').answer.text, 'depends on the bank API');
+    assert.equal(qOf(r, 'try_first').answer.state, 'skipped');
+    assert.equal(qOf(r, 'change_course').answer, null, 'never touched is empty, not skipped');
+    assert.deepEqual(r.work.counts, { total: 4, answered: 1, not_sure: 1, skipped: 1, empty: 1 });
+  });
+
+  await test(`${label}: revising replaces the answer and keeps what it used to say`, async () => {
+    const r = await gw.setAnswer('strategize', 'risks', { text: 'The bank API may not allow read-only access.' }, A, deps);
+    assert.equal(qOf(r, 'risks').answer.state, 'answered');
+    const h = await gw.answerHistory('strategize', 'risks', deps);
+    assert.equal(h.ok, true);
+    assert.deepEqual(h.history.map((x) => x.state), ['answered', 'not_sure'], 'newest first');
+    assert.equal(h.history[1].text, 'depends on the bank API');
+  });
+
+  await test(`${label}: a write that changes nothing writes nothing`, async () => {
+    const r = await gw.setAnswer('strategize', 'risks', { text: 'The bank API may not allow read-only access.' }, A, deps);
+    assert.equal(r.changed, false);
+    assert.equal((await gw.answerHistory('strategize', 'risks', deps)).history.length, 2);
+  });
+
+  await test(`${label}: un-answering goes back to EMPTY (not skipped) and is recorded`, async () => {
+    const r = await gw.clearAnswer('strategize', 'try_first', A, deps);
+    assert.equal(r.cleared, true);
+    assert.equal(qOf(r, 'try_first').answer, null);
+    assert.equal(r.work.counts.skipped, 0);
+    assert.equal(r.work.counts.empty, 2);
+    const h = await gw.answerHistory('strategize', 'try_first', deps);
+    assert.equal(h.history[0].state, 'cleared');
+    const again = await gw.clearAnswer('strategize', 'try_first', A, deps);
+    assert.equal(again.cleared, false, 'clearing an empty question is a no-op');
+  });
+
+  await test(`${label}: switching doors keeps the answers, the page and the link`, async () => {
+    await gw.setDoor('strategize', 'open', A, deps);
+    await gw.setPage('strategize', 'We bet on the ledger. Everything else waits.', A, deps);
+    await gw.setLink('strategize', 'https://example.com/strategy', A, deps);
+    let r = await gw.setDoor('strategize', 'assisted', A, deps);
+    assert.equal(r.work.door, 'assisted');
+    r = await gw.setDoor('strategize', 'guided', A, deps);
+    assert.equal(r.work.page, 'We bet on the ledger. Everything else waits.');
+    assert.equal(r.work.link, 'https://example.com/strategy');
+    assert.equal(r.work.counts.answered, 2, 'answers survive every switch');
+  });
+
+  await test(`${label}: a carried-over answer fills only what is empty, and the founder's edit makes it theirs`, async () => {
+    const kept = await gw.setAnswer('strategize', 'big_pieces', { text: 'from the pre-sign-up chat', origin: 'carried_over' }, null, deps, { ifEmpty: true });
+    assert.equal(kept.changed, false);
+    assert.equal(qOf(kept, 'big_pieces').answer.origin, 'founder', 'never overwrites the founder');
+    const filled = await gw.setAnswer('strategize', 'change_course', { text: 'If nobody connects a bank in a month.', origin: 'carried_over' }, null, deps, { ifEmpty: true });
+    assert.equal(qOf(filled, 'change_course').answer.carried_over, true);
+    const mine = await gw.setAnswer('strategize', 'change_course', { text: 'If nobody connects a bank in two months.' }, A, deps);
+    assert.equal(qOf(mine, 'change_course').answer.origin, 'founder');
+  });
+
+  await test(`${label}: the read path a planning session uses says what the founder said`, async () => {
+    const { markdown, stages } = await gw.readContext(deps);
+    assert.equal(stages.length, 5);
+    assert.match(markdown, /^# What the founder has said about this project/);
+    assert.match(markdown, /## Strategize/);
+    assert.match(markdown, /Ledger first, then the importer, then the view\./);
+    assert.match(markdown, /We bet on the ledger/);
+    assert.match(markdown, /https:\/\/example\.com\/strategy/);
+    assert.doesNotMatch(markdown, /## Scope/, 'a stage with nothing in it is left out');
+  });
+
+  // ── the scope interview (task 1005114) ──
+  await test(`${label}: scope's interview is its guided door: six questions, all empty, guided first`, async () => {
+    const r = await gw.readStage('scope', deps);
+    assert.equal(r.work.door, 'guided');
+    assert.deepEqual(r.work.questions.map((q) => q.id),
+      ['what_creating', 'goal_impact', 'success_two_years', 'reach_who', 'work_with_who', 'others_wrong']);
+    assert.deepEqual([...new Set(r.work.questions.map((q) => q.group))], ['What and why', 'Who', 'The bet']);
+    assert.equal(r.work.counts.empty, 6);
+  });
+
+  await test(`${label}: scope stores answers, "not sure yet", a skip, an un-answer and a revision`, async () => {
+    await gw.setAnswer('scope', 'what_creating', { text: 'A live picture of each business you run.' }, A, deps);
+    await gw.setAnswer('scope', 'success_two_years', { state: 'not_sure', text: 'depends on whether others want it' }, A, deps);
+    await gw.setAnswer('scope', 'work_with_who', { state: 'skipped' }, A, deps);
+    await gw.setAnswer('scope', 'others_wrong', { text: 'They value a business from the outside.' }, A, deps);
+    await gw.clearAnswer('scope', 'work_with_who', A, deps);
+    let r = await gw.setAnswer('scope', 'what_creating', { text: 'A live picture of each business you run, and your worth across them.' }, A, deps);
+    assert.deepEqual(r.work.counts, { total: 6, answered: 2, not_sure: 1, skipped: 0, empty: 3 });
+    assert.equal(qOf(r, 'work_with_who').answer, null, 'un-answered is empty, not skipped');
+    const h = await gw.answerHistory('scope', 'what_creating', deps);
+    assert.equal(h.history.length, 2, 'the founder can see what the answer used to say');
+    assert.equal(h.history[1].text, 'A live picture of each business you run.');
+    r = await gw.setAnswer('scope', 'success_two_years', { text: 'Three other founders run their estate on it.' }, A, deps);
+    assert.equal(qOf(r, 'success_two_years').answer.state, 'answered', '"not sure yet" is easy to come back to');
+  });
+
+  await test(`${label}: a session planning a goal reads the scope answers, scope first`, async () => {
+    const { markdown } = await gw.readContext(deps);
+    assert.ok(markdown.indexOf('## Scope') < markdown.indexOf('## Strategize'), 'genesis order');
+    assert.match(markdown, /In a few sentences, what are you creating with this project\?\*\*\n  A live picture of each business you run, and your worth across them\./);
+    assert.match(markdown, /Three other founders run their estate on it\./);
+    assert.match(markdown, /They value a business from the outside\./);
+    assert.doesNotMatch(markdown, /Who do you want working on it with you/, 'an empty question is not printed');
+  });
+}
+
+if (import.meta.url === url.pathToFileURL(process.argv[1]).href) {
+  let passed = 0;
+  let failed = 0;
+  const test = async (name, fn) => {
+    try { await fn(); passed++; console.log(`  ok  ${name}`); }
+    catch (err) { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.stack || err.message}`); }
+  };
+
+  await contract(test, 'memory', { store: memStore() }, 7);
+
+  await test('refusals: unknown stage / question, bad state / origin / door / link, empty answer', async () => {
+    const deps = { store: memStore() };
+    assert.equal((await gw.readStage('decide', deps)).reason, 'unknown_stage');
+    assert.equal((await gw.setAnswer('strategize', 'nope', { text: 'x' }, 1, deps)).reason, 'unknown_question');
+    assert.equal((await gw.setAnswer('strategize', 'risks', { state: 'maybe' }, 1, deps)).reason, 'bad_state');
+    assert.equal((await gw.setAnswer('strategize', 'risks', { text: 'x', origin: 'model' }, 1, deps)).reason, 'bad_origin');
+    assert.equal((await gw.setAnswer('strategize', 'risks', { text: '   ' }, 1, deps)).reason, 'empty_answer');
+    assert.equal((await gw.setAnswer('strategize', 'risks', { text: 'x'.repeat(4001) }, 1, deps)).reason, 'answer_too_long');
+    assert.equal((await gw.setDoor('strategize', 'autopilot', 1, deps)).reason, 'bad_door');
+    assert.equal((await gw.setLink('strategize', 'javascript:alert(1)', 1, deps)).reason, 'bad_link');
+    assert.equal((await gw.clearAnswer('strategize', 'nope', 1, deps)).reason, 'unknown_question');
+    assert.equal(deps.store.answers.size, 0, 'no refusal wrote anything');
+  });
+
+  await test('"not sure yet" needs no words; a skip may carry a note', async () => {
+    const deps = { store: memStore() };
+    const r = await gw.setAnswer('strategize', 'risks', { state: 'not_sure' }, 1, deps);
+    assert.equal(qOf(r, 'risks').answer.state, 'not_sure');
+    assert.equal(qOf(r, 'risks').answer.text, null);
+  });
+
+  await test('a stage that has not adopted questions still takes a page and a link', async () => {
+    const deps = { store: memStore() };
+    const r = await gw.setPage('charter', 'Monarchy to start.', 1, deps);
+    assert.equal(r.work.adopted, false);
+    assert.equal(r.work.page, 'Monarchy to start.');
+    assert.equal((await gw.setAnswer('charter', 'anything', { text: 'x' }, 1, deps)).reason, 'unknown_question');
+  });
+
+  await test('an empty project gives the planning read path nothing to print', async () => {
+    assert.equal((await gw.readContext({ store: memStore() })).markdown, '');
+  });
+
+  await test('the read path labels not-sure, skipped, assisted and carried-over answers', async () => {
+    const deps = { store: memStore() };
+    await gw.setAnswer('strategize', 'risks', { state: 'not_sure', text: 'waiting on the bank' }, 1, deps);
+    await gw.setAnswer('strategize', 'try_first', { state: 'skipped' }, 1, deps);
+    await gw.setAnswer('strategize', 'big_pieces', { text: 'Ledger, then view.', origin: 'assisted' }, 1, deps);
+    await gw.setAnswer('strategize', 'change_course', { text: 'No users.', origin: 'carried_over' }, null, deps);
+    const md = (await gw.readContext(deps)).markdown;
+    assert.match(md, /Not sure yet — waiting on the bank/);
+    assert.match(md, /Skipped by the founder/);
+    assert.match(md, /worked out with an AI session, accepted by the founder/);
+    assert.match(md, /carried over from before sign-up, not yet confirmed/);
+  });
+
+  await test('the assisted door works the stage\'s own questions and leaves the founder the author', async () => {
+    const p = gw.assistPrompt('strategize');
+    assert.match(p, /I am the author; you are my assistant/);
+    for (const q of gw.QUESTIONS.strategize) assert.ok(p.includes(q.ask), `asks: ${q.ask}`);
+    assert.match(p, /Push back/);
+    assert.match(p, /Not sure yet/i);
+    assert.match(p, /npx bongos genesis answer strategize <question-id> "<my words>" --origin assisted/);
+    assert.equal(gw.assistPrompt('decide'), null);
+  });
+
+  await test('the assisted door for scope walks the same interview, ids included, and drafts only from the answers', async () => {
+    const p = gw.assistPrompt('scope');
+    for (const q of gw.QUESTIONS.scope) assert.ok(p.includes(`[${q.id}] ${q.ask}`), `asks: ${q.id}`);
+    assert.match(p, /draft page built only from my answers/);
+  });
+
+  await test('CLI: the scope interview prints under its group headings', async () => {
+    const deps = { store: memStore() };
+    const r = await gw.readStage('scope', deps);
+    const out = formatStage(r.work);
+    assert.ok(out.indexOf('— What and why —') < out.indexOf('— Who —'));
+    assert.ok(out.indexOf('— Who —') < out.indexOf('— The bet —'));
+  });
+
+  await test('question ids are unique and fit the stored shape', async () => {
+    for (const [stage, qs] of Object.entries(gw.QUESTIONS)) {
+      assert.ok(gw.STAGES.includes(stage));
+      const ids = qs.map((q) => q.id);
+      assert.equal(new Set(ids).size, ids.length);
+      for (const id of ids) assert.match(id, /^[a-z][a-z0-9_]{1,39}$/);
+    }
+  });
+
+  await test('CLI: answer arguments become the right body', async () => {
+    assert.deepEqual(parseAnswer(['Ledger', 'first']).body, { state: 'answered', text: 'Ledger first' });
+    assert.deepEqual(parseAnswer(['--not-sure']).body, { state: 'not_sure' });
+    assert.deepEqual(parseAnswer(['--not-sure', 'bank API']).body, { state: 'not_sure', text: 'bank API' });
+    assert.deepEqual(parseAnswer(['--skip']).body, { state: 'skipped' });
+    assert.deepEqual(parseAnswer(['Ledger', '--origin', 'assisted']).body, { state: 'answered', text: 'Ledger', origin: 'assisted' });
+    assert.ok(parseAnswer([]).error);
+    assert.ok(parseAnswer(['--skip', '--not-sure']).error);
+  });
+
+  await test('CLI: a stage prints each answer with its state and origin', async () => {
+    const deps = { store: memStore() };
+    await gw.setAnswer('strategize', 'risks', { state: 'not_sure' }, 1, deps);
+    const r = await gw.setAnswer('strategize', 'big_pieces', { text: 'Ledger', origin: 'assisted' }, 1, deps);
+    const out = formatStage(r.work);
+    assert.match(out, /Strategize — working guided · 1 answered, 1 not sure, 0 skipped, 2 empty/);
+    assert.match(out, /\[not sure yet\]/);
+    assert.match(out, /Ledger \(with AI help\)/);
+    assert.match(out, /\(empty\)/);
+  });
+
+  console.log(`\ngenesis_work: ${passed} passed, ${failed} failed`);
+  if (failed) process.exit(1);
+}

package/tests/genesis_work_db.mjs

@@ -0,0 +1,73 @@
+// tests/genesis_work_db.mjs — the genesis stage-work contract against a REAL Postgres
+// (task 1005116).
+//
+// tests/genesis_work.mjs runs the contract against an in-memory store in the DB-free
+// unit lane. This runs the SAME contract (imported, not copied) through the real
+// Postgres store (genesis-work.js pgStore) over the real migration, so the one-statement
+// answer-plus-history writes, the no-op guard, the if-empty carry-over and the CHECK
+// constraints are proven where they live. Integration lane (run-unit-tests.js).
+//
+// Needs a MIGRATED database (scripts/migrate.sh). SKIPS (exit 0) with no reachable
+// Postgres, like every *_db test.
+//
+// Run:  DATABASE_URL=postgres://... node tests/genesis_work_db.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import url from 'node:url';
+import { contract } from './genesis_work.mjs';
+import { insertTestBuilders } from './helpers.mjs';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(url.fileURLToPath(import.meta.url)), '..');
+const { Pool } = require('pg');
+const gw = require('../modules/onboarding/genesis-work.js');
+const pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+
+try {
+  await pool.query('SELECT 1');
+} catch (e) {
+  console.log(`genesis_work_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}). Set DATABASE_URL to run.`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.stack || err.message}`); }
+}
+
+const MIGRATION = fs.readFileSync(path.join(ROOT, 'modules/onboarding/migrations/onboarding_002_genesis_work.sql'), 'utf8');
+const wipe = () => pool.query('DELETE FROM onboarding_genesis_answers; DELETE FROM onboarding_genesis_answer_history; DELETE FROM onboarding_genesis_work;');
+
+await test('postgres: the migration re-applies cleanly over the migrated schema (idempotent)', async () => {
+  await pool.query(MIGRATION);
+  await pool.query(MIGRATION);
+});
+
+const A = 910000201;
+await insertTestBuilders(pool, [{ id: A, login: 'genesis-a' }]);
+await wipe();
+try {
+  await contract(test, 'postgres', { store: gw.pgStore(pool) }, A);
+  await test('postgres: the CHECKs refuse a wordless answer, a bad state, origin, door and link', async () => {
+    const bad = (sql, params) => assert.rejects(pool.query(sql, params), (e) => e.code === '23514');
+    await bad("INSERT INTO onboarding_genesis_answers (stage, question_id, state, answer_md) VALUES ('scope', 'what', 'answered', '  ')");
+    await bad("INSERT INTO onboarding_genesis_answers (stage, question_id, state) VALUES ('scope', 'what', 'maybe')");
+    await bad("INSERT INTO onboarding_genesis_answers (stage, question_id, state, origin) VALUES ('scope', 'what', 'skipped', 'model')");
+    await bad("INSERT INTO onboarding_genesis_answers (stage, question_id, state) VALUES ('decide', 'what', 'skipped')");
+    await bad("INSERT INTO onboarding_genesis_work (stage, door) VALUES ('charter', 'autopilot')");
+    await bad("INSERT INTO onboarding_genesis_work (stage, link_url) VALUES ('charter', 'javascript:alert(1)')");
+  });
+} finally {
+  await wipe().catch(() => {});
+  await pool.query('DELETE FROM builders WHERE id = $1', [A]).catch(() => {});
+  await pool.end().catch(() => {});
+}
+
+console.log(`\ngenesis_work_db: ${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);

package/tests/genesis_work_routes.mjs

@@ -0,0 +1,130 @@
+// tests/genesis_work_routes.mjs — the genesis stage-work HTTP surface (task 1005116)
+//
+// Drives the REAL routes (modules/onboarding/routes/genesis-work.js) over a real express
+// server and an in-memory store. Auth is stubbed at the doorway the way other route
+// tests do it: a request names its builder in `x-test-builder`, and only the builder
+// named in `x-test-owner` holds `project.settings.manage`. What it proves: any builder
+// reads, only the owner writes, a refusal is a 4xx with its code, un-answer is DELETE,
+// and the planning read path comes back over the wire.
+//
+// Run:  node tests/genesis_work_routes.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { memStore } from './genesis_work.mjs';
+
+const require = createRequire(import.meta.url);
+const express = require('express');
+const api = require('../src/module-api.js');
+
+const OWNER = 1;
+const OTHER = 2;
+api.requireBuilder = (req, res, next) => {
+  const id = Number(req.get('x-test-builder'));
+  if (!id) return res.status(401).json({ error: { code: 'unauthenticated' } });
+  req.builder = { id };
+  next();
+};
+api.requirePermission = () => (req, res, next) => (req.builder.id === OWNER ? next() : res.status(403).json({ error: { code: 'forbidden' } }));
+
+const mount = require('../modules/onboarding/routes/genesis-work.js');
+const store = memStore();
+const app = express();
+app.use(express.json());
+const router = express.Router();
+mount(router, { store });
+app.use('/api/bongos', router);
+const server = app.listen(0);
+const base = `http://127.0.0.1:${server.address().port}/api/bongos`;
+
+async function call(method, path, { as = OWNER, body } = {}) {
+  const r = await fetch(base + path, {
+    method,
+    headers: { 'content-type': 'application/json', ...(as ? { 'x-test-builder': String(as) } : {}) },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  return { status: r.status, data: await r.json() };
+}
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.stack || err.message}`); }
+}
+
+try {
+  await test('reads need a signed-in builder', async () => {
+    assert.equal((await call('GET', '/founding/work', { as: null })).status, 401);
+  });
+
+  await test('the owner answers, and any builder reads the answer back', async () => {
+    const w = await call('PUT', '/founding/work/strategize/answers/big_pieces', { body: { text: 'Ledger first.' } });
+    assert.equal(w.status, 200);
+    assert.equal(w.data.changed, true);
+    const r = await call('GET', '/founding/work/strategize', { as: OTHER });
+    assert.equal(r.status, 200);
+    assert.equal(r.data.work.questions.find((q) => q.id === 'big_pieces').answer.text, 'Ledger first.');
+  });
+
+  await test('a builder who is not the owner cannot write', async () => {
+    for (const [m, p, body] of [
+      ['PUT', '/founding/work/strategize/answers/risks', { text: 'x' }],
+      ['DELETE', '/founding/work/strategize/answers/big_pieces'],
+      ['PUT', '/founding/work/strategize/door', { door: 'open' }],
+      ['PUT', '/founding/work/strategize/page', { page: 'x' }],
+      ['PUT', '/founding/work/strategize/link', { url: 'https://example.com' }],
+    ]) assert.equal((await call(m, p, { as: OTHER, body })).status, 403, `${m} ${p}`);
+    assert.equal(store.answers.size, 1, 'nothing was written');
+  });
+
+  await test('"not sure yet" over the wire, then un-answer back to empty', async () => {
+    const ns = await call('PUT', '/founding/work/strategize/answers/risks', { body: { state: 'not_sure' } });
+    assert.equal(ns.data.work.questions.find((q) => q.id === 'risks').answer.state, 'not_sure');
+    const del = await call('DELETE', '/founding/work/strategize/answers/risks');
+    assert.equal(del.status, 200);
+    assert.equal(del.data.cleared, true);
+    assert.equal(del.data.work.questions.find((q) => q.id === 'risks').answer, null);
+    const h = await call('GET', '/founding/work/strategize/answers/risks/history', { as: OTHER });
+    assert.deepEqual(h.data.history.map((x) => x.state), ['cleared', 'not_sure']);
+  });
+
+  await test('refusals come back as 4xx with their code', async () => {
+    const cases = [
+      ['PUT', '/founding/work/strategize/answers/nope', { text: 'x' }, 404, 'unknown_question'],
+      ['GET', '/founding/work/decide', undefined, 404, 'unknown_stage'],
+      ['PUT', '/founding/work/strategize/answers/risks', { text: ' ' }, 400, 'empty_answer'],
+      ['PUT', '/founding/work/strategize/door', { door: 'autopilot' }, 400, 'bad_door'],
+      ['PUT', '/founding/work/strategize/link', { url: 'ftp://x' }, 400, 'bad_link'],
+    ];
+    for (const [m, p, body, status, code] of cases) {
+      const r = await call(m, p, { body });
+      assert.equal(r.status, status, `${m} ${p}`);
+      assert.equal(r.data.error.code, code);
+    }
+    const unknownField = await call('PUT', '/founding/work/strategize/door', { body: { door: 'open', extra: 1 } });
+    assert.equal(unknownField.status, 400, 'an unknown field is refused');
+  });
+
+  await test('switching door over the wire keeps the answers', async () => {
+    await call('PUT', '/founding/work/strategize/page', { body: { page: 'Bet on the ledger.' } });
+    const r = await call('PUT', '/founding/work/strategize/door', { body: { door: 'open' } });
+    assert.equal(r.data.work.door, 'open');
+    assert.equal(r.data.work.page, 'Bet on the ledger.');
+    assert.equal(r.data.work.counts.answered, 1);
+  });
+
+  await test('the planning read path and the assisted brief are readable by any builder', async () => {
+    const c = await call('GET', '/founding/context', { as: OTHER });
+    assert.equal(c.status, 200);
+    assert.match(c.data.markdown, /Ledger first\./);
+    assert.match(c.data.markdown, /Bet on the ledger\./);
+    const a = await call('GET', '/founding/work/strategize/assist', { as: OTHER });
+    assert.match(a.data.prompt, /I am the author/);
+  });
+} finally {
+  server.close();
+}
+
+console.log(`\ngenesis_work_routes: ${passed} passed, ${failed} failed`);
+if (failed) process.exit(1);