@bongos/core 1.25.18 → 1.25.20

package/tests/founding_mode.mjs

@@ -143,7 +143,8 @@ function makeHall() {
     documentElement: root,
     createElement: (t) => new El(t),
     querySelector: (sel) => (sel === '.app-body' ? appBody : null),
-    querySelectorAll: (sel) => (sel === '#app-sidebar .nav-item--asleep' ? nav.filter((a) => a.classList.contains('nav-item--asleep')) : []),
+    querySelectorAll: (sel) => (sel === '#app-sidebar .nav-item--asleep, #app-sidebar .nav-item--arrived'
+      ? nav.filter((a) => a.classList.contains('nav-item--asleep') || a.classList.contains('nav-item--arrived')) : []),
     getElementById: (id) => nav.find((a) => a.id === id) || appBody.children.find((c) => c.id === id) || null,
   };
   return { document, nav, appBody, root };
@@ -164,12 +165,12 @@ function sliceFn(name) {
   assert.ok(start > -1 && end > start, name + ' was located in shell.js');
   return SHELL.slice(start, end + 4);
 }
-function loadApplyFounding(document, access, brand = { identity: { productName: 'Kestrel' } }) {
+function loadApplyFounding(document, access, brand = { identity: { productName: 'Kestrel' } }, storage = null) {
   const wakeStart = SHELL.indexOf('  var WAKE_TEXT = {');
   const wakeEnd = SHELL.indexOf('};', wakeStart) + 2;
   assert.ok(wakeStart > -1, 'WAKE_TEXT was located in shell.js');
   const src = [SHELL.slice(wakeStart, wakeEnd), sliceEsc(), sliceFn('applyFounding')].join('\n');
-  return new Function('document', 'brand', 'access', 'window', `${src}\nreturn applyFounding;`)(document, brand, access, { OTB: realOTB() });
+  return new Function('document', 'brand', 'access', 'window', `${src}\nreturn applyFounding;`)(document, brand, access, { OTB: realOTB(), localStorage: storage || undefined });
 }
 
 const snapshot = (h) => JSON.stringify({
@@ -213,8 +214,8 @@ test('founding ON: the band above the topbar, and the rooms the server named asl
   const byId = (id) => h.nav.find((a) => a.id === 'nav-' + id);
   assert.ok(!byId('goals').classList.contains('nav-item--asleep'), 'scope is behind: goals is awake');
   assert.ok(byId('work').classList.contains('nav-item--asleep'), 'strategize is current: tasks still sleeps');
-  assert.equal(byId('work').children[0].textContent, 'opens after strategy', 'a sentence, never a raw slug');
-  assert.equal(byId('collab').children[0].textContent, 'opens when alive');
+  assert.equal(byId('work').children.length, 0, 'a hidden room carries no label nobody can see (task 1005112)');
+  assert.ok(byId('collab').classList.contains('nav-item--asleep'), 'community sleeps until alive');
   assert.ok(!byId('home').classList.contains('nav-item--asleep'), 'home is never put to sleep');
 });
 
@@ -227,7 +228,7 @@ test('founding OFF after ON restores the hall exactly — OFF removes, it does n
   assert.notEqual(snapshot(h), before);
   access.founding = null;
   apply();
-  assert.equal(snapshot(h), before, 'band, asleep classes, wake tags and the root attribute are all gone');
+  assert.equal(snapshot(h), before, 'band, asleep classes and the root attribute are all gone');
 });
 
 test('the band escapes what it prints — a project name cannot inject markup', () => {
@@ -280,13 +281,13 @@ test('a failing waiting-on source never turns the mode off', async () => {
   assert.equal(f.waiting_on, null);
 });
 
-test('re-applying ON does not stack a second band or duplicate wake tags', () => {
+test('re-applying ON does not stack a second band or add anything to a room', () => {
   const h = makeHall();
   const access = { founding: fm.shapeFoundingMode({ active: 'true', stage: 'decide' }) };
   const apply = loadApplyFounding(h.document, access);
   apply(); apply();
   assert.equal(h.appBody.children.filter((c) => c.id === 'founding-band').length, 1);
-  assert.equal(h.nav.find((a) => a.id === 'nav-work').children.length, 1);
+  assert.equal(h.nav.find((a) => a.id === 'nav-work').children.length, 0);
 });
 
 // ── the wiring ──────────────────────────────────────────────────────────────
@@ -317,3 +318,78 @@ test('founding mode adds no page, no route and no nav item — it is a mode', ()
   const hall = fs.readdirSync(path.join(ROOT, 'modules', 'hall-ui', 'public'));
   assert.ok(!hall.some((f) => /^founding\./.test(f)), 'no founding page file');
 });
+
+// ── task 1005112: hidden, not dimmed; the arrival; the honest refusal ─────────
+
+test('a sleeping room is hidden by the sheet, and a group of sleeping rooms hides its head', () => {
+  const css = fs.readFileSync(path.join(ROOT, 'modules', 'hall-ui', 'public', 'style.css'), 'utf8');
+  assert.match(css, /\.nav-item--asleep \{ display: none; \}/, 'asleep is not drawn at all, never dimmed');
+  assert.doesNotMatch(css, /\.nav-item--asleep \{ opacity/);
+  assert.match(css, /html\[data-founding="on"\] \.nav-group:not\(:has\(\.nav-item:not\(\.nav-item--asleep\)/);
+});
+
+test('a room that woke since this browser last looked arrives marked, once (task 1005112)', () => {
+  const store = new Map();
+  const storage = { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, String(v)) };
+  const at = (stage) => ({ founding: fm.shapeFoundingMode({ active: 'true', stage }) });
+  const h1 = makeHall();
+  loadApplyFounding(h1.document, at('scope'), undefined, storage)();
+  assert.ok(!h1.nav.some((a) => a.classList.contains('nav-item--arrived')), 'the first look marks nothing');
+  const h2 = makeHall();
+  loadApplyFounding(h2.document, at('strategize'), undefined, storage)();
+  const arrived = h2.nav.filter((a) => a.classList.contains('nav-item--arrived')).map((a) => a.id);
+  assert.deepEqual(arrived.sort(), ['nav-goal-map', 'nav-goals'], 'scope finished: Goals and Sky arrive');
+  const h3 = makeHall();
+  loadApplyFounding(h3.document, at('strategize'), undefined, storage)();
+  assert.ok(!h3.nav.some((a) => a.classList.contains('nav-item--arrived')), 'the next page load: no mark again');
+  // Switching off removes the mark with everything else.
+  const access = at('charter');
+  const h4 = makeHall();
+  const before = snapshot(h4);
+  const apply = loadApplyFounding(h4.document, access, undefined, storage);
+  apply();
+  access.founding = null;
+  apply();
+  assert.equal(snapshot(h4), before);
+});
+
+test('the shell says, on Home, what a refused room is and which stage opens it (task 1005112)', () => {
+  const navStart = SHELL.indexOf('  var NAV = [');
+  const navEnd = SHELL.indexOf('  var NAV_COLLAPSE_KEY');
+  const wakeStart = SHELL.indexOf('  var WAKE_TEXT = {');
+  const wakeEnd = SHELL.indexOf('};', wakeStart) + 2;
+  const src = [SHELL.slice(navStart, navEnd), SHELL.slice(wakeStart, wakeEnd), sliceEsc(),
+    sliceFn('navItemById'), sliceFn('renderDeniedNotice')].join('\n');
+  let inserted = null;
+  let replaced = null;
+  const el = { querySelector: () => ({ addEventListener() {} }), setAttribute() {} };
+  const document = {
+    getElementById: (id) => (id === 'app-topbar' ? { insertAdjacentElement: (_, n) => { inserted = n; } } : null),
+    createElement: () => el,
+  };
+  const run = (search) => {
+    inserted = null;
+    new Function('document', 'window', 'history', 'brand', 'access', 'icon', 'chevronIcon',
+      `${src}\nreturn renderDeniedNotice;`)(document,
+      { location: { search, pathname: '/', hash: '' }, OTB: realOTB() },
+      { replaceState: (a, b, url) => { replaced = url; } }, {}, {}, () => '', () => '')();
+    return inserted;
+  };
+  const n = run('?asleep=goals&opens=scope');
+  assert.ok(n, 'a notice is drawn');
+  assert.match(n.innerHTML, /Goals isn’t open yet\. It opens after scope\. Finish that stage of founding here on Home\./);
+  assert.equal(replaced, '/', 'the query is stripped so a refresh does not re-show it');
+  assert.equal(run('?asleep=goals%3Cx&opens=scope'), null, 'a malformed room id draws nothing');
+  assert.match(run('?denied=page.view.government').innerHTML, /permission/, 'the old denial still reads the same');
+});
+
+test('the arrival mark survives the shell applying the mode a second time on one page', () => {
+  const store = new Map([['hall-founding-asleep', JSON.stringify({ goals: 'scope', 'goal-map': 'scope', 'board-room': 'charter' })]]);
+  const storage = { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, String(v)) };
+  const h = makeHall();
+  const apply = loadApplyFounding(h.document, { founding: fm.shapeFoundingMode({ active: 'true', stage: 'strategize' }) }, undefined, storage);
+  apply();
+  apply(); // /me settles, then the page reports: applyAccess runs again
+  const arrived = h.nav.filter((a) => a.classList.contains('nav-item--arrived')).map((a) => a.id).sort();
+  assert.deepEqual(arrived, ['nav-board-room', 'nav-goal-map', 'nav-goals']);
+});

package/tests/founding_page_gate.mjs

@@ -0,0 +1,105 @@
+// tests/founding_page_gate.mjs — A SLEEPING ROOM IS NOT REACHABLE BY URL (task 1005112).
+//
+// The sidebar hides a room a founding project has not opened; this is the other half,
+// the page. Everything here RUNS the real middleware (src/bongos/founding-page-gate.js)
+// over fake requests, fed by the real founding-mode shape (modules/onboarding/
+// founding-mode.js) — and, in the last cases, through the real port lookup — so the
+// server's /me answer and the page refusal are one rule.
+
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+
+const require = createRequire(import.meta.url);
+const { foundingPageGate } = require('../src/bongos/founding-page-gate.js');
+const seams = require('../src/module-seams.js');
+const fm = require('../modules/onboarding/founding-mode.js');
+
+const founding = (stage) => fm.shapeFoundingMode({ active: 'true', stage });
+const ROOMS = [...new Set([...Object.values(fm.WAKES).flat(), ...fm.WAKES_WHEN_ALIVE])];
+
+// Drive the middleware once; resolve with what it did.
+function run(pathname, { read, buildersHost = false, skip = false } = {}) {
+  return new Promise((resolve) => {
+    const res = {
+      headers: {},
+      set(k, v) { this.headers[k] = v; return this; },
+      redirect(code, url) { resolve({ redirect: url, code, headers: this.headers }); },
+    };
+    const opts = { isBuildersHost: () => buildersHost, skip: () => skip };
+    if (read) opts.read = read;
+    foundingPageGate(opts)({ path: pathname }, res, () => resolve({ next: true }));
+  });
+}
+
+test('every room a genesis stage can put to sleep is refused while it sleeps, and nothing else is', async () => {
+  // At 'decide' every room sleeps, so this is the whole list the gate must cover.
+  const read = async () => founding('decide');
+  for (const id of ROOMS) {
+    const out = await run(`/builders/${id}`, { read });
+    assert.ok(out.redirect, `${id} is refused while asleep`);
+  }
+  for (const never of ['primer', 'board-room', 'profile', 'task/12', 'settings', 'blockers', 'studio']) {
+    assert.deepEqual(await run(`/builders/${never}`, { read }), { next: true }, `${never} is never gated`);
+  }
+  // And the gate names no room the server never puts to sleep: a fake answer naming
+  // an unknown room changes nothing.
+  assert.deepEqual(await run('/builders/blockers', { read: async () => ({ active: true, asleep: { blockers: 'scope' } }) }), { next: true });
+});
+
+test('a sleeping room\'s page goes home, naming the room and the stage that opens it', async () => {
+  const out = await run('/builders/goals', { read: async () => founding('scope') });
+  assert.equal(out.code, 302);
+  assert.equal(out.redirect, '/builders/?asleep=goals&opens=scope');
+  assert.equal(out.headers['Cache-Control'], 'no-store', 'a refusal is never cached past the wake');
+  const sub = await run('/builders/work.html', { read: async () => founding('scope'), buildersHost: true });
+  assert.equal(sub.redirect, '/?asleep=work&opens=strategize', 'the builders. host form');
+  const alive = await run('/builders/roster/', { read: async () => founding('legislation') });
+  assert.equal(alive.redirect, '/builders/?asleep=roster&opens=alive');
+  const sneaky = await run('/builders//goal-map', { read: async () => founding('decide') });
+  assert.equal(sneaky.redirect, '/builders/?asleep=goal-map&opens=scope', 'a doubled slash is normalised, not a way past');
+});
+
+test('an awake room opens, and a later stage never takes one away', async () => {
+  assert.deepEqual(await run('/builders/goals', { read: async () => founding('strategize') }), { next: true });
+  assert.deepEqual(await run('/builders/work', { read: async () => founding('charter') }), { next: true });
+});
+
+test('a project that is not founding is untouched, and a failed read opens rather than shuts', async () => {
+  assert.deepEqual(await run('/builders/goals', { read: async () => null }), { next: true });
+  assert.deepEqual(await run('/builders/collab', { read: async () => ({ active: false }) }), { next: true });
+  assert.deepEqual(await run('/builders/goals', { read: async () => { throw new Error('db down'); } }), { next: true },
+    'a read that throws opens the page');
+});
+
+test('only the five room pages ever cost a founding read', async () => {
+  let reads = 0;
+  const read = async () => { reads += 1; return founding('decide'); };
+  for (const p of ['/builders/', '/builders/primer', '/builders/board-room', '/builders/task/5', '/api/bongos/me', '/goals']) {
+    assert.deepEqual(await run(p, { read }), { next: true }, p);
+  }
+  assert.deepEqual(await run('/builders/goals', { read, skip: true }), { next: true }, 'a module surface host is skipped');
+  assert.equal(reads, 0);
+});
+
+test('the default read is the onboarding port\'s foundingModeFor, the answer /me carries', async () => {
+  seams._reset();
+  try {
+    assert.deepEqual(await run('/builders/goals'), { next: true }, 'onboarding module off: not founding, page opens');
+    seams.registerProvider('onboarding', { foundingModeFor: async () => founding('scope') });
+    assert.equal((await run('/builders/goals')).redirect, '/builders/?asleep=goals&opens=scope');
+    seams._reset();
+    seams.registerProvider('onboarding', { foundingModeFor: async () => { throw new Error('settings table gone'); } });
+    assert.deepEqual(await run('/builders/goals'), { next: true }, 'a port that throws opens the page');
+  } finally {
+    seams._reset();
+  }
+});
+
+test('the server mounts it after the sign-in gate, so a stranger still meets sign-in first', () => {
+  const src = fs.readFileSync(new URL('../src/bongos/serve-internal.js', import.meta.url), 'utf8');
+  const signIn = src.indexOf('return gdsAuth.requireBuilderPage(req, res, next);');
+  const mount = src.indexOf('app.use(foundingPageGate(');
+  assert.ok(signIn > 0 && mount > signIn, 'mounted, and after the sign-in gate');
+});

package/tests/front_door_guide_existing.mjs

@@ -222,6 +222,7 @@ test('the guide has no upload, fetch or link-reading path: these are all its rou
   assert.deepEqual([...routes(chatRouter), ...routes(planRouter)].sort(), [
     'GET /front-door-guide/conversations/:id',
     'GET /front-door-guide/mine',
+    'GET /front-door-guide/mine/handoff.md',   // the plan as the hand-off file, a download (task 1005274): reads nothing of theirs
     'GET /front-door-guide/status',
     'POST /front-door-guide/conversations',
     'POST /front-door-guide/conversations/:id/attach',

package/tests/genesis_home.mjs

@@ -226,7 +226,7 @@ function world({ withGovernment = true } = {}) {
   const deps = () => ({
     getSetting: async (k) => (store.has(k) ? { key: k, value: store.get(k) } : null),
     setSetting: async (k, v) => { store.set(k, String(v)); return { key: k, value: String(v) }; },
-    lifecycle, government, now,
+    lifecycle, government, now, documents: null,
   });
   return {
     store, tasks, board, opened, deps,
@@ -385,6 +385,67 @@ test('with no Board Room module the founder\'s confirm closes a finished stage',
   assert.equal((await gh.readGenesis(w.deps())).stage, 'strategize');
 });
 
+test('task 1005115: with no Board Room a finished stage moves on by itself, and the view says so', async () => {
+  const w = world({ withGovernment: false });
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  let g = await gh.readGenesis(w.deps());
+  assert.equal(g.board_room, false);
+  assert.equal(g.moved, null, 'nothing has moved past a stage yet');
+  w.finish('scope');
+  // A ship moves it on; no read and no button needed.
+  assert.deepEqual(await gh.onTaskShipped(w.deps()), []);
+  assert.equal(w.store.get(fm.KEYS.STAGE), 'strategize', 'the ship that finished scope advanced it');
+  g = await gh.readGenesis(w.deps());
+  assert.equal(g.stage, 'strategize');
+  assert.equal(g.can_close, false, 'there is no close button on this path');
+  assert.equal(g.moved.from, 'scope');
+  assert.equal(g.moved.to, 'strategize');
+  assert.equal(g.moved.how, 'tasks_finished');
+  assert.deepEqual(g.moved.opened, fm.WAKES.scope, 'and it names what opened');
+  assert.equal(g.stages[0].state, 'done');
+  // Every read reconciles too, through several finished stages in order.
+  w.finish('strategize'); w.finish('charter');
+  g = await gh.readGenesis(w.deps());
+  assert.equal(g.stage, 'legalize');
+  // Legislation does not pass itself: its finished tasks open the alive door.
+  w.finish('legalize'); w.finish('legislation');
+  g = await gh.readGenesis(w.deps());
+  assert.equal(g.stage, 'legislation');
+  assert.equal(g.can_close, false);
+  assert.equal(g.can_come_alive, true);
+  // The old close call on a stage that already moved answers what happened.
+  const again = await gh.closeStage('scope', 1, w.deps());
+  assert.equal(again.ok, true);
+  assert.equal(again.already, true);
+  assert.equal(again.next_stage, 'legislation', 'it names where the project is now, not the stage after scope');
+  assert.equal((await gh.comeAlive(1, w.deps())).ok, true);
+});
+
+test('task 1005115: with a Board Room nothing moves by itself; the sitting still decides', async () => {
+  const w = world();
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  w.finish('scope');
+  const g = await gh.readGenesis(w.deps());
+  assert.equal(g.stage, 'scope');
+  assert.equal(g.board_room, true);
+  assert.equal(g.can_close, true);
+});
+
+test('task 1005115: each stage on the genesis home carries its document', async () => {
+  const w = world({ withGovernment: false });
+  await gh.startFounding(1, w.deps());
+  await gh.savePlan({}, 1, w.deps());
+  const documents = async () => ({ scope: { title: 'The scope', filled: true, updated_at: null, editable: true } });
+  let g = await gh.readGenesis({ ...w.deps(), documents });
+  assert.equal(g.stages[0].document.title, 'The scope');
+  assert.equal(g.stages[1].document, null);
+  g = await gh.readGenesis({ ...w.deps(), documents: async () => { throw new Error('db down'); } });
+  assert.equal(g.stage, 'scope', 'the home still renders when the documents cannot be read');
+  assert.equal(g.stages[0].document, null);
+});
+
 test('the view: states, wakes, the life plates and a due date from the plan', () => {
   const mode = { stage: 'strategize', stage_number: 2, stage_count: 5, day: 9 };
   const g = gh.shapeGenesis({
@@ -592,6 +653,8 @@ test('the stage reads as a checklist: done, open and locked, and a locked row of
   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(row('301'), /sr-only/, 'an open row adds no hidden word its status pill could contradict');
+  assert.match(row('302'), /class="sr-only">Locked: /);
   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,
@@ -605,6 +668,25 @@ test('the stage reads as a checklist: done, open and locked, and a locked row of
   assert.doesNotMatch(r304, /data-genesis-copy/);
 });
 
+test('task 1005115: with no Board Room the card says the stage moved by itself, and lists what each stage left', async () => {
+  const genesis = gh.shapeGenesis({
+    mode: { stage: 'strategize', stage_number: 2, stage_count: 5, day: 3 },
+    plan: { days: {} },
+    tasks: { scope: [{ id: '1', title: 'Write the scope', status: 'shipped' }], strategize: [{ id: '2', title: 'Write the strategy', status: 'ready' }] },
+    stageAt: { strategize: '2026-10-08T00:00:00Z' },
+    boardRoom: false,
+    documents: { scope: { title: 'The scope', filled: true, updated_at: null, editable: true }, strategize: { title: 'The strategy', filled: false } },
+  });
+  const { host } = bootCard({ founding: true, data: { genesis, viewer_id: '1' } });
+  await new Promise((r) => setImmediate(r));
+  await new Promise((r) => setImmediate(r));
+  assert.match(host.innerHTML, /data-genesis-moved>Scope is done, so this stage opened by itself\. Now open: /);
+  assert.match(host.innerHTML, /moves on by itself/);
+  assert.doesNotMatch(host.innerHTML, /put this stage to the board/, 'no board to put it to');
+  assert.match(host.innerHTML, /<b>The scope<\/b>/);
+  assert.doesNotMatch(host.innerHTML, /The strategy<\/b>/, 'an empty document is not listed');
+});
+
 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');
@@ -694,3 +776,25 @@ test('task 1005121: the close route answers 202 with the whole body for an open
   const click = hall.slice(hall.indexOf("t.hasAttribute('data-genesis-close')"), hall.indexOf("t.hasAttribute('data-genesis-confirm')"));
   assert.ok(click.length > 0 && !click.includes('/votes'),'the hall no longer casts a second vote after closing — the server did it');
 });
+
+test('a stage that opens no room says what finishing it earns, never nothing (task 1005112)', async () => {
+  const genesis = gh.shapeGenesis({ mode: { stage: 'scope', stage_number: 1, stage_count: 5, day: 1 }, plan: gh.parsePlan({}).plan });
+  const by = Object.fromEntries(genesis.stages.map((s) => [s.key, s]));
+  assert.equal(by.scope.earns, null, 'a stage that wakes rooms names the rooms instead');
+  assert.equal(by.strategize.earns, null);
+  for (const k of ['charter', 'legalize', 'legislation']) {
+    assert.deepEqual(by[k].wakes, [], `${k} wakes no room`);
+    assert.ok(by[k].earns && by[k].earns.length > 10, `${k} says what it earns`);
+  }
+  assert.match(by.legislation.earns, /every room opens/, 'the last stage is the one that opens everything');
+  const b = bootCard({ founding: true, data: { genesis, viewer_id: '1' } });
+  await mountClickable(b);
+  assert.match(b.host.innerHTML, /Wakes Goals, Goal map/);
+  assert.match(b.host.innerHTML, /puts your government in force/);
+  assert.match(b.host.innerHTML, /settles how contributors are rewarded/);
+  // The district rises with the stages (task 1005112): each row also names what it raises.
+  assert.match(b.host.innerHTML, /Wakes Goals, Goal map · raises Planning/);
+  assert.match(b.host.innerHTML, /Raises Treasury · settles how contributors are rewarded/);
+  assert.match(b.host.innerHTML, /Raises Rules, Review, Disputes · brings the project to life/);
+  assert.deepEqual(by.legalize.raises, ['treasury']);
+});

package/tests/genesis_work.mjs

@@ -370,6 +370,35 @@ if (import.meta.url === url.pathToFileURL(process.argv[1]).href) {
     assert.match(out, /\(empty\)/);
   });
 
+  await test('task 1005115: a stage\'s document is its record read as one named, editable page', async () => {
+    const deps = { store: memStore() };
+    let d = (await gw.readDocument('strategize', deps)).document;
+    assert.equal(d.title, 'The strategy');
+    assert.equal(d.filled, false, 'nothing written yet: an empty document, not a heading');
+    assert.equal(d.markdown, '');
+    await gw.setAnswer('strategize', 'big_pieces', { text: 'Ledger, then sync' }, 1, deps);
+    await gw.setAnswer('strategize', 'risks', { state: 'not_sure', text: 'bank API' }, 1, deps);
+    await gw.setPage('strategize', 'We start small.', 1, deps);
+    d = (await gw.readDocument('strategize', deps)).document;
+    assert.equal(d.filled, true);
+    assert.match(d.markdown, /^# The strategy\n/);
+    assert.match(d.markdown, /Ledger, then sync/);
+    assert.match(d.markdown, /Not sure yet — bank API/);
+    assert.match(d.markdown, /We start small\./);
+    assert.equal(d.editable, true);
+    assert.equal(d.edit.page, 'PUT /api/bongos/founding/work/strategize/page');
+    assert.ok(d.updated_at, 'the document says when it last changed');
+    // Editing it is editing the record: the same write, seen at once in the document.
+    await gw.setAnswer('strategize', 'big_pieces', { text: 'Sync first' }, 1, deps);
+    assert.match((await gw.readDocument('strategize', deps)).document.markdown, /Sync first/);
+    assert.equal((await gw.readDocument('nope', deps)).reason, 'unknown_stage');
+    const all = await gw.readDocuments(deps);
+    assert.deepEqual(Object.keys(all), ['scope', 'strategize', 'charter', 'legalize', 'legislation']);
+    assert.equal(all.strategize.filled, true);
+    assert.equal(all.scope.filled, false);
+    assert.equal(all.charter.title, 'The charter');
+  });
+
   console.log(`\ngenesis_work: ${passed} passed, ${failed} failed`);
   if (failed) process.exit(1);
 }

package/tests/genesis_work_routes.mjs

@@ -67,6 +67,15 @@ try {
     assert.equal(r.data.work.questions.find((q) => q.id === 'big_pieces').answer.text, 'Ledger first.');
   });
 
+  await test('task 1005115: any builder reads a stage\'s document; an unknown stage is 404', async () => {
+    assert.equal((await call('GET', '/founding/work/strategize/document', { as: null })).status, 401);
+    const r = await call('GET', '/founding/work/strategize/document', { as: OTHER });
+    assert.equal(r.status, 200);
+    assert.equal(r.data.document.title, 'The strategy');
+    assert.match(r.data.document.markdown, /Ledger first\./, 'the answer written above is in the document');
+    assert.equal((await call('GET', '/founding/work/nope/document')).status, 404);
+  });
+
   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' }],