@bongos/core 1.25.14 → 1.25.15

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;
 };

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.25.14",
+  "version": "1.25.15",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.25.14",
+      "version": "1.25.15",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.25.14",
+  "version": "1.25.15",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/release-notes.json

@@ -11806,5 +11806,11 @@
       "id": "1005279",
       "text": "The project guide now asks whether you are starting fresh or already have something, and for an existing project plans from your own description, without ever reading your files or code."
     }
+  ],
+  "1.25.15": [
+    {
+      "id": "1005116",
+      "text": "Founders now write their own strategy. Each setup stage can be done three ways: answer guided questions, write it freely, or get help from your own AI — and you can switch at any time without losing anything. Your answers are"
+    }
   ]
 }