@bongos/core 1.20.56 → 1.20.58

package/modules/lifecycle/routes/kickoff-seed.js

@@ -3,7 +3,8 @@
 // modules/lifecycle/routes/kickoff-seed.js — registers the `lifecycle.kickoffSeed` port
 // (task 1003239): the founder's first board, filed the moment the kernel seats them.
 //
-// Resolved by ONE caller — the first-admin bootstrap in src/bongos/auth-admission.js —
+// Resolved by two callers — the first-admin bootstrap in src/bongos/auth-admission.js
+// (seedIfEmpty) and the genesis home in modules/onboarding (seedGenesis, genesisTasks) —
 // through resolveOptional, so an instance without this module signs in exactly as
 // before. A route factory for a routeless capability, for the reason routes/lifecycle.js
 // and routes/rank-sync.js give: mountModuleRoutes is the boot hook that runs in the live
@@ -17,6 +18,11 @@ const seed = require('../kickoff-seed');
 // Delegates at call time (never spreads) so a stubbed seed still bites.
 const kickoffSeedPort = {
   seedIfEmpty: (...a) => seed.seedKickoffIfEmpty(...a),
+  // task 1004423: the genesis home files the five stages through the same seeder, and
+  // reads them back by stage. Still no HTTP surface here: the genesis home's own routes
+  // (modules/onboarding) gate who may file them.
+  seedGenesis: (...a) => seed.seedGenesisStages(...a),
+  genesisTasks: (...a) => seed.genesisStageTasks(...a),
 };
 
 module.exports = function buildLifecycleKickoffSeedRouter() {

package/modules/onboarding/genesis-home.js

@@ -0,0 +1,274 @@
+'use strict';
+
+// modules/onboarding/genesis-home.js — THE GENESIS HOME: what a founding project does,
+// stage by stage, until it comes alive (task 1004423 / BV2.PS08, goal 1000121; spec
+// docs/specs/bongos-v2-project-startup.md D4 + D7; design of record
+// docs/design/mocks/project-startup/GenesisDecide|GenesisHall|Alive.dc.html).
+//
+// The flow, in founding-mode.js's stages:
+//   decide       the founder settles a plan: each stage's length and what counts as
+//                done, the starting government, how many passes, optional advisors.
+//                Saving it files the five stages as REAL tasks (the kickoff seeder, on
+//                the lifecycle port) and moves the project to scope.
+//   scope ..     each stage is worked as tasks. When they are all finished (shipped or
+//   legislation  dropped) the stage is put to the Board Room under the constitution in
+//                force (the government port's genesis-stage subject, spec D7). Under
+//                Monarchy / BDFL the founder's one yes closes it, which is the solo
+//                fast-track's "one confirm per stage" (D4). A pass moves the project to
+//                the next stage, and the rooms that stage woke stop sleeping
+//                (founding-mode.js WAKES, which the shell already reads).
+//   alive        once legislation has passed, the founder brings the project to life:
+//                founding mode switches off and the full hall opens.
+//
+// WHERE THE STATE LIVES. The stage is founding-mode's (project_settings). The plan is
+// one more project_settings row, `founding.plan`, JSON. The tasks are the board's. The
+// decision is the Board Room's: a stage moves on only because a sitting PASSED, read
+// back from the government port, never because a client said so. A pass is announced
+// as `board.genesis_stage.passed` (the route factory listens), and every read
+// reconciles again, so a missed nudge cannot strand a stage.
+//
+// THE BOUNDARY. Core through ../../src/module-api.js; the lifecycle and government
+// modules through their ports only (resolveOptional), never a require.
+
+const fm = require('./founding-mode');
+
+const PLAN_KEY = 'founding.plan';
+const PROPER = Object.freeze(fm.STAGES.slice(1)); // the five stages after 'decide'
+
+// Each stage's life-strip plate (the world pair under the hall's genesis/ folder, task
+// 1004425), what the design calls that moment of life, and its plain done-when line.
+const STAGE_INFO = Object.freeze({
+  scope: Object.freeze({ label: 'Scope', life: 'primordial sea', plate: 'r5-life-1-primordial-sea', days: 7,
+    done_when: 'The scope is written: what you are making, for whom, and what is left out.' }),
+  strategize: Object.freeze({ label: 'Strategize', life: 'first cells', plate: 'r5-life-2-first-cells', days: 7,
+    done_when: 'The strategy is written out, or the one you have is linked.' }),
+  charter: Object.freeze({ label: 'Charter', life: 'the genome', plate: 'r5-life-3-genome', days: 4,
+    done_when: 'The starting government is chosen and the bylaws are written.' }),
+  legalize: Object.freeze({ label: 'Legalize', life: 'the membrane', plate: 'r5-life-4-membrane', days: 7,
+    done_when: 'Rewards are decided, and who can be paid.' }),
+  legislation: Object.freeze({ label: 'Legislation', life: 'the nervous system', plate: 'r5-life-5-nervous-system', days: 3,
+    done_when: 'The voting rules are set: who votes, and how many must agree.' }),
+});
+
+const PASSES = Object.freeze([1, 2]);
+const ADVISORS = Object.freeze(['none', 'cbaas']);
+const MAX_DAYS = 90;
+
+const intIn = (v, lo, hi) => Number.isInteger(v) && v >= lo && v <= hi;
+
+// parsePlan(body) — PURE. The founder's plan, defaults filled in, or why it is refused.
+// The government is recorded, not applied: the charter stage (task 1004427) files it as
+// an amendment, so here it is only a well-formed form key.
+function parsePlan(body = {}) {
+  const b = body && typeof body === 'object' ? body : {};
+  const days = {};
+  for (const s of PROPER) {
+    const raw = b.days && b.days[s] != null ? Number(b.days[s]) : STAGE_INFO[s].days;
+    if (!intIn(raw, 1, MAX_DAYS)) return { ok: false, reason: 'bad_days', stage: s };
+    days[s] = raw;
+  }
+  const passes = b.passes == null ? 1 : Number(b.passes);
+  if (!PASSES.includes(passes)) return { ok: false, reason: 'bad_passes' };
+  const advisors = b.advisors == null ? 'none' : String(b.advisors);
+  if (!ADVISORS.includes(advisors)) return { ok: false, reason: 'bad_advisors' };
+  const government = b.government == null || b.government === '' ? null : String(b.government);
+  if (government !== null && !/^[a-z][a-z-]{1,39}$/.test(government)) return { ok: false, reason: 'bad_government' };
+  const expected = b.expected_builders == null || b.expected_builders === '' ? null : Number(b.expected_builders);
+  if (expected !== null && !intIn(expected, 1, 100000)) return { ok: false, reason: 'bad_expected_builders' };
+  return { ok: true, plan: { days, passes, advisors, government, expected_builders: expected, existing: b.existing === true } };
+}
+
+function readPlanValue(raw) {
+  if (!raw) return null;
+  try { const p = JSON.parse(raw); return p && typeof p === 'object' ? p : null; } catch (_) { return null; }
+}
+
+const FINISHED = Object.freeze(['shipped', 'abandoned']); // the Board Room's own gate, mirrored for display
+
+// shapeGenesis({ mode, plan, tasks, board, stageAt }) — PURE. The genesis home's view.
+//   mode    foundingModeFor's shape (non-null)
+//   plan    the saved plan or null (deciding)
+//   tasks   { stage: [{ id, title, status }] }
+//   board   { stage: genesisStageStatus row } or {}
+//   stageAt { stage: ISO } — when each stage began, for its due date
+function shapeGenesis({ mode, plan, tasks = {}, board = {}, stageAt = {} }) {
+  const at = fm.STAGES.indexOf(mode.stage);
+  const stages = PROPER.map((key) => {
+    const info = STAGE_INFO[key];
+    const idx = fm.STAGES.indexOf(key);
+    const list = (tasks[key] || []).map((t) => ({ ...t, finished: FINISHED.includes(t.status) }));
+    const b = board[key] || null;
+    const days = plan && plan.days && plan.days[key] ? plan.days[key] : info.days;
+    const began = stageAt[key] ? new Date(stageAt[key]) : null;
+    const due = began && Number.isFinite(began.getTime()) ? new Date(began.getTime() + days * 86400000).toISOString() : null;
+    return {
+      key,
+      number: idx,
+      label: info.label,
+      life: info.life,
+      plate: info.plate,
+      done_when: info.done_when,
+      wakes: fm.WAKES[key] || [],
+      days,
+      due,
+      state: idx < at ? 'done' : idx === at ? 'now' : 'later',
+      tasks: list,
+      finished: list.filter((t) => t.finished).length,
+      total: list.length,
+      board: b ? {
+        state: b.state, item_id: b.item_id || null, needs: b.needs || null,
+        one_vote_decides: !!b.one_vote_decides, waiting_on: b.waiting_on || [],
+      } : null,
+    };
+  });
+  const now = stages.find((s) => s.state === 'now') || null;
+  const sitting = now && now.board && now.board.state === 'sitting';
+  const passed = now && now.board && now.board.state === 'passed';
+  return {
+    stage: mode.stage,
+    stage_number: mode.stage_number,
+    stage_count: mode.stage_count,
+    day: mode.day,
+    deciding: mode.stage === 'decide',
+    plan: plan || null,
+    stages,
+    // The close door: every task of the current stage finished, and not already sitting.
+    can_close: !!(now && now.total > 0 && now.finished === now.total && !sitting && !passed),
+    // Alive: the last stage has passed its sitting.
+    can_come_alive: !!(now && now.key === 'legislation' && passed),
+  };
+}
+
+// ── the reads and writes, over injectable seams ──────────────────────────────
+
+function seams(deps = {}) {
+  const api = deps.api || require('../../src/module-api');
+  return {
+    get: deps.getSetting || api.projectSettings.get,
+    set: deps.setSetting || api.projectSettings.set,
+    lifecycle: deps.lifecycle !== undefined ? deps.lifecycle : api.resolveOptional('lifecycle.kickoffSeed'),
+    government: deps.government !== undefined ? deps.government : api.resolveOptional('government'),
+    now: deps.now,
+  };
+}
+const modeDeps = (s) => ({ getSetting: s.get, setSetting: s.set, government: s.government, now: s.now });
+
+async function boardByStage(gov) {
+  if (!gov || typeof gov.genesisStageStatus !== 'function') return {};
+  const status = await gov.genesisStageStatus();
+  const out = {};
+  for (const row of (status && status.stages) || []) out[row.key] = row;
+  return out;
+}
+
+// reconcile — move on from every stage whose sitting has passed. The ONLY thing that
+// advances a stage, called on the pass event and on every read and write. Legislation
+// does not advance: its pass opens the alive door instead.
+async function reconcile(s) {
+  let mode = await fm.foundingModeFor(modeDeps(s));
+  if (!mode || !PROPER.includes(mode.stage) || mode.stage === 'legislation') return mode;
+  const board = await boardByStage(s.government);
+  while (mode && PROPER.includes(mode.stage) && mode.stage !== 'legislation'
+    && board[mode.stage] && board[mode.stage].state === 'passed') {
+    const next = fm.STAGES[fm.STAGES.indexOf(mode.stage) + 1];
+    mode = await fm.setFoundingMode({ stage: next }, null, modeDeps(s));
+  }
+  return mode;
+}
+
+// readGenesis(deps) → the view, or null when the project is not founding.
+async function readGenesis(deps = {}) {
+  const s = seams(deps);
+  const mode = await reconcile(s);
+  if (!mode) return null;
+  const planRow = await s.get(PLAN_KEY);
+  const plan = readPlanValue(planRow && planRow.value);
+  const tasks = s.lifecycle && typeof s.lifecycle.genesisTasks === 'function' ? await s.lifecycle.genesisTasks() : {};
+  const board = await boardByStage(s.government);
+  const stageAt = {};
+  for (const key of PROPER) {
+    const row = await s.get(fm.stageAtKey(key));
+    if (row && row.value) stageAt[key] = row.value;
+  }
+  return shapeGenesis({ mode, plan, tasks, board, stageAt });
+}
+
+// startFounding — a brand-new project enters genesis (the create flow's birth calls
+// this). Refused once the project has come alive: genesis happens once (spec D8).
+async function startFounding(builderId, deps = {}) {
+  const s = seams(deps);
+  const ended = await s.get(fm.KEYS.ENDED_AT);
+  if (ended && ended.value) return { ok: false, reason: 'already_alive' };
+  const mode = await fm.setFoundingMode({ active: true }, builderId, modeDeps(s));
+  return { ok: true, mode };
+}
+
+// savePlan — the decide stage's door: record the plan, file the five stages as tasks,
+// and move to scope. Only while deciding.
+async function savePlan(body, builderId, deps = {}) {
+  const s = seams(deps);
+  const mode = await fm.foundingModeFor(modeDeps(s));
+  if (!mode) return { ok: false, reason: 'not_founding' };
+  if (mode.stage !== 'decide') return { ok: false, reason: 'not_deciding' };
+  const parsed = parsePlan(body);
+  if (!parsed.ok) return parsed;
+  if (!s.lifecycle || typeof s.lifecycle.seedGenesis !== 'function') return { ok: false, reason: 'no_board' };
+  await s.set(PLAN_KEY, JSON.stringify(parsed.plan), builderId);
+  const seeded = await s.lifecycle.seedGenesis({ builderId, existing: parsed.plan.existing });
+  await fm.setFoundingMode({ stage: 'scope' }, builderId, modeDeps(s));
+  return { ok: true, plan: parsed.plan, seeded: seeded && seeded.seeded };
+}
+
+// closeStage — put the current stage to the Board Room. The finished-tasks gate is the
+// government module's (it checks the ids against the board); this only names the
+// stage's tasks. With no government module there is no Board Room to put it to, and
+// the founder's confirm closes the stage itself once its tasks are finished.
+async function closeStage(stageKey, builderId, deps = {}) {
+  const s = seams(deps);
+  const mode = await reconcile(s);
+  if (!mode) return { ok: false, reason: 'not_founding' };
+  if (mode.stage !== stageKey) return { ok: false, reason: 'not_current_stage', stage: mode.stage };
+  const all = s.lifecycle && typeof s.lifecycle.genesisTasks === 'function' ? await s.lifecycle.genesisTasks() : {};
+  const list = all[stageKey] || [];
+  const gov = s.government;
+  if (gov && typeof gov.openGenesisStageClose === 'function') {
+    const r = await gov.openGenesisStageClose({ stageKey, taskIds: list.map((t) => t.id), openedBy: builderId });
+    if (!r.opened && r.reason !== 'already_open') return { ok: false, reason: r.reason, unfinished: r.unfinished || [] };
+    return { ok: true, item_id: r.item ? String(r.item.id) : null, already_open: !r.opened };
+  }
+  if (!list.length || !list.every((t) => FINISHED.includes(t.status))) return { ok: false, reason: 'stage_tasks_unfinished' };
+  if (stageKey !== 'legislation') {
+    await fm.setFoundingMode({ stage: fm.STAGES[fm.STAGES.indexOf(stageKey) + 1] }, builderId, modeDeps(s));
+  }
+  return { ok: true, item_id: null, closed: true };
+}
+
+// comeAlive — the last door. Only once legislation has passed (or, with no Board Room,
+// once its tasks are finished): founding mode switches off and every room opens.
+async function comeAlive(builderId, deps = {}) {
+  const s = seams(deps);
+  const mode = await reconcile(s);
+  if (!mode) return { ok: false, reason: 'not_founding' };
+  if (mode.stage !== 'legislation') return { ok: false, reason: 'not_at_legislation' };
+  if (s.government && typeof s.government.genesisStageStatus === 'function') {
+    const board = await boardByStage(s.government);
+    if (!board.legislation || board.legislation.state !== 'passed') return { ok: false, reason: 'legislation_not_passed' };
+  } else {
+    const all = s.lifecycle && typeof s.lifecycle.genesisTasks === 'function' ? await s.lifecycle.genesisTasks() : {};
+    const list = all.legislation || [];
+    if (!list.length || !list.every((t) => FINISHED.includes(t.status))) return { ok: false, reason: 'legislation_not_passed' };
+  }
+  await fm.setFoundingMode({ active: false }, builderId, modeDeps(s));
+  return { ok: true };
+}
+
+// onStagePassed — the `board.genesis_stage.passed` listener. Best-effort: the next read
+// reconciles anyway.
+async function onStagePassed(deps = {}) {
+  try { await reconcile(seams(deps)); } catch (_) { /* recovered on the next read */ }
+}
+
+module.exports = {
+  PLAN_KEY, STAGE_INFO, PROPER, parsePlan, shapeGenesis,
+  readGenesis, startFounding, savePlan, closeStage, comeAlive, onStagePassed,
+};

package/modules/onboarding/routes/onboarding.js

@@ -35,6 +35,7 @@ const api = require('../../../src/module-api');
 const onboardingPort = require('../port');
 const buildAccessRequestsRouter = require('./access-requests');
 const foundingBuilders = require('../founding-builders');
+const genesis = require('../genesis-home');
 
 // Register the `onboarding` kernel PORT. See the header + port.js for the full
 // consumer list and the graceful-degradation contract.
@@ -61,5 +62,60 @@ module.exports = function buildOnboardingRouter() {
     res.set('Cache-Control', 'private, max-age=60');
     res.json({ builders });
   });
+  mountGenesisRoutes(router);
   return router;
 };
+
+// ── the genesis home (task 1004423) ──────────────────────────────────────────
+// Read by any signed-in builder of a founding project (everyone sees where genesis
+// is); every write is the project owner's, behind the same atom that guards the
+// project's other settings. The decision that moves a stage on is NOT here: it is the
+// Board Room's vote, and these routes only put a finished stage to it.
+const GENESIS_REFUSALS = {
+  not_founding: 409, not_deciding: 409, not_current_stage: 409, already_alive: 409,
+  not_at_legislation: 409, legislation_not_passed: 409, stage_tasks_unfinished: 409,
+  no_stage_tasks: 409, unknown_stage: 400, no_board: 503,
+  bad_days: 400, bad_passes: 400, bad_advisors: 400, bad_government: 400, bad_expected_builders: 400,
+};
+let genesisListening = false;
+
+function mountGenesisRoutes(router) {
+  // A stage's sitting passed: move the project on now rather than at the next read.
+  // Registered once per process; the route factory runs again on a test rebuild.
+  if (!genesisListening && typeof api.on === 'function') {
+    genesisListening = true;
+    api.on('board.genesis_stage.passed', () => genesis.onStagePassed());
+  }
+  const owns = api.requirePermission('project.settings.manage');
+  const refuse = (res, r) => res.status(GENESIS_REFUSALS[r.reason] || 409).json({
+    error: { code: r.reason, message: r.reason }, ...(r.unfinished ? { unfinished: r.unfinished } : {}),
+  });
+  const handle = (fn) => async (req, res) => {
+    try {
+      const r = await fn(req);
+      if (r && r.ok === false) return refuse(res, r);
+      res.set('Cache-Control', 'no-store');
+      res.json(r);
+    } catch (err) {
+      api.logger('onboarding').error('[onboarding] genesis', err);
+      res.status(500).json({ error: { code: 'genesis_failed', message: 'internal error' } });
+    }
+  };
+  router.get('/founding/genesis', api.requireBuilder, handle(async (req) => ({ genesis: await genesis.readGenesis(), viewer_id: String(req.builder.id) })));
+  router.post('/founding/start', api.requireBuilder, owns, handle((req) => genesis.startFounding(req.builder.id)));
+  // The plan's ranges and vocabularies are genesis-home.js parsePlan's (one source);
+  // this schema only names the fields so an unknown one is refused.
+  router.post('/founding/plan', api.requireBuilder, owns, (req, res, next) => {
+    if (api.validateOrRespond(req, res, {
+      days: { type: 'object' },
+      passes: { type: 'integer', min: 1, max: 2 },
+      advisors: { type: 'string', maxLength: 16 },
+      government: { type: 'string', maxLength: 40 },
+      expected_builders: { type: 'integer', min: 1, max: 100000 },
+      existing: { type: 'boolean' },
+    })) return;
+    next();
+  }, handle((req) => genesis.savePlan(req.body || {}, req.builder.id)));
+  router.post('/founding/stages/:stage/close', api.requireBuilder, owns, handle((req) => genesis.closeStage(String(req.params.stage), req.builder.id)));
+  router.post('/founding/alive', api.requireBuilder, owns, handle((req) => genesis.comeAlive(req.builder.id)));
+}

package/modules/ui-design/kit/fixtures/founding-genesis-decide.json

@@ -0,0 +1,108 @@
+{
+  "_": "The genesis home while deciding (task 1004423): the plan step, every default pre-picked.",
+  "genesis": {
+    "stage": "decide",
+    "stage_number": 0,
+    "stage_count": 5,
+    "day": 1,
+    "deciding": true,
+    "plan": null,
+    "stages": [
+      {
+        "key": "scope",
+        "number": 1,
+        "label": "Scope",
+        "life": "primordial sea",
+        "plate": "r5-life-1-primordial-sea",
+        "done_when": "The scope is written: what you are making, for whom, and what is left out.",
+        "wakes": [
+          "roadmap",
+          "goals",
+          "goal-map"
+        ],
+        "days": 7,
+        "due": null,
+        "state": "later",
+        "tasks": [],
+        "finished": 0,
+        "total": 0,
+        "board": null
+      },
+      {
+        "key": "strategize",
+        "number": 2,
+        "label": "Strategize",
+        "life": "first cells",
+        "plate": "r5-life-2-first-cells",
+        "done_when": "The strategy is written out, or the one you have is linked.",
+        "wakes": [
+          "work"
+        ],
+        "days": 7,
+        "due": null,
+        "state": "later",
+        "tasks": [],
+        "finished": 0,
+        "total": 0,
+        "board": null
+      },
+      {
+        "key": "charter",
+        "number": 3,
+        "label": "Charter",
+        "life": "the genome",
+        "plate": "r5-life-3-genome",
+        "done_when": "The starting government is chosen and the bylaws are written.",
+        "wakes": [
+          "board-room"
+        ],
+        "days": 4,
+        "due": null,
+        "state": "later",
+        "tasks": [],
+        "finished": 0,
+        "total": 0,
+        "board": null
+      },
+      {
+        "key": "legalize",
+        "number": 4,
+        "label": "Legalize",
+        "life": "the membrane",
+        "plate": "r5-life-4-membrane",
+        "done_when": "Rewards are decided, and who can be paid.",
+        "wakes": [
+          "economy"
+        ],
+        "days": 7,
+        "due": null,
+        "state": "later",
+        "tasks": [],
+        "finished": 0,
+        "total": 0,
+        "board": null
+      },
+      {
+        "key": "legislation",
+        "number": 5,
+        "label": "Legislation",
+        "life": "the nervous system",
+        "plate": "r5-life-5-nervous-system",
+        "done_when": "The voting rules are set: who votes, and how many must agree.",
+        "wakes": [
+          "ranks"
+        ],
+        "days": 3,
+        "due": null,
+        "state": "later",
+        "tasks": [],
+        "finished": 0,
+        "total": 0,
+        "board": null
+      }
+    ],
+    "can_close": false,
+    "can_come_alive": false
+  },
+  "viewer_id": "1"
+}

package/modules/ui-design/kit/fixtures/founding-genesis-stage.json

@@ -0,0 +1,162 @@
+{
+  "_": "The genesis home mid-way (task 1004423): scope passed, strategize in progress with its task active.",
+  "genesis": {
+    "stage": "strategize",
+    "stage_number": 2,
+    "stage_count": 5,
+    "day": 9,
+    "deciding": false,
+    "plan": {
+      "days": {
+        "scope": 7,
+        "strategize": 7,
+        "charter": 4,
+        "legalize": 7,
+        "legislation": 3
+      },
+      "passes": 2,
+      "advisors": "none",
+      "government": "monarchy",
+      "expected_builders": 3,
+      "existing": false
+    },
+    "stages": [
+      {
+        "key": "scope",
+        "number": 1,
+        "label": "Scope",
+        "life": "primordial sea",
+        "plate": "r5-life-1-primordial-sea",
+        "done_when": "The scope is written: what you are making, for whom, and what is left out.",
+        "wakes": [
+          "roadmap",
+          "goals",
+          "goal-map"
+        ],
+        "days": 7,
+        "due": "2026-10-08T00:00:00.000Z",
+        "state": "done",
+        "tasks": [
+          {
+            "id": "101",
+            "title": "Write the project scope: what we are making, for whom, and what is out of scope",
+            "status": "shipped",
+            "finished": true
+          }
+        ],
+        "finished": 1,
+        "total": 1,
+        "board": {
+          "state": "passed",
+          "item_id": "7",
+          "needs": null,
+          "one_vote_decides": true,
+          "waiting_on": []
+        }
+      },
+      {
+        "key": "strategize",
+        "number": 2,
+        "label": "Strategize",
+        "life": "first cells",
+        "plate": "r5-life-2-first-cells",
+        "done_when": "The strategy is written out, or the one you have is linked.",
+        "wakes": [
+          "work"
+        ],
+        "days": 7,
+        "due": "2026-10-15T00:00:00.000Z",
+        "state": "now",
+        "tasks": [
+          {
+            "id": "102",
+            "title": "Write out the strategy, or link the one you already have",
+            "status": "active",
+            "finished": false
+          }
+        ],
+        "finished": 0,
+        "total": 1,
+        "board": null
+      },
+      {
+        "key": "charter",
+        "number": 3,
+        "label": "Charter",
+        "life": "the genome",
+        "plate": "r5-life-3-genome",
+        "done_when": "The starting government is chosen and the bylaws are written.",
+        "wakes": [
+          "board-room"
+        ],
+        "days": 4,
+        "due": null,
+        "state": "later",
+        "tasks": [
+          {
+            "id": "103",
+            "title": "Choose the starting government and write the bylaws",
+            "status": "ready",
+            "finished": false
+          }
+        ],
+        "finished": 0,
+        "total": 1,
+        "board": null
+      },
+      {
+        "key": "legalize",
+        "number": 4,
+        "label": "Legalize",
+        "life": "the membrane",
+        "plate": "r5-life-4-membrane",
+        "done_when": "Rewards are decided, and who can be paid.",
+        "wakes": [
+          "economy"
+        ],
+        "days": 7,
+        "due": null,
+        "state": "later",
+        "tasks": [
+          {
+            "id": "104",
+            "title": "Decide how contributors are rewarded and who can be paid",
+            "status": "ready",
+            "finished": false
+          }
+        ],
+        "finished": 0,
+        "total": 1,
+        "board": null
+      },
+      {
+        "key": "legislation",
+        "number": 5,
+        "label": "Legislation",
+        "life": "the nervous system",
+        "plate": "r5-life-5-nervous-system",
+        "done_when": "The voting rules are set: who votes, and how many must agree.",
+        "wakes": [
+          "ranks"
+        ],
+        "days": 3,
+        "due": null,
+        "state": "later",
+        "tasks": [
+          {
+            "id": "105",
+            "title": "Set the voting rules: who votes and how many must agree",
+            "status": "ready",
+            "finished": false
+          }
+        ],
+        "finished": 0,
+        "total": 1,
+        "board": null
+      }
+    ],
+    "can_close": false,
+    "can_come_alive": false
+  },
+  "viewer_id": "1"
+}