@bongos/core 1.25.13 → 1.25.15

package/modules/hall-ui/public/work.js

@@ -641,54 +641,10 @@
   async function copyPromptForTask(taskId, btn) {
     const t = taskState.all.find((x) => String(x.id) === String(taskId));
     if (!t) return;
-    const prompt = buildPromptForTask(t);
-    const icon = btn.querySelector('.task__copy-icon');
-    const label = btn.querySelector('.task__copy-label');
-    try {
-      await navigator.clipboard.writeText(prompt);
-      btn.dataset.copied = '1';
-      if (icon) icon.textContent = '✓';
-      if (label) label.textContent = 'Copied';
-      setTimeout(() => {
-        btn.dataset.copied = '0';
-        if (icon) icon.textContent = '📋';
-        if (label) label.textContent = 'Copy prompt';
-      }, 1600);
-      toast(`Prompt for #${taskId} copied to your clipboard.`);
-    } catch (err) {
-      try {
-        const ta = document.createElement('textarea');
-        ta.value = prompt;
-        ta.style.position = 'fixed';
-        ta.style.opacity = '0';
-        document.body.appendChild(ta);
-        ta.select();
-        document.execCommand('copy');
-        ta.remove();
-        toast(`Prompt for #${taskId} copied.`);
-      } catch (_) {
-        toast('Could not copy to the clipboard. Try again.');
-      }
-    }
-  }
-  async function copyText(text) {
-    try { await navigator.clipboard.writeText(text); return true; }
-    catch (_) {
-      try {
-        const ta = document.createElement('textarea');
-        ta.value = text;
-        ta.style.position = 'fixed';
-        ta.style.opacity = '0';
-        document.body.appendChild(ta);
-        ta.select();
-        const ok = document.execCommand('copy');
-        ta.remove();
-        return ok;
-      } catch (_e) {
-        return false;
-      }
-    }
+    await window.OTBTaskLib.copyTaskPrompt(t, btn, toast);
   }
+  // The hall's one clipboard write (task-lib.js), kept under this name for the ctx below.
+  const copyText = (text) => window.OTBTaskLib.copyText(text);
 
   // ---- bulk selection (task 1759) -------------------------------------------
 

package/modules/lifecycle/kickoff-checklist.js

@@ -148,7 +148,7 @@ const GENESIS_STEPS = Object.freeze({
   ],
   strategize: [
     { title: 'Write out the strategy, or link the one you already have',
-      description: 'Genesis stage 2 (strategize). How the project gets from here to its first version: the order of the big pieces, the risks, and what gets tried first. A strategy that already exists can be linked instead. When it is done, Tasks wake.' },
+      description: 'Genesis stage 2 (strategize). How the project gets from here to its first version: the order of the big pieces, the risks, and what gets tried first. You are the author, and you choose how to work: be guided through the questions, write it yourself on a blank page, or have your own AI session help (it asks the same questions and pushes back, and you decide) — switch any time, nothing is lost. A strategy that already exists can be linked instead. Run `npx bongos genesis show strategize` to see the questions and your answers, or `npx bongos genesis assist strategize` for the brief to give your AI session. When it is done, Tasks wake.' },
   ],
   charter: [
     { title: 'Choose the starting government and write the bylaws',

package/modules/lifecycle/kickoff-seed.js

@@ -112,20 +112,24 @@ async function seedGenesisStages({ builderId = null, existing = false } = {}, de
   return { seeded, versionId };
 }
 
-// genesisStageTasks(deps) → { stageKey: [{ id, title, status }] } for every genesis
-// task on the board, grouped by the stage its source_ref names. The genesis home lists
-// them, and a stage close hands their ids to the Board Room's finished-tasks gate.
+// genesisStageTasks(deps) → { stageKey: [{ id, title, status, description }] } for every
+// genesis task on the board, grouped by the stage its source_ref names. The genesis home
+// lists them, and a stage close hands their ids to the Board Room's finished-tasks gate.
+// The description rides along so each row's Copy prompt carries the task's own words
+// (task 1005109); the read stays bounded, it is only the few seeded genesis tasks.
 async function genesisStageTasks(deps = {}) {
   const pool = deps.pool || api.pool;
   const { rows } = await pool.query(
-    `SELECT id, title, status, source_ref FROM tasks WHERE source = $1 ORDER BY id ASC`,
+    `SELECT id, title, status, description, source_ref FROM tasks WHERE source = $1 ORDER BY id ASC`,
     [GENESIS_SOURCE],
   );
   const out = {};
   for (const r of rows) {
     const stage = String(r.source_ref || '').split(':')[1];
     if (!stage) continue;
-    (out[stage] = out[stage] || []).push({ id: String(r.id), title: r.title, status: r.status });
+    (out[stage] = out[stage] || []).push({
+      id: String(r.id), title: r.title, status: r.status, description: r.description || '',
+    });
   }
   return out;
 }

package/modules/onboarding/genesis-home.js

@@ -146,7 +146,7 @@ const FINISHED = Object.freeze(['shipped', 'abandoned']); // the Board Room's ow
 // 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 }] }
+//   tasks   { stage: [{ id, title, status, description }] }
 //   board   { stage: genesisStageStatus row } or {}
 //   stageAt { stage: ISO } — when each stage began, for its due date
 function shapeGenesis({ mode, plan, tasks = {}, board = {}, stageAt = {} }) {

package/modules/onboarding/genesis-work.js

@@ -0,0 +1,364 @@
+'use strict';
+
+// modules/onboarding/genesis-work.js — THE FOUNDER'S OWN WORK ON A GENESIS STAGE: one
+// stored record per stage that three ways of working all read and write (task 1005116,
+// goal 1000106; owner ruling 2026-11-07).
+//
+// WHY. A genesis stage is a decision only the founder can make. It used to have one
+// route through it: an AI session drafted the stage's answer, and the project's strategy
+// (or scope) became the model's. The owner's rule: Bongos may structure the thinking
+// and may help with the words, but THE FOUNDER IS THE AUTHOR. So every stage offers
+// three DOORS onto the same work, and the founder picks and switches freely:
+//
+//   guided    the platform asks the stage's questions one at a time; the founder
+//             answers every one. The DEFAULT, offered first: a blank page is how a
+//             stage comes back thin.
+//   open      a blank page and the stage's done-when line. The questions still show
+//             beside it, as the shape of a good answer, never as fields to fill.
+//   assisted  the founder's own AI session helps (assistPrompt): it works the SAME
+//             questions, pushes back and offers options, and records only what the
+//             founder decides.
+//
+// Plus the fourth way that already existed: link the document you already have.
+//
+// ONE ARTIFACT, NOT THREE FLOWS. The door is only how the founder is working right now.
+// The answers, the free page and the link are one record per stage, kept whatever the
+// door, so switching loses nothing: start guided, finish on the page, ask the session
+// to poke holes in it.
+//
+// AN ANSWER IS STORED AS AN ANSWER, never as prose inside a task description, so every
+// later goal and task can read it (contextMarkdown, `GET /founding/context`). Each has
+// a STATE, and the three are deliberately distinct from one another and from "empty":
+//   answered   the founder's words
+//   not_sure   "not sure yet" — an answer, not a gap (an optional note says why)
+//   skipped    the founder chose to pass on it
+//   (no row)   never touched
+// Un-answering deletes the row, back to empty. Each answer carries its ORIGIN —
+// `founder` (typed by them), `assisted` (worked out with their session and accepted by
+// them) or `carried_over` (brought in from before sign-up, task 1005274; shown as
+// editable, and any edit by the founder makes it theirs). Every write and every
+// un-answer appends a history row, so the founder can see what an answer used to say.
+//
+// WHICH STAGES. A stage adopts the pattern by declaring its questions in QUESTIONS.
+// Strategize does here; scope's guided door is its project interview (task 1005114);
+// charter, legalize and legislation adopt it when they are next touched. A stage with
+// no questions still takes a free page and a link.
+//
+// THE BOUNDARY. Pure apart from the store. The store is injected (tests) or the
+// Postgres one below, over the doorway's pool; tables in
+// migrations/onboarding_002_genesis_work.sql.
+
+const fm = require('./founding-mode');
+
+const STAGES = Object.freeze(fm.STAGES.slice(1)); // scope … legislation
+const DOORS = Object.freeze(['guided', 'open', 'assisted']);
+const DEFAULT_DOOR = 'guided';
+const STATES = Object.freeze(['answered', 'not_sure', 'skipped']);
+const ORIGINS = Object.freeze(['founder', 'assisted', 'carried_over']);
+const LIMITS = Object.freeze({ answer: 4000, page: 20000, link: 500 });
+
+// Each adopted stage's questions, in the order the guided door asks them. `id` is
+// stable: a stored answer names it, so never rename or reuse one. `hint` is the shape
+// of a good answer, shown under the question in every door.
+const QUESTIONS = Object.freeze({
+  strategize: Object.freeze([
+    Object.freeze({ id: 'big_pieces', ask: 'What are the big pieces, and in what order do they get built?',
+      hint: 'Three to six pieces is plenty. Say why that order: what has to exist before what.' }),
+    Object.freeze({ id: 'risks', ask: 'What are the biggest risks, the things that could sink this?',
+      hint: 'Name what you are least sure of: a technical unknown, whether anyone wants it, time, money.' }),
+    Object.freeze({ id: 'try_first', ask: 'What gets tried first, and why that?',
+      hint: 'Usually the cheapest test of the biggest risk.' }),
+    Object.freeze({ id: 'change_course', ask: 'What would make you change course?',
+      hint: 'The signal that would tell you this plan is wrong, so you notice it when it comes.' }),
+  ]),
+});
+
+const isStage = (s) => STAGES.includes(s);
+const questionsFor = (stage) => QUESTIONS[stage] || [];
+const questionFor = (stage, id) => questionsFor(stage).find((q) => q.id === id) || null;
+const text = (v) => (v == null ? '' : String(v)).trim();
+
+// ── pure: checking a write ────────────────────────────────────────────────────
+
+// checkAnswer(stage, questionId, body) → { ok, value } or { ok:false, reason }.
+//   body: { state, text?, origin? }. `answered` needs words; `not_sure` and `skipped`
+//   may carry a short note. The origin defaults to `founder`.
+function checkAnswer(stage, questionId, body = {}) {
+  if (!isStage(stage)) return { ok: false, reason: 'unknown_stage' };
+  if (!questionFor(stage, questionId)) return { ok: false, reason: 'unknown_question' };
+  const b = body && typeof body === 'object' ? body : {};
+  const state = b.state == null ? 'answered' : String(b.state);
+  if (!STATES.includes(state)) return { ok: false, reason: 'bad_state' };
+  const origin = b.origin == null ? 'founder' : String(b.origin);
+  if (!ORIGINS.includes(origin)) return { ok: false, reason: 'bad_origin' };
+  const words = text(b.text);
+  if (words.length > LIMITS.answer) return { ok: false, reason: 'answer_too_long' };
+  if (state === 'answered' && !words) return { ok: false, reason: 'empty_answer' };
+  return { ok: true, value: { state, answer_md: words || null, origin } };
+}
+
+// checkLink(url) → { ok, value } — an http(s) address, or '' / null to remove it.
+function checkLink(url) {
+  const u = text(url);
+  if (!u) return { ok: true, value: null };
+  if (u.length > LIMITS.link) return { ok: false, reason: 'link_too_long' };
+  if (!/^https?:\/\/[^\s]+$/i.test(u)) return { ok: false, reason: 'bad_link' };
+  return { ok: true, value: u };
+}
+
+// ── pure: the view ────────────────────────────────────────────────────────────
+
+const iso = (v) => (v ? new Date(v).toISOString() : null);
+
+// shapeStage(stage, work, answers) → one stage's record as every door sees it.
+//   work     the stage row ({ door, page_md, link_url, updated_at }) or null
+//   answers  the stage's answer rows
+function shapeStage(stage, work, answers = []) {
+  const byId = new Map(answers.filter((a) => a.stage === stage).map((a) => [a.question_id, a]));
+  const questions = questionsFor(stage).map((q) => {
+    const a = byId.get(q.id);
+    return {
+      id: q.id, ask: q.ask, hint: q.hint,
+      answer: a ? {
+        state: a.state, text: a.answer_md || null, origin: a.origin,
+        // A carried-over answer is shown as such until the founder makes it theirs.
+        carried_over: a.origin === 'carried_over',
+        updated_at: iso(a.updated_at),
+      } : null,
+    };
+  });
+  const count = (st) => questions.filter((q) => q.answer && q.answer.state === st).length;
+  return {
+    stage,
+    adopted: questionsFor(stage).length > 0,
+    door: (work && DOORS.includes(work.door)) ? work.door : DEFAULT_DOOR,
+    doors: DOORS,
+    questions,
+    page: work && work.page_md ? work.page_md : null,
+    link: work && work.link_url ? work.link_url : null,
+    counts: {
+      total: questions.length,
+      answered: count('answered'),
+      not_sure: count('not_sure'),
+      skipped: count('skipped'),
+      empty: questions.filter((q) => !q.answer).length,
+    },
+    updated_at: iso(work && work.updated_at),
+  };
+}
+
+// shapeAll({ work, answers }) → every stage, in genesis order.
+function shapeAll({ work = [], answers = [] } = {}) {
+  const byStage = new Map(work.map((w) => [w.stage, w]));
+  return STAGES.map((s) => shapeStage(s, byStage.get(s) || null, answers));
+}
+
+const STATE_WORDS = { not_sure: 'Not sure yet', skipped: 'Skipped by the founder' };
+const ORIGIN_WORDS = { assisted: ' (worked out with an AI session, accepted by the founder)', carried_over: ' (carried over from before sign-up, not yet confirmed by the founder)' };
+
+// contextMarkdown(stages) → THE READ PATH for an AI session planning a goal or task:
+// what the founder has said about the project, stage by stage, as plain markdown. Only
+// stages with something in them appear; an empty project returns an empty string so a
+// caller can say nothing rather than print an empty heading.
+function contextMarkdown(stages) {
+  const out = [];
+  for (const s of stages || []) {
+    const said = s.questions.filter((q) => q.answer);
+    if (!said.length && !s.page && !s.link) continue;
+    out.push(`## ${s.stage[0].toUpperCase()}${s.stage.slice(1)}`);
+    for (const q of said) {
+      const a = q.answer;
+      const body = a.state === 'answered' ? a.text : `${STATE_WORDS[a.state]}${a.text ? ` — ${a.text}` : ''}`;
+      out.push(`- **${q.ask}**${ORIGIN_WORDS[a.origin] || ''}\n  ${String(body).replace(/\n/g, '\n  ')}`);
+    }
+    if (s.page) out.push('', '**In the founder\'s own words:**', '', s.page);
+    if (s.link) out.push('', `**The founder's existing document:** ${s.link}`);
+    out.push('');
+  }
+  if (!out.length) return '';
+  return ['# What the founder has said about this project', '',
+    'Written by the founder during genesis. Treat it as the project\'s own direction: plan inside it, and say so when a goal or task would go against it. "Not sure yet" is an honest answer, not a gap to fill in for them.', '',
+    ...out].join('\n').trimEnd() + '\n';
+}
+
+// assistPrompt(stage) → the brief the founder hands their own AI session for the
+// assisted door. It works the stage's own questions (never a shape of its own),
+// argues rather than authors, and records only what the founder decides.
+function assistPrompt(stage) {
+  if (!isStage(stage)) return null;
+  const qs = questionsFor(stage);
+  const lines = [
+    `Help me work through the ${stage} stage of my project's genesis. I am the author; you are my assistant.`,
+    '',
+    'How to help:',
+    '- Work these questions, one at a time, in this order. Do not invent a different structure.',
+    '- Ask what I am assuming. Push back when an answer is vague or I seem too sure.',
+    '- Offer two or three options when I am stuck, never one confident answer.',
+    '- "Not sure yet" is a fine answer. Record it as that rather than filling the gap for me.',
+    '- Record an answer only after I say it is mine, in my words (you may tidy the wording; read it back first).',
+    '',
+  ];
+  if (qs.length) {
+    lines.push('The questions:');
+    qs.forEach((q, i) => lines.push(`${i + 1}. ${q.ask} (${q.hint})`));
+    lines.push('');
+  }
+  lines.push('To see what I have already said:  npx bongos genesis show ' + stage);
+  if (qs.length) {
+    lines.push(`To record an answer I accepted:    npx bongos genesis answer ${stage} <question-id> "<my words>" --origin assisted`);
+    lines.push(`To record "not sure yet":          npx bongos genesis answer ${stage} <question-id> --not-sure ["why"]`);
+  }
+  lines.push(`To save a page I wrote:            npx bongos genesis page ${stage} --file <path>`);
+  return lines.join('\n');
+}
+
+// ── the store (Postgres) ──────────────────────────────────────────────────────
+
+function pgStore(pool) {
+  const db = () => pool || require('../../src/module-api').pool;
+  return {
+    async loadAll() {
+      const [w, a] = await Promise.all([
+        db().query('SELECT stage, door, page_md, link_url, updated_at FROM onboarding_genesis_work'),
+        db().query('SELECT stage, question_id, state, answer_md, origin, updated_at FROM onboarding_genesis_answers'),
+      ]);
+      return { work: w.rows, answers: a.rows };
+    },
+    // patch: any of { door, page_md, link_url }; an absent key keeps what is stored.
+    async upsertWork(stage, patch, by) {
+      const has = (k) => Object.prototype.hasOwnProperty.call(patch, k);
+      await db().query(
+        `INSERT INTO onboarding_genesis_work (stage, door, page_md, link_url, updated_by)
+         VALUES ($1, COALESCE($2, '${DEFAULT_DOOR}'), $4, $6, $8)
+         ON CONFLICT (stage) DO UPDATE SET
+           door     = CASE WHEN $3 THEN EXCLUDED.door ELSE onboarding_genesis_work.door END,
+           page_md  = CASE WHEN $5 THEN EXCLUDED.page_md ELSE onboarding_genesis_work.page_md END,
+           link_url = CASE WHEN $7 THEN EXCLUDED.link_url ELSE onboarding_genesis_work.link_url END,
+           updated_by = EXCLUDED.updated_by, updated_at = now()`,
+        [stage, has('door') ? patch.door : null, has('door'), has('page_md') ? patch.page_md : null,
+          has('page_md'), has('link_url') ? patch.link_url : null, has('link_url'), by == null ? null : by],
+      );
+    },
+    // One statement: the answer and its history row land together, and a write that
+    // changes nothing writes neither. ifEmpty never touches an answer already there.
+    async writeAnswer(stage, questionId, v, by, { ifEmpty = false } = {}) {
+      const { rows } = await db().query(
+        `WITH up AS (
+           INSERT INTO onboarding_genesis_answers (stage, question_id, state, answer_md, origin, updated_by)
+           VALUES ($1, $2, $3, $4, $5, $6)
+           ON CONFLICT (stage, question_id) DO ${ifEmpty ? 'NOTHING' : `UPDATE SET
+             state = EXCLUDED.state, answer_md = EXCLUDED.answer_md, origin = EXCLUDED.origin,
+             updated_by = EXCLUDED.updated_by, updated_at = now()
+           WHERE (onboarding_genesis_answers.state, onboarding_genesis_answers.answer_md, onboarding_genesis_answers.origin)
+             IS DISTINCT FROM (EXCLUDED.state, EXCLUDED.answer_md, EXCLUDED.origin)`}
+           RETURNING stage, question_id, state, answer_md, origin, updated_by)
+         INSERT INTO onboarding_genesis_answer_history (stage, question_id, state, answer_md, origin, changed_by)
+         SELECT stage, question_id, state, answer_md, origin, updated_by FROM up
+         RETURNING id`,
+        [stage, questionId, v.state, v.answer_md, v.origin, by == null ? null : by],
+      );
+      return { changed: rows.length > 0 };
+    },
+    async clearAnswer(stage, questionId, by) {
+      const { rows } = await db().query(
+        `WITH del AS (
+           DELETE FROM onboarding_genesis_answers WHERE stage = $1 AND question_id = $2
+           RETURNING stage, question_id)
+         INSERT INTO onboarding_genesis_answer_history (stage, question_id, state, answer_md, origin, changed_by)
+         SELECT stage, question_id, NULL, NULL, NULL, $3 FROM del
+         RETURNING id`,
+        [stage, questionId, by == null ? null : by],
+      );
+      return { cleared: rows.length > 0 };
+    },
+    async history(stage, questionId) {
+      const { rows } = await db().query(
+        `SELECT state, answer_md, origin, changed_by, changed_at FROM onboarding_genesis_answer_history
+          WHERE stage = $1 AND question_id = $2 ORDER BY changed_at DESC, id DESC LIMIT 50`,
+        [stage, questionId],
+      );
+      return rows;
+    },
+  };
+}
+
+// ── the operations the routes call ────────────────────────────────────────────
+
+const storeOf = (deps = {}) => deps.store || pgStore(deps.pool);
+
+async function readAll(deps = {}) {
+  return shapeAll(await storeOf(deps).loadAll());
+}
+
+async function readStage(stage, deps = {}) {
+  if (!isStage(stage)) return { ok: false, reason: 'unknown_stage' };
+  const all = await readAll(deps);
+  return { ok: true, work: all.find((s) => s.stage === stage) };
+}
+
+async function setDoor(stage, door, by, deps = {}) {
+  if (!isStage(stage)) return { ok: false, reason: 'unknown_stage' };
+  if (!DOORS.includes(door)) return { ok: false, reason: 'bad_door' };
+  await storeOf(deps).upsertWork(stage, { door }, by);
+  return readStage(stage, deps);
+}
+
+async function setPage(stage, page, by, deps = {}) {
+  if (!isStage(stage)) return { ok: false, reason: 'unknown_stage' };
+  const words = text(page);
+  if (words.length > LIMITS.page) return { ok: false, reason: 'page_too_long' };
+  await storeOf(deps).upsertWork(stage, { page_md: words || null }, by);
+  return readStage(stage, deps);
+}
+
+async function setLink(stage, url, by, deps = {}) {
+  if (!isStage(stage)) return { ok: false, reason: 'unknown_stage' };
+  const c = checkLink(url);
+  if (!c.ok) return c;
+  await storeOf(deps).upsertWork(stage, { link_url: c.value }, by);
+  return readStage(stage, deps);
+}
+
+// setAnswer — store or revise one answer. opts.ifEmpty (for carrying answers over,
+// task 1005274) writes only where the founder has said nothing yet.
+async function setAnswer(stage, questionId, body, by, deps = {}, opts = {}) {
+  const c = checkAnswer(stage, questionId, body);
+  if (!c.ok) return c;
+  const { changed } = await storeOf(deps).writeAnswer(stage, questionId, c.value, by, opts);
+  const r = await readStage(stage, deps);
+  return { ...r, changed };
+}
+
+// clearAnswer — un-answer: the question goes back to empty (not to "skipped").
+async function clearAnswer(stage, questionId, by, deps = {}) {
+  if (!isStage(stage)) return { ok: false, reason: 'unknown_stage' };
+  if (!questionFor(stage, questionId)) return { ok: false, reason: 'unknown_question' };
+  const { cleared } = await storeOf(deps).clearAnswer(stage, questionId, by);
+  const r = await readStage(stage, deps);
+  return { ...r, cleared };
+}
+
+async function answerHistory(stage, questionId, deps = {}) {
+  if (!isStage(stage)) return { ok: false, reason: 'unknown_stage' };
+  if (!questionFor(stage, questionId)) return { ok: false, reason: 'unknown_question' };
+  const rows = await storeOf(deps).history(stage, questionId);
+  return {
+    ok: true,
+    history: rows.map((r) => ({
+      state: r.state || 'cleared', text: r.answer_md || null, origin: r.origin || null,
+      changed_by: r.changed_by == null ? null : String(r.changed_by), changed_at: iso(r.changed_at),
+    })),
+  };
+}
+
+async function readContext(deps = {}) {
+  const stages = await readAll(deps);
+  return { markdown: contextMarkdown(stages), stages };
+}
+
+// Only what a caller uses is exported; the checks and the view shaping stay private
+// and are exercised through the operations (tests/genesis_work.mjs).
+module.exports = {
+  STAGES, LIMITS, QUESTIONS, assistPrompt,
+  pgStore, readAll, readStage, setDoor, setPage, setLink, setAnswer, clearAnswer, answerHistory, readContext,
+};

package/modules/onboarding/migrations/onboarding_002_genesis_work.sql

@@ -0,0 +1,76 @@
+-- onboarding_002_genesis_work.sql — the founder's own work on each genesis stage
+-- (task 1005116; read modules/onboarding/genesis-work.js for the why).
+--
+-- Every genesis stage offers three ways of working (guided · open · assisted) onto ONE
+-- record per stage, so switching loses nothing:
+--   onboarding_genesis_work            one row per stage: the door the founder is using
+--                                      now, their free page, and a link to a document
+--                                      they already have
+--   onboarding_genesis_answers         one row per answered question. The state tells
+--                                      "answered", "not sure yet" and "skipped" apart;
+--                                      no row means never touched (empty). The origin
+--                                      says whose words: the founder's, worked out with
+--                                      their AI session, or carried over from before
+--                                      sign-up (task 1005274).
+--   onboarding_genesis_answer_history  append-only: every write and un-answer, so a
+--                                      revised answer keeps what it used to say. A NULL
+--                                      state is an un-answer.
+--
+-- The questions themselves are code (genesis-work.js QUESTIONS); the API refuses an id
+-- a stage does not name, so question_id is only shape-checked here.
+--
+-- ADDITIVE, module-owned (ADR 0083 §Decision #5). Idempotent: safe to re-run.
+
+BEGIN;
+
+CREATE TABLE IF NOT EXISTS onboarding_genesis_work (
+  stage       text        PRIMARY KEY,
+  door        text        NOT NULL DEFAULT 'guided',
+  page_md     text,
+  link_url    text,
+  updated_by  bigint      REFERENCES builders(id) ON DELETE SET NULL,
+  updated_at  timestamptz NOT NULL DEFAULT now(),
+  CONSTRAINT onboarding_genesis_work_stage_chk CHECK (stage IN ('scope', 'strategize', 'charter', 'legalize', 'legislation')),
+  CONSTRAINT onboarding_genesis_work_door_chk CHECK (door IN ('guided', 'open', 'assisted')),
+  CONSTRAINT onboarding_genesis_work_page_chk CHECK (page_md IS NULL OR length(page_md) <= 20000),
+  CONSTRAINT onboarding_genesis_work_link_chk CHECK (link_url IS NULL OR (length(link_url) <= 500 AND link_url ~* '^https?://'))
+);
+
+CREATE TABLE IF NOT EXISTS onboarding_genesis_answers (
+  stage        text        NOT NULL,
+  question_id  text        NOT NULL,
+  state        text        NOT NULL,
+  answer_md    text,
+  origin       text        NOT NULL DEFAULT 'founder',
+  updated_by   bigint      REFERENCES builders(id) ON DELETE SET NULL,
+  created_at   timestamptz NOT NULL DEFAULT now(),
+  updated_at   timestamptz NOT NULL DEFAULT now(),
+  PRIMARY KEY (stage, question_id),
+  CONSTRAINT onboarding_genesis_answers_stage_chk CHECK (stage IN ('scope', 'strategize', 'charter', 'legalize', 'legislation')),
+  CONSTRAINT onboarding_genesis_answers_qid_chk CHECK (question_id ~ '^[a-z][a-z0-9_]{1,39}$'),
+  CONSTRAINT onboarding_genesis_answers_state_chk CHECK (state IN ('answered', 'not_sure', 'skipped')),
+  CONSTRAINT onboarding_genesis_answers_origin_chk CHECK (origin IN ('founder', 'assisted', 'carried_over')),
+  -- "answered" always has words; the other two may carry a short note.
+  CONSTRAINT onboarding_genesis_answers_words_chk CHECK (state <> 'answered' OR length(btrim(coalesce(answer_md, ''))) > 0),
+  CONSTRAINT onboarding_genesis_answers_len_chk CHECK (answer_md IS NULL OR length(answer_md) <= 4000)
+);
+
+CREATE TABLE IF NOT EXISTS onboarding_genesis_answer_history (
+  id           bigserial   PRIMARY KEY,
+  stage        text        NOT NULL,
+  question_id  text        NOT NULL,
+  state        text,
+  answer_md    text,
+  origin       text,
+  changed_by   bigint      REFERENCES builders(id) ON DELETE SET NULL,
+  changed_at   timestamptz NOT NULL DEFAULT now(),
+  CONSTRAINT onboarding_genesis_answer_history_state_chk CHECK (state IS NULL OR state IN ('answered', 'not_sure', 'skipped'))
+);
+
+CREATE INDEX IF NOT EXISTS onboarding_genesis_answer_history_q_idx
+  ON onboarding_genesis_answer_history (stage, question_id, changed_at DESC);
+
+INSERT INTO schema_migrations (version) VALUES ('onboarding_002_genesis_work')
+  ON CONFLICT (version) DO NOTHING;
+
+COMMIT;

package/modules/onboarding/routes/genesis-work.js

@@ -0,0 +1,85 @@
+'use strict';
+
+// modules/onboarding/routes/genesis-work.js — the HTTP surface of the founder's own work
+// on each genesis stage (task 1005116; the why is in ../genesis-work.js). Mounted by the
+// onboarding route factory (./onboarding.js), on the same /api/bongos router.
+//
+// Who may do what: any signed-in builder READS (the whole team, and every AI session
+// planning a goal or task, reads what the founder said). Every WRITE is the project
+// owner's, behind the same `project.settings.manage` atom as the rest of genesis — the
+// founder is the author. Writes are allowed whether or not founding mode is on, so an
+// answer can be revised long after the project came alive.
+
+const api = require('../../../src/module-api');
+const work = require('../genesis-work');
+
+const REFUSALS = {
+  unknown_stage: 404, unknown_question: 404, bad_door: 400, bad_state: 400, bad_origin: 400,
+  empty_answer: 400, answer_too_long: 400, page_too_long: 400, link_too_long: 400, bad_link: 400,
+};
+
+// `deps` is for tests only (an in-memory store); production passes none.
+module.exports = function mountGenesisWorkRoutes(router, deps = {}) {
+  const owns = api.requirePermission('project.settings.manage');
+  const handle = (fn) => async (req, res) => {
+    try {
+      const r = await fn(req);
+      if (r && r.ok === false) {
+        return res.status(REFUSALS[r.reason] || 409).json({ error: { code: r.reason, message: r.reason } });
+      }
+      res.set('Cache-Control', 'no-store');
+      res.json(r);
+    } catch (err) {
+      api.logger('onboarding').error('[onboarding] genesis work', err);
+      res.status(500).json({ error: { code: 'genesis_work_failed', message: 'internal error' } });
+    }
+  };
+  const stage = (req) => String(req.params.stage);
+  const q = (req) => String(req.params.question);
+
+  // The read path for every door and for AI sessions planning a goal or task.
+  router.get('/founding/work', api.requireBuilder, handle(async () => ({ stages: await work.readAll(deps) })));
+  router.get('/founding/context', api.requireBuilder, handle(() => work.readContext(deps)));
+  router.get('/founding/work/:stage', api.requireBuilder, handle((req) => work.readStage(stage(req), deps)));
+  router.get('/founding/work/:stage/assist', api.requireBuilder, handle(async (req) => {
+    const prompt = work.assistPrompt(stage(req));
+    return prompt ? { prompt } : { ok: false, reason: 'unknown_stage' };
+  }));
+  router.get('/founding/work/:stage/answers/:question/history', api.requireBuilder,
+    handle((req) => work.answerHistory(stage(req), q(req), deps)));
+
+  // The founder's writes.
+  router.put('/founding/work/:stage/door', api.requireBuilder, owns,
+    (req, res, next) => {
+      if (api.validateOrRespond(req, res, { door: { type: 'string', required: true, maxLength: 16 } })) return;
+      next();
+    },
+    handle((req) => work.setDoor(stage(req), req.body.door, req.builder.id, deps)));
+  router.put('/founding/work/:stage/page', api.requireBuilder, owns,
+    (req, res, next) => {
+      if (api.validateOrRespond(req, res, { page: { type: 'string', maxLength: work.LIMITS.page } })) return;
+      next();
+    },
+    handle((req) => work.setPage(stage(req), req.body.page, req.builder.id, deps)));
+  router.put('/founding/work/:stage/link', api.requireBuilder, owns,
+    (req, res, next) => {
+      if (api.validateOrRespond(req, res, { url: { type: 'string', maxLength: work.LIMITS.link } })) return;
+      next();
+    },
+    handle((req) => work.setLink(stage(req), req.body.url, req.builder.id, deps)));
+  router.put('/founding/work/:stage/answers/:question', api.requireBuilder, owns,
+    (req, res, next) => {
+      if (api.validateOrRespond(req, res, {
+        state: { type: 'string', maxLength: 16 },
+        text: { type: 'string', maxLength: work.LIMITS.answer },
+        origin: { type: 'string', maxLength: 16 },
+        if_empty: { type: 'boolean' },
+      })) return;
+      next();
+    },
+    handle((req) => work.setAnswer(stage(req), q(req), req.body || {}, req.builder.id, deps,
+      { ifEmpty: req.body && req.body.if_empty === true })));
+  // Un-answer: back to empty, which is not the same as skipped.
+  router.delete('/founding/work/:stage/answers/:question', api.requireBuilder, owns,
+    handle((req) => work.clearAnswer(stage(req), q(req), req.builder.id, deps)));
+};

package/modules/onboarding/routes/onboarding.js

@@ -38,6 +38,7 @@ const foundingBuilders = require('../founding-builders');
 const genesis = require('../genesis-home');
 const foundingBirth = require('../founding-birth');
 const howtoState = require('../howto-state');
+const mountGenesisWorkRoutes = require('./genesis-work');
 
 // Register the `onboarding` kernel PORT. See the header + port.js for the full
 // consumer list and the graceful-degradation contract.
@@ -65,6 +66,8 @@ module.exports = function buildOnboardingRouter() {
     res.json({ builders });
   });
   mountGenesisRoutes(router);
+  // The founder's own work on each stage: three doors onto one record (task 1005116).
+  mountGenesisWorkRoutes(router);
   mountHowtoRoutes(router);
   return router;
 };