@bongos/core 1.25.15 → 1.25.17

package/tests/first_read.mjs

@@ -0,0 +1,303 @@
+// tests/first_read.mjs — THE FIRST READ-THROUGH of a project that already exists (task
+// 1005280, goal 1000106).
+//
+// Done-when: an adopted project's Genesis step hands the owner a prompt for their OWN AI
+// session; that session's map comes back in a defined, validated shape; the owner
+// accepts it whole or item by item into DRAFT goals and tasks; a rejection files
+// nothing; a re-run files nothing twice; the shape has room for task 1005281's
+// recommended modules.
+//
+// Everything here RUNS: the real prompt and Genesis checklist, the real validator and
+// acceptance planner, the real store over an in-memory fake pool, and the real router
+// over a socket.
+
+import { strict as assert } from 'node:assert';
+import { test, after } from 'node:test';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const fr = require('../modules/lifecycle/first-read.js');
+const storeModule = require('../modules/lifecycle/first-read-db.js');
+// A snapshot of the real store: the route section below re-points the module's exports
+// at its own pool, and module-level code runs before any test does.
+const store = { ...storeModule };
+const { genesisChecklist } = require('../modules/lifecycle/kickoff-checklist.js');
+
+const clone = (o) => JSON.parse(JSON.stringify(o));
+
+// ── an in-memory pool that answers exactly the store's statements ─────────────
+
+function fakePool() {
+  const s = { maps: [], filed: new Map(), goals: [], tasks: [], nextId: 1 };
+  const query = async (sql, p = []) => {
+    const q = sql.replace(/\s+/g, ' ').trim();
+    if (/^(BEGIN|COMMIT|ROLLBACK)$/.test(q) || /pg_advisory_xact_lock/.test(q)) return { rows: [] };
+    if (/^INSERT INTO lifecycle_repo_maps/.test(q)) {
+      const row = { id: String(s.nextId++), schema: p[0], map: JSON.parse(p[1]), status: 'pending', submitted_by: p[2], submitted_at: new Date() };
+      s.maps.push(row); return { rows: [row] };
+    }
+    if (/FROM lifecycle_repo_maps ORDER BY/.test(q)) return { rows: s.maps.slice(-1) };
+    if (/^SELECT .* FROM lifecycle_repo_maps WHERE id = \$1/.test(q)) return { rows: s.maps.filter((m) => m.id === String(p[0])) };
+    if (/^SELECT ref, kind, entity_id FROM lifecycle_repo_map_filed/.test(q)) {
+      return { rows: p[0].filter((r) => s.filed.has(r)).map((r) => ({ ref: r, ...s.filed.get(r) })) };
+    }
+    if (/^INSERT INTO lifecycle_repo_map_filed .* unnest/.test(q)) {
+      s.filedWrites = (s.filedWrites || 0) + 1;
+      p[0].forEach((ref, i) => {
+        if (s.filed.has(ref)) throw Object.assign(new Error('duplicate key'), { code: '23505' });
+        s.filed.set(ref, { kind: p[1][i], entity_id: p[2][i], map_id: p[3] });
+      });
+      return { rows: [] };
+    }
+    if (/^SELECT id FROM versions/.test(q)) return { rows: [{ id: 'V1' }] };
+    if (/^UPDATE lifecycle_repo_maps SET status = 'accepted'/.test(q)) { s.maps.find((m) => m.id === String(p[0])).status = 'accepted'; return { rows: [] }; }
+    if (/^UPDATE lifecycle_repo_maps SET status = 'rejected'/.test(q)) {
+      const m = s.maps.find((x) => x.id === String(p[0]) && x.status === 'pending');
+      if (!m) return { rows: [] };
+      m.status = 'rejected'; return { rows: [{ id: m.id }] };
+    }
+    throw new Error('unexpected SQL: ' + q);
+  };
+  const pool = { query, connect: async () => ({ query, release() {} }), state: s };
+  const deps = {
+    pool,
+    createGoal: async (row, d) => { assert.ok(d && d.client, 'goals are created inside the accept transaction'); const g = { id: String(100 + s.goals.length), ...row }; s.goals.push(g); return g; },
+    createTask: async (row, d) => { assert.ok(d && d.client, 'tasks are created inside the accept transaction'); const t = { id: String(500 + s.tasks.length), ...row }; s.tasks.push(t); return t; },
+  };
+  return { pool, deps, s };
+}
+
+// ── the prompt ───────────────────────────────────────────────────────────────
+
+test('the prompt sends the owner\'s own session to read locally, map in the defined shape, and accept only with a yes', () => {
+  const p = fr.firstReadPrompt();
+  for (const must of [
+    'own AI session', 'Bongos itself never reads this repository', 'Do not upload, paste or send any source code',
+    fr.MAP_FILE, fr.SCHEMA, '"goals"', '"next"', '"why"', '"seen_at"', 'errors or mishaps',
+    'first-read check', 'first-read submit', 'first-read accept', 'first-read reject', 'Never accept on your own',
+    'not filed twice',
+  ]) assert.ok(p.includes(must), `the prompt says: ${must}`);
+  // The example it prints is itself a valid map, so a session that copies it is on the shape.
+  assert.equal(fr.validateRepoMap(fr.exampleMap()).ok, true);
+  const printed = JSON.parse(p.slice(p.indexOf('{'), p.lastIndexOf('}') + 1));
+  assert.deepEqual(printed, fr.exampleMap());
+});
+
+test('an adopted project\'s Genesis step carries the prompt; a new project\'s does not', () => {
+  const existing = genesisChecklist({ existing: true }).scope;
+  assert.equal(existing[0].ref, 'genesis:scope:existing', 'the step keeps its ref, so a seeded project is not refiled');
+  assert.ok(existing[0].description.includes(fr.firstReadPrompt()), 'the hall copy-prompt hands over the whole prompt');
+  assert.ok(/own AI/.test(existing[0].title));
+  const fresh = genesisChecklist().scope;
+  assert.ok(fresh.every((t) => !t.description.includes(fr.SCHEMA)));
+});
+
+// ── validation ───────────────────────────────────────────────────────────────
+
+test('a good map validates into a flat review list with stable refs', () => {
+  const v = fr.validateRepoMap(fr.exampleMap());
+  assert.equal(v.ok, true);
+  assert.deepEqual(v.items.map((i) => [i.type, i.ref]), [
+    ['goal', 'goal:take-payments-for-bookings'],
+    ['task', 'task:take-payments-for-bookings:finish-the-checkout-page'],
+    ['task', 'task:take-payments-for-bookings:send-a-receipt-by-email'],
+    ['next', 'next:fix-the-failing-booking-test'],
+  ]);
+  assert.ok(v.items.every((i) => i.why && i.seen_at.length));
+  assert.equal(v.items[3].goal_ref, fr.NEXT_GOAL.ref, 'a next item naming no goal lands under the fix-what-was-found goal');
+});
+
+test('a later section (recommended modules) rides along without breaking the shape', () => {
+  const raw = { ...fr.exampleMap(), recommended_modules: [{ key: 'payments', why: 'a checkout exists' }] };
+  const v = fr.validateRepoMap(raw);
+  assert.equal(v.ok, true);
+  assert.deepEqual(v.map.recommended_modules, raw.recommended_modules);
+});
+
+test('a prototype-shaped key in the map is never copied onto it', () => {
+  const raw = JSON.parse(`{"schema":"${fr.SCHEMA}","summary":"s","next":[{"title":"t","why":"w","seen_at":["a"]}],"__proto__":{"polluted":true},"constructor":{"x":1}}`);
+  const v = fr.validateRepoMap(raw);
+  assert.equal(v.ok, true);
+  assert.equal(v.map.polluted, undefined);
+  assert.equal(Object.getPrototypeOf(v.map), Object.prototype);
+  assert.ok(!Object.prototype.hasOwnProperty.call(v.map, 'constructor'));
+  assert.equal(({}).polluted, undefined);
+});
+
+test('malformed maps are refused, each error naming its field', () => {
+  const cases = [
+    [null, /JSON object/],
+    [[], /JSON object/],
+    [{ ...fr.exampleMap(), schema: 'other/1' }, /schema must be/],
+    [{ ...fr.exampleMap(), goals: 'lots' }, /goals must be a list/],
+    [{ schema: fr.SCHEMA, summary: 'x', goals: [], next: [] }, /no goals and nothing next/],
+    [(() => { const m = fr.exampleMap(); delete m.goals[0].why; return m; })(), /goals\[0\]\.why is missing/],
+    [(() => { const m = fr.exampleMap(); m.goals[0].tasks[0].seen_at = []; return m; })(), /goals\[0\]\.tasks\[0\]\.seen_at needs at least one place/],
+    [(() => { const m = fr.exampleMap(); m.goals[0].tasks[1].status = 'half'; return m; })(), /status must be one of/],
+    [(() => { const m = fr.exampleMap(); m.goals[0].tasks[1].title = m.goals[0].tasks[0].title; return m; })(), /repeats another item's title/],
+    [(() => { const m = fr.exampleMap(); m.next[0].goal = 'No such goal'; return m; })(), /not a goal in this map/],
+    [(() => { const m = fr.exampleMap(); m.next[0].kind = 'oops'; return m; })(), /kind must be one of/],
+    [(() => { const m = fr.exampleMap(); m.goals[0].why = 'x'.repeat(fr.LIMITS.WHY + 1); return m; })(), /longer than/],
+    [(() => { const m = fr.exampleMap(); m.summary = 'y'.repeat(fr.LIMITS.BYTES); return m; })(), /larger than/],
+    [(() => { const m = fr.exampleMap(); m.goals[0].title = '!!!'; return m; })(), /needs letters or numbers/],
+  ];
+  for (const [raw, re] of cases) {
+    const v = fr.validateRepoMap(raw);
+    assert.equal(v.ok, false, `refused: ${re}`);
+    assert.ok(v.errors.some((e) => re.test(e)), `${re} in ${JSON.stringify(v.errors)}`);
+  }
+});
+
+// ── the store: submit, accept, reject, re-run ────────────────────────────────
+
+test('submitting files nothing: the map waits pending', async () => {
+  const { deps, s } = fakePool();
+  const out = await store.submitMap({ raw: fr.exampleMap(), builderId: '1' }, deps);
+  assert.equal(out.ok, true);
+  assert.equal(s.maps[0].status, 'pending');
+  assert.equal(s.goals.length + s.tasks.length, 0);
+  const bad = await store.submitMap({ raw: { schema: 'nope' } }, deps);
+  assert.equal(bad.ok, false);
+  assert.equal(s.maps.length, 1, 'a malformed map is not stored');
+});
+
+test('accepting the whole map files draft goals and backlog tasks, nothing claimable', async () => {
+  const { deps, s } = fakePool();
+  const { map_id } = await store.submitMap({ raw: fr.exampleMap(), builderId: '1' }, deps);
+  const out = await store.acceptMap({ mapId: map_id, select: 'all', builderId: '1' }, deps);
+  assert.equal(out.ok, true);
+  assert.deepEqual(s.goals.map((g) => g.title), ['Take payments for bookings', fr.NEXT_GOAL.title]);
+  assert.equal(s.tasks.length, 3);
+  for (const t of s.tasks) {
+    assert.equal(t.status, 'backlog');
+    assert.equal(t.source, store.TASK_SOURCE);
+    assert.ok(t.goalId, 'every task has a goal home');
+    assert.ok(t.description.includes('Seen at:'));
+  }
+  assert.equal(s.tasks.find((t) => t.title === 'Fix the failing booking test').kind, 'bug');
+  assert.equal(s.tasks.find((t) => t.title === 'Fix the failing booking test').goalId, s.goals[1].id);
+  assert.equal(s.maps[0].status, 'accepted');
+  assert.equal(s.filedWrites, 1, 'every filed ref is remembered in one statement');
+  assert.equal(s.filed.size, 5);
+});
+
+test('accepting item by item files only what the owner chose (and the goal it needs)', async () => {
+  const { deps, s } = fakePool();
+  const { map_id } = await store.submitMap({ raw: fr.exampleMap() }, deps);
+  const out = await store.acceptMap({ mapId: map_id, select: ['task:take-payments-for-bookings:send-a-receipt-by-email'] }, deps);
+  assert.equal(out.ok, true);
+  assert.deepEqual(s.goals.map((g) => g.title), ['Take payments for bookings']);
+  assert.deepEqual(s.tasks.map((t) => t.title), ['Send a receipt by email']);
+  const unknown = await store.acceptMap({ mapId: map_id, select: ['task:nope'] }, deps);
+  assert.equal(unknown.code, 'unknown_items');
+  const none = await store.acceptMap({ mapId: map_id, select: [] }, deps);
+  assert.equal(none.code, 'nothing_selected');
+  assert.equal(s.tasks.length, 1, 'a refused accept files nothing');
+});
+
+test('a task the map says is done is shown, never filed', async () => {
+  const { deps, s } = fakePool();
+  const raw = fr.exampleMap();
+  raw.goals[0].tasks[0].status = 'done';
+  const { map_id } = await store.submitMap({ raw }, deps);
+  const out = await store.acceptMap({ mapId: map_id, select: 'all' }, deps);
+  assert.ok(out.skipped.some((x) => x.reason === 'already_done'));
+  assert.ok(!s.tasks.some((t) => t.title === 'Finish the checkout page'));
+});
+
+test('rejecting files nothing, and a rejected map cannot then be accepted', async () => {
+  const { deps, s } = fakePool();
+  const { map_id } = await store.submitMap({ raw: fr.exampleMap() }, deps);
+  assert.equal((await store.rejectMap({ mapId: map_id, builderId: '1' }, deps)).ok, true);
+  assert.equal(s.maps[0].status, 'rejected');
+  const again = await store.acceptMap({ mapId: map_id, select: 'all' }, deps);
+  assert.equal(again.code, 'map_rejected');
+  assert.equal(s.goals.length + s.tasks.length, 0);
+  assert.equal((await store.rejectMap({ mapId: map_id }, deps)).code, 'not_pending');
+  assert.equal((await store.rejectMap({ mapId: '99' }, deps)).code, 'not_found');
+});
+
+test('a re-run does not duplicate: the same items are skipped, only new ones are filed', async () => {
+  const { deps, s } = fakePool();
+  const first = await store.submitMap({ raw: fr.exampleMap() }, deps);
+  await store.acceptMap({ mapId: first.map_id, select: 'all' }, deps);
+  const goalsBefore = s.goals.length;
+  const tasksBefore = s.tasks.length;
+  // Accepting the same map again files nothing.
+  const twice = await store.acceptMap({ mapId: first.map_id, select: 'all' }, deps);
+  assert.equal(twice.filed.goals.length + twice.filed.tasks.length, 0);
+  // A second read-through names the same items (reordered, retitled in case) plus one new task.
+  const raw = clone(fr.exampleMap());
+  raw.goals[0].title = 'TAKE PAYMENTS FOR BOOKINGS';
+  raw.goals[0].tasks.reverse();
+  raw.goals[0].tasks.push({ title: 'Refund a booking', status: 'not_started', why: 'No refund path exists.', seen_at: ['src/payments/'] });
+  const second = await store.submitMap({ raw }, deps);
+  const review = await store.reviewMap('latest', deps);
+  assert.equal(review.map_id, second.map_id);
+  assert.equal(review.items.filter((i) => i.filed).length, 4, 'the review marks what is already in Bongos');
+  const out = await store.acceptMap({ mapId: second.map_id, select: 'all' }, deps);
+  assert.equal(s.goals.length, goalsBefore, 'no goal filed twice');
+  assert.equal(s.tasks.length, tasksBefore + 1);
+  assert.deepEqual(out.filed.tasks.map((t) => t.title), ['Refund a booking']);
+  assert.equal(out.filed.tasks[0].goal_id, s.goals[0].id, 'the new task joins the goal filed by the first run');
+  assert.equal(out.skipped.filter((x) => x.reason === 'already_filed').length, 4);
+});
+
+// ── the routes, over a real socket ───────────────────────────────────────────
+
+const express = require('express');
+const api = require('../src/module-api.js');
+const perms = [];
+api.requireBuilder = (req, _res, next) => { req.builder = { id: '7', rank: 'archon' }; next(); };
+api.requirePermission = (...p) => { perms.push(p.join(',')); return (_req, _res, next) => next(); };
+api.requireActAlone = (area) => { perms.push('act-alone:' + area); return (_req, _res, next) => next(); };
+
+const route = fakePool();
+for (const fn of ['submitMap', 'reviewMap', 'acceptMap', 'rejectMap']) {
+  storeModule[fn] = (a) => store[fn](a, route.deps);
+}
+const app = express();
+app.use(express.json());
+app.use((req, res, next) => {
+  res.fail = (code, status, details) => res.status(status || 400).json({ error: code, ...(details || {}) });
+  next();
+});
+app.use('/api/bongos', require('../modules/lifecycle/routes/first-read.js')());
+const server = app.listen(0);
+await new Promise((r) => server.once('listening', r));
+after(() => server.close());
+const base = `http://127.0.0.1:${server.address().port}/api/bongos`;
+const call = async (method, p, body) => {
+  const r = await fetch(base + p, { method, headers: { 'content-type': 'application/json' }, body: body ? JSON.stringify(body) : undefined });
+  return { status: r.status, body: await r.json().catch(() => null) };
+};
+
+test('the routes: filing is gated like creating a goal, and the flow runs end to end', async () => {
+  assert.ok(perms.includes('goal.create'));
+  assert.ok(perms.includes('act-alone:planning'));
+  const prompt = await call('GET', '/first-read/prompt');
+  assert.equal(prompt.status, 200);
+  assert.equal(prompt.body.prompt, fr.firstReadPrompt());
+
+  const bad = await call('POST', '/first-read/maps', { map: { schema: fr.SCHEMA, summary: 'x', goals: [{ title: 'A' }] } });
+  assert.equal(bad.status, 400);
+  assert.equal(bad.body.error, 'invalid_map');
+  assert.ok(bad.body.errors.length >= 2);
+
+  const ok = await call('POST', '/first-read/maps', { map: fr.exampleMap() });
+  assert.equal(ok.status, 201);
+  assert.equal(route.s.tasks.length, 0, 'submit files nothing');
+
+  const bogus = await call('POST', `/first-read/maps/${ok.body.map_id}/accept`, { items: ['x'], all: true });
+  assert.equal(bogus.status, 400);
+  const accepted = await call('POST', `/first-read/maps/${ok.body.map_id}/accept`, { items: ['goal:take-payments-for-bookings'] });
+  assert.equal(accepted.status, 200);
+  assert.equal(accepted.body.filed.goals.length, 1);
+  assert.equal(accepted.body.filed.tasks.length, 0);
+
+  const shown = await call('GET', '/first-read/maps/latest');
+  assert.equal(shown.status, 200);
+  assert.equal(shown.body.items.find((i) => i.ref === 'goal:take-payments-for-bookings').filed.kind, 'goal');
+  assert.equal((await call('GET', '/first-read/maps/999')).status, 404);
+  assert.equal((await call('POST', `/first-read/maps/${ok.body.map_id}/reject`)).status, 409, 'an accepted map is not then rejected');
+});

package/tests/genesis_home.mjs

@@ -46,17 +46,54 @@ test('genesis files a task per stage, keyed by a ref that names the step, not it
 
 test('the seeder files every genesis step once, under the catch-all, and never twice', async () => {
   const filed = [];
+  const edges = [];
   const deps = {
     pool: { query: async () => ({ rows: [{ id: 'V1' }] }) },
-    createTask: async (row) => { filed.push(row); },
+    createTask: async (row) => { filed.push({ ...row, id: 100 + filed.length }); },
     findTaskBySourceRef: async ({ source, sourceRef }) => filed.find((r) => r.source === source && r.sourceRef === sourceRef) || null,
+    addTaskDependency: async (id, dep) => { edges.push([id, dep]); },
   };
   const first = await seed.seedGenesisStages({ builderId: 1 }, deps);
   assert.equal(first.seeded, 5);
   assert.ok(filed.every((r) => r.status === 'ready' && r.source === 'genesis' && r.allowCatchAll === true && r.versionId === 'V1'));
+  assert.deepEqual(edges, [], 'a new project: every stage has one step, nothing waits on anything');
   const again = await seed.seedGenesisStages({ builderId: 1, existing: true }, deps);
   assert.equal(again.seeded, 1, 'a second run files only the step that was not there (the brownfield one)');
   assert.equal(filed.length, 6);
+  const scope = filed.find((r) => r.sourceRef === 'genesis:scope');
+  const gather = filed.find((r) => r.sourceRef === 'genesis:scope:existing');
+  assert.deepEqual(edges, [[scope.id, gather.id]], 'writing the scope waits on gathering what exists (task 1005110)');
+});
+
+test('the checklist declares order only where it is real: brownfield scope (task 1005110)', () => {
+  const fresh = genesisChecklist({});
+  assert.ok(Object.values(fresh).flat().every((t) => t.after === null), 'a new project: all open');
+  const old = genesisChecklist({ existing: true });
+  assert.deepEqual(old.scope.map((t) => [t.ref, t.after]), [
+    ['genesis:scope:existing', null],
+    ['genesis:scope', 'genesis:scope:existing'],
+  ]);
+  for (const k of ['strategize', 'charter', 'legalize', 'legislation']) assert.equal(old[k][0].after, null);
+});
+
+test('the board read says what each task waits on, from the dependency edges (task 1005110)', async () => {
+  let seen = '';
+  const pool = { query: async (sql) => {
+    seen = sql;
+    return { rows: [
+      { id: 1, title: 'Gather', status: 'ready', description: '', source_ref: 'genesis:scope:existing', waits_on: [] },
+      { id: 2, title: 'Write', status: 'ready', description: '', source_ref: 'genesis:scope', waits_on: [{ id: 1, title: 'Gather' }] },
+    ] };
+  } };
+  const out = await seed.genesisStageTasks({ pool });
+  assert.match(seen, /FROM dependencies d/);
+  assert.match(seen, /x\.status <> 'shipped'/, 'the claim gate\'s own rule: only a shipped task stops blocking');
+  assert.deepEqual(out.scope[1].waits_on, [{ id: '1', title: 'Gather' }]);
+  const g = gh.shapeGenesis({ mode: { stage: 'scope', stage_number: 1, stage_count: 5, day: 1 }, plan: gh.parsePlan({}).plan, tasks: out });
+  assert.deepEqual(g.stages[0].tasks.map((t) => t.state), ['open', 'locked']);
+  const done = gh.shapeGenesis({ mode: { stage: 'scope', stage_number: 1, stage_count: 5, day: 1 }, plan: gh.parsePlan({}).plan,
+    tasks: { scope: [{ id: '1', title: 'Gather', status: 'shipped' }, { id: '2', title: 'Write', status: 'ready', waits_on: [] }] } });
+  assert.deepEqual(done.stages[0].tasks.map((t) => t.state), ['done', 'open'], 'once the first ships, the second opens');
 });
 
 test('the board read groups genesis tasks by the stage their ref names', async () => {
@@ -389,7 +426,7 @@ function bootCard({ founding, data = { genesis: null } }) {
   const attrs = founding ? { 'data-founding': 'on' } : {};
   const sandbox = {
     window: {
-      OTB: { escapeHtml: (s) => String(s), statusPill: (s) => `<span>${s}</span>`, contributeHallWidget: (w) => { widget = w; }, toast: (m) => toasts.push(m) },
+      OTB: { escapeHtml: (s) => String(s), statusPill: (s) => `<span>${s}</span>`, contributeHallWidget: (w) => { widget = w; }, toast: (m) => toasts.push(m), CHECK_SVG: '<svg/>' },
       BongosClient: { createClient: () => ({ request: async (m, p) => { calls.push(`${m} ${p}`); return { ok: true, status: 200, data }; } }) },
     },
     navigator: { clipboard: { writeText: async (t) => { copied.push(t); } } },
@@ -537,6 +574,37 @@ test('each open stage task has Copy prompt, and it copies the task\'s own words
   assert.match(b.toasts.join(' '), /copied/i);
 });
 
+test('the stage reads as a checklist: done, open and locked, and a locked row offers no prompt (task 1005110)', async () => {
+  const genesis = gh.shapeGenesis({
+    mode: { stage: 'scope', stage_number: 1, stage_count: 5, day: 1 },
+    plan: gh.parsePlan({}).plan,
+    tasks: { scope: [
+      { id: '301', title: 'Gather what already exists', status: 'ready', description: 'Link it.' },
+      { id: '302', title: 'Write the scope', status: 'ready', description: 'Write it.', waits_on: [{ id: '301', title: 'Gather what already exists' }] },
+    ], strategize: [{ id: '303', title: 'Strategy', status: 'shipped' }] },
+  });
+  const b = bootCard({ founding: true, data: { genesis, viewer_id: '1' } });
+  await mountClickable(b);
+  const html = b.host.innerHTML;
+  const row = (id) => html.split('<li ').find((x) => x.includes(`/task/${id}"`)) || '';
+  assert.match(row('301'), /class="genesis__task is-open"/);
+  assert.match(row('301'), /data-genesis-copy="301"/, 'the open row has Copy prompt');
+  assert.match(row('302'), /class="genesis__task is-locked"/);
+  assert.match(row('302'), /after Gather what already exists/, 'a locked row says what it waits on');
+  assert.doesNotMatch(row('302'), /data-genesis-copy/, 'a locked row offers no prompt for work it cannot claim');
+  assert.doesNotMatch(html, /is-finished|line-through/, 'nothing is drawn struck through');
+  // The "done" row: the earlier stage is not the one on screen, so check the shape directly.
+  const done = gh.shapeGenesis({ mode: { stage: 'scope', stage_number: 1, stage_count: 5, day: 1 }, plan: gh.parsePlan({}).plan,
+    tasks: { scope: [{ id: '304', title: 'Gathered', status: 'shipped' }, { id: '305', title: 'Next', status: 'ready' }] } });
+  const b2 = bootCard({ founding: true, data: { genesis: done, viewer_id: '1' } });
+  await mountClickable(b2);
+  const r304 = b2.host.innerHTML.split('<li ').find((x) => x.includes('/task/304"')) || '';
+  assert.match(r304, /class="genesis__task is-done"/);
+  assert.match(r304, /<span class="genesis__mark" aria-hidden="true"><svg/, 'done fills its circle with the hall\'s tick');
+  assert.match(r304, /class="sr-only">Done: /, 'and says so to a screen reader');
+  assert.doesNotMatch(r304, /data-genesis-copy/);
+});
+
 test('the hall carries the five life plates byte-identical to the world\'s', () => {
   const world = path.join(ROOT, 'modules', 'public-landing', 'public', 'assets', 'world');
   const hall = path.join(ROOT, 'modules', 'hall-ui', 'public', 'genesis');

package/tests/genesis_work.mjs

@@ -152,6 +152,41 @@ export async function contract(test, label, deps, A) {
     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) {
@@ -220,6 +255,20 @@ if (import.meta.url === url.pathToFileURL(process.argv[1]).href) {
     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));

package/tests/government_act_alone_buildings.mjs

@@ -216,6 +216,7 @@ for (const rel of [
   'modules/lifecycle/routes/goals.js',
   'modules/lifecycle/routes/versions.js',
   'modules/lifecycle/routes/project-settings.js',
+  'modules/lifecycle/routes/first-read.js',
   'modules/render-deploy/routes/act.js',
   'modules/npm-release/routes/release.js',
   'modules/provisioning/routes/core-upgrade.js',
@@ -262,6 +263,7 @@ const REQUESTS = {
   'POST /goals/reorder': ['POST', '/goals/reorder', {}],
   'POST /work-categories': ['POST', '/work-categories', {}],
   'PUT /versions/focus': ['PUT', '/versions/focus', { version_id: '   ' }],
+  'POST /first-read/maps/:id/accept': ['POST', `/first-read/maps/${BAD}/accept`, { all: true }], // task 1005280
   'POST /autonomy/fence': ['POST', '/autonomy/fence', { enabled: 'yes' }],
   'POST /autonomy/fence/goals': ['POST', '/autonomy/fence/goals', { goal_id: 0 }],
   'DELETE /autonomy/fence/goals/:goalId': ['DELETE', `/autonomy/fence/goals/${BAD}`],