@bongos/core 1.25.19 → 1.25.21

package/docs/project-context.template.md

@@ -4,7 +4,7 @@
 >
 > **Relationship to the rest of the project:**
 > - [`CLAUDE.md`](../CLAUDE.md) is the **portable methodology core** Cloud Bongos ships — working rules, session protocol, claim→ship lifecycle, the [ADR 0061](adr/0061-context-layer-decomposition.md) content charter, the nested-`CLAUDE.md` pattern. Instance-agnostic; you do not author it.
-> - **The founder's own answers come first.** What the project is, who it is for, what success looks like and the bet it makes are asked in the genesis scope interview and stored as answers in Bongos, not here. `node scripts/bongos/genesis.js context` (or `npx bongos genesis context`) prints them. Where this file and those answers disagree, the answers are the founder's latest word ([ADR 0408](adr/0408-a-genesis-stage-is-three-doors-onto-one-record.md), task 1005114).
+> - **The founder's own answers come first.** What the project is, who it is for, what success looks like and the bet it makes are asked in the genesis scope interview and stored as answers in Bongos, not here. `node scripts/bongos/genesis.js context` (or `npx bongos genesis context`) prints them. Where this file and those answers disagree, the answers are the founder's latest word ([ADR 0408](adr/0408-a-genesis-stage-is-three-doors-onto-one-record.md), task 1005114). A founder who planned the project with the start-a-project guide before signing up also has a hand-off file (where the project started, the plan, the recommended modules and the first steps); the same command prints it first (task 1005274).
 > - **This file is the *prose* identity** — lore, vision, the why. The **machine-readable** identity (exact strings code reads: product/world/company names, domains, cookie/OAuth origins, currency label, palette, repo binding) lives in the branding contract [`config/branding.json`](../config/branding.json) ([`docs/branding-contract.md`](branding-contract.md)). **Where a name must be exact for code, the branding contract wins** — never re-hardcode a contract-owned string here.
 
 <!--

package/modules/front-door-guide/handoff.js

@@ -0,0 +1,120 @@
+'use strict';
+
+// modules/front-door-guide/handoff.js — THE GUIDE'S HAND-OFF (task 1005274, goal 1000106):
+// what a founder told the start-a-project guide, carried forward so nothing is asked twice.
+// PURE: a saved Plan in, words out. Nothing here calls an AI; it moves saved answers.
+//
+// Three readers, one source (the Plan the guide saved, plan.js):
+//   * the creation page's pre-fill reads the Plan itself (GET /front-door-guide/mine);
+//   * scopeAnswers(plan) → the Genesis scope interview's carried-over answers;
+//   * handoffMarkdown(plan) → the hand-off file: what the project is, the plan, the
+//     recommended modules and the first steps, written for the founder's own AI.
+//
+// THE SCOPE MAP IS EXPLICIT, and a question the plan does not answer stays EMPTY. The
+// plan's fields are what the guide asked; the scope interview's six questions
+// (modules/onboarding/genesis-work.js QUESTIONS.scope) are the founder's own. Only one
+// field says the same thing as a scope question. Every other question maps to null on
+// purpose: inventing "who it is for" or "the bet" from a chat that never asked would put
+// words in the founder's mouth, which is the one thing genesis exists to prevent.
+
+const SCOPE_MAP = Object.freeze({
+  what_creating: 'summary',     // "what are you creating" ← the guide's summary of what they said
+  goal_impact: null,            // the guide never asks why or for what impact
+  success_two_years: null,      // nor what success looks like
+  reach_who: null,              // the summary may mention who, but not as an answer to this
+  work_with_who: null,          // nor who they want working with them
+  others_wrong: null,           // nor the bet
+});
+
+const ANSWER_MAX = 4000;        // genesis-work.js LIMITS.answer
+const MARKDOWN_MAX = 12000;     // the hand-off rides an env line to the new project; keep it bounded
+const PROJECT_TYPE_WORDS = Object.freeze({
+  game: 'A game', research: 'Research', business: 'A business', 'non-profit': 'A non-profit', 'not-sure': 'Not decided yet',
+});
+
+const str = (v) => (typeof v === 'string' ? v.trim() : '');
+const list = (v) => (Array.isArray(v) ? v : []);
+
+// scopeAnswers(plan) → { question_id: text } for the questions the plan answers, and only
+// those. An empty object for no plan.
+function scopeAnswers(plan) {
+  const out = {};
+  if (!plan || typeof plan !== 'object') return out;
+  for (const [question, field] of Object.entries(SCOPE_MAP)) {
+    if (!field) continue;
+    const words = str(plan[field]).slice(0, ANSWER_MAX);
+    if (words) out[question] = words;
+  }
+  return out;
+}
+
+// handoffMarkdown(plan, { name }) → the hand-off file, or '' for no usable plan. Written
+// so an AI session that reads ONLY this file can say what the project is for and what to
+// do next, and knows these are carried-over words the founder has not yet confirmed.
+function handoffMarkdown(plan, { name = '' } = {}) {
+  if (!plan || typeof plan !== 'object' || !str(plan.summary)) return '';
+  const title = str(name);
+  const lines = [
+    `# ${title ? `${title}: ` : ''}where this project started`,
+    '',
+    'Before signing up, the founder talked with the start-a-project guide. This is what came out of that conversation, carried over so nobody asks them the same things again.',
+    '',
+    'If you are an AI session working on this project: read this first. It is a starting point, not the founder\'s final word. Where the founder has since answered the Genesis questions (`npx bongos genesis context`), their answers win. Confirm anything below with them before relying on it, and never ask them again what is already written here.',
+    '',
+    '## What the project is',
+    '',
+    str(plan.summary),
+    '',
+  ];
+  const type = PROJECT_TYPE_WORDS[plan.project_type];
+  if (type) lines.push(`**Kind of project:** ${type}`, '');
+  if (plan.starting_point === 'existing') {
+    lines.push('**Starting point:** they already have something.', '');
+    const have = list(plan.what_you_have).map(str).filter(Boolean);
+    if (have.length) lines.push('What they said they already have:', '', ...have.map((h) => `- ${h}`), '');
+  } else if (plan.starting_point === 'fresh') {
+    lines.push('**Starting point:** starting fresh.', '');
+  }
+  const how = list(plan.how_it_works).map(str).filter(Boolean);
+  if (how.length) lines.push('## The plan', '', ...how.map((h) => `- ${h}`), '');
+  const modules = list(plan.modules).filter((m) => m && str(m.key));
+  if (modules.length) {
+    lines.push('## Recommended modules', '');
+    for (const m of modules) {
+      const why = str(m.why);
+      lines.push(`- **${str(m.label) || str(m.key)}** (\`${str(m.key)}\`)${str(m.summary) ? `: ${str(m.summary)}` : ''}${why ? ` Why: ${why}` : ''}`);
+    }
+    lines.push('');
+  }
+  const steps = list(plan.steps).filter((s) => s && str(s.title));
+  if (steps.length) {
+    lines.push('## First steps', '');
+    steps.forEach((s, i) => lines.push(`${i + 1}. **${str(s.title)}**${str(s.detail) ? ` ${str(s.detail)}` : ''}`));
+    lines.push('');
+  }
+  const needs = list(plan.needs).filter((n) => n && str(n.item));
+  if (needs.length) {
+    lines.push('## What they will need', '');
+    for (const n of needs) lines.push(`- **${str(n.item)}**${str(n.detail) ? `: ${str(n.detail)}` : ''}`);
+    lines.push('');
+  }
+  const open = list(plan.open_questions).map(str).filter(Boolean);
+  if (open.length) lines.push('## Still open', '', ...open.map((q) => `- ${q}`), '');
+  lines.push('## Your next step', '',
+    steps.length
+      ? `Start with step 1, "${str(steps[0].title)}". Then open the Genesis scope questions with the founder (\`npx bongos genesis show scope\`): only "what are you creating" was carried over, and the rest are theirs to answer.`
+      : 'Open the Genesis scope questions with the founder (`npx bongos genesis show scope`): only "what are you creating" was carried over, and the rest are theirs to answer.',
+    '');
+  const md = lines.join('\n');
+  return md.length > MARKDOWN_MAX ? `${md.slice(0, MARKDOWN_MAX - 40).trimEnd()}\n\n(The rest was cut for length.)\n` : md;
+}
+
+// handoffFor(plan, opts) → { scope, markdown } | null — what the provisioning port hands the
+// create route to stamp on a new project.
+function handoffFor(plan, opts = {}) {
+  const markdown = handoffMarkdown(plan, opts);
+  if (!markdown) return null;
+  return { scope: scopeAnswers(plan), markdown };
+}
+
+module.exports = { SCOPE_MAP, MARKDOWN_MAX, scopeAnswers, handoffMarkdown, handoffFor };

package/modules/front-door-guide/module.json

@@ -25,7 +25,7 @@
       "retention-sweep"
     ]
   },
-  "provides": [],
+  "provides": ["front-door-guide.handoff"],
   "consumes": [],
   "dependencies": { "@anthropic-ai/sdk": "^0.131.0" }
 }

package/modules/front-door-guide/routes/front-door-guide-plan.js

@@ -5,6 +5,7 @@
 //   POST /front-door-guide/conversations/:id/plan    write (or re-read) the plan   { token, website? }
 //   POST /front-door-guide/conversations/:id/attach  put the chat on my account    { token }
 //   GET  /front-door-guide/mine                      my newest chat and its plan
+//   GET  /front-door-guide/mine/handoff.md           my plan as the hand-off file, a download  (?name=)
 //
 // The plan is ONE structured-output call per chat (a JSON schema, never parsed prose),
 // asked once the visitor has said something; a second request re-reads the stored plan
@@ -29,6 +30,7 @@ const claude = require('../claude');
 const { readSettings } = require('../settings');
 const L = require('../limits');
 const C = require('../context');
+const H = require('../handoff');
 
 const log = api.logger('front-door-guide');
 const ID_RE = /^\d{1,18}$/;
@@ -62,8 +64,19 @@ function mineView(conv, settings) {
   };
 }
 
+// The `front-door-guide.handoff` port (task 1005274): the signed-in builder's newest attached
+// plan as { scope, markdown }, or null. The hub's create route stamps it on a new project
+// (modules/provisioning/guide-handoff.js), which is how the guide's answers reach a project
+// whose database this process cannot touch. Read-only.
+async function handoffForBuilder(builderId, { name = '' } = {}) {
+  if (builderId == null) return null;
+  const conv = await db.latestForBuilder(builderId);
+  return conv && conv.plan ? H.handoffFor(conv.plan, { name }) : null;
+}
+
 module.exports = function buildFrontDoorGuidePlanRouter() {
   const router = express.Router();
+  if (!api.hasProvider('front-door-guide.handoff')) api.registerProvider('front-door-guide.handoff', handoffForBuilder);
   let current = readSettings();
   const fresh = (req, res, next) => { current = readSettings(); next(); };
   const planLimit = L.makeLimiter({ windowMs: 60_000, max: () => current.messagesPerMinute, scope: 'front-door-guide-plan' });
@@ -141,5 +154,16 @@ module.exports = function buildFrontDoorGuidePlanRouter() {
     res.json({ ok: true, conversation: conv ? mineView(conv, current) : null });
   }));
 
+  // rank: builder — my plan as the hand-off file (task 1005274), offered as a download on the
+  // creation page. 404 with no plan. The name is only the file's title; it is never stored.
+  router.get('/front-door-guide/mine/handoff.md', api.requireBuilder, api.asyncHandler('GET /front-door-guide/mine/handoff.md', async (req, res) => {
+    const name = typeof req.query.name === 'string' ? req.query.name.replace(/[\r\n#]/g, ' ').trim().slice(0, 80) : '';
+    const h = await handoffForBuilder(req.builder.id, { name });
+    if (!h) return res.status(404).json({ ok: false, error: 'no_plan' });
+    res.set('Cache-Control', 'no-store');
+    res.set('Content-Disposition', 'attachment; filename="PROJECT-HANDOFF.md"');
+    res.type('text/markdown; charset=utf-8').send(h.markdown);
+  }));
+
   return router;
 };

package/modules/government/board.js

@@ -256,20 +256,20 @@ function validateVote({ direction, reasonMd, sectionKey } = {}) {
 //   { ok: true,  vote, fresh: false, self_cast }               — idempotent re-cast
 //   { ok: false, reason: 'item_not_found' | 'item_closed' | 'vote_window_expired'
 //               | 'not_board_member' | 'bad_cast_via' | <validateVote reason> }
-// `castVia` (task 1005121, government_038) is internal — never read from a request: 'ballot', or 'stage_close' (genesis-close.js: a founder's confirm given by closing a genesis stage — genesis_stage + yes only, no vote karma).
+// `castVia` (task 1005121, government_038) is internal — never read from a request: 'ballot', 'stage_close' (genesis-close.js: a founder's confirm given by closing a genesis stage — genesis_stage + yes only, no vote karma), or 'filed' (sole-member.js, task 1005130 / government_039: a board of one's confirm given by filing — constitutional_amendment + yes only, no vote karma).
 // 'anti_self_vote' is GONE as of task 1003273 — an author may cast; what they
 // cannot do is decide alone, which shouldCloseAfterVote and tallyOutcome enforce.
 // A self-cast is recorded and visible but earns no karma (karma_delta: 0).
 async function castVote({ itemId, voterId, direction, reasonMd = null, sectionKey = null, castVia = 'ballot' } = {}) {
   const id = Number(itemId);
   if (!Number.isFinite(id) || id <= 0) return { ok: false, reason: 'item_not_found' };
-  if (castVia !== 'ballot' && castVia !== 'stage_close') return { ok: false, reason: 'bad_cast_via' };
+  if (!['ballot', 'stage_close', 'filed'].includes(castVia)) return { ok: false, reason: 'bad_cast_via' };
   const v = validateVote({ direction, reasonMd, sectionKey });
   if (!v.ok) return v;
 
   const item = await db.getBoardItemForVote(id);
   if (!item) return { ok: false, reason: 'item_not_found' };
-  if (castVia === 'stage_close' && (item.subject_type !== 'genesis_stage' || v.direction !== 'yes')) return { ok: false, reason: 'bad_cast_via' };
+  if (castVia !== 'ballot' && (item.subject_type !== (castVia === 'filed' ? 'constitutional_amendment' : 'genesis_stage') || v.direction !== 'yes')) return { ok: false, reason: 'bad_cast_via' };
   if (item.closed_at) return { ok: false, reason: 'item_closed' };
   // The clock is checked here as well as by the R11 poller: a vote landing in
   // the gap between expiry and the sweep would be a vote after time. The
@@ -321,7 +321,7 @@ async function castVote({ itemId, voterId, direction, reasonMd = null, sectionKe
   }
   // Karma rides the FRESH insert only, and the whole route refused a closed or
   // expired item above, so every paid vote is by construction in-window.
-  if (isSelfCast || castVia === 'stage_close') {
+  if (isSelfCast || castVia !== 'ballot') {
     return { ok: true, vote: inserted, fresh: true, karma_delta: 0, self_cast: isSelfCast };
   }
   await db.insertVoteKarma({ voterId, itemId: id, delta: VOTE_KARMA_DELTA });
@@ -906,9 +906,10 @@ async function proposeCharter({
   }
   const unchanged = ['membership', 'pass_rule', 'window_minutes', 'close_early_on_full_turnout']
     .every((k) => v.proposal[k] === live[k]);
-  if (unchanged) return { ok: false, reason: 'no_change' };
-
+  // task 1005130: a choice that changes nothing SAYS so, and counts as done.
+  if (unchanged) return { ok: false, reason: 'no_change', in_force: charter.readCharter(live).name, complete: true, message: charter.alreadyLine(live) };
   const readsAs = charter.readCharter(v.proposal);
+  const next = `${readsAs.form === 'custom' ? 'These settings' : `Choosing ${readsAs.name}`} ${charter.whatHappensNext(live)}`;
   const out = await proposeAmendment({
     proposal: v.proposal,
     // The record says in words what was chosen, so the amendment history reads
@@ -917,7 +918,7 @@ async function proposeCharter({
     proposedBy,
     acknowledgeSelfRemoval,
   });
-  return out.ok ? { ...out, reads_as: readsAs } : out;
+  return out.ok ? { ...out, reads_as: readsAs, what_happens_next: next } : out;
 }
 
 // ── who decides what (task 1004529, ADR 0363) ───────────────────────────────

package/modules/government/charter-advice.js

@@ -67,12 +67,18 @@ function draftBylaws({ charter: rec, preset, prose = {} }) {
 // buildAdvice({ answers, prose, headcount, type, laws }) — PURE. `answers` holds only
 // the closed answers the founder actually gave (not "not sure yet", not skipped);
 // `laws` is db.listLaws() rows, so the preset view says which is in force now.
-function buildAdvice({ answers = {}, prose = {}, headcount = 0, type = null, laws = [] } = {}) {
+function buildAdvice({ answers = {}, prose = {}, headcount = 0, type = null, laws = [], board = null } = {}) {
   const rec = recommendedCharter(headcount, type, answers);
   const preset = presets.recommendedPreset(answers);
   const view = presets.presetsView(laws);
+  // task 1005130: what is true NOW, before the founder chooses — the form in force,
+  // every form saying who decides and what closing takes, and what choosing the
+  // recommended one would do (nothing, when it is already in force).
+  const forms = board ? charter.charterView(board) : null;
   return {
-    charter: rec,
+    in_force: forms ? forms.in_force : null,
+    forms: forms ? forms.forms : null,
+    charter: board ? { ...rec, on_choose: charter.choiceOutcome(board, rec.key) } : rec,
     // null when the founder's principles do not point at one — no preset is fine
     preset: preset ? { ...preset, locks: (view.presets.find((p) => p.key === preset.key) || {}).locks || [] } : null,
     preset_in_force: view.current,
@@ -91,13 +97,14 @@ function recommendedCharter(headcount, type, answers) {
 // otherwise the live count of active builders.
 async function charterAdvice({ answers, prose, headcount = null, type = null } = {}, deps = {}) {
   const db = deps.db || require('./db');
+  const board = deps.board !== undefined ? deps.board : require('./config').loadGovernmentConfig().board;
   const [count, laws] = await Promise.all([
     headcount != null && Number(headcount) > 0 ? Number(headcount) : db.countActiveBuilders(),
     db.listLaws(),
   ]);
   const p = {};
   for (const k of PROSE) if (prose && text(prose[k])) p[k] = text(prose[k]);
-  return buildAdvice({ answers, prose: p, headcount: count, type, laws });
+  return buildAdvice({ answers, prose: p, headcount: count, type, laws, board });
 }
 
 module.exports = { buildAdvice, charterAdvice };

package/modules/government/charter.js

@@ -123,6 +123,41 @@ const FORMS = freezeAll([
     explanation: 'Self-governing teams coordinate under one shared pact. Coming later, for projects with many teams.' },
 ]);
 
+// ── what a form asks of the founder day to day (task 1005130) ───────────────
+// Owner, 2026-11-07: "I am the monarch" read as "nothing is asked of me", and the
+// project still asked for a vote to close a stage. Monarchy means ONE yes decides,
+// not NO yes is needed. So every form says, beside its name, who decides and what
+// closing something takes — DERIVED from its franchise and pass rule, never written
+// by hand, so it can never disagree with what the board actually runs.
+const WHO_DECIDES = Object.freeze({
+  founder: 'You decide.',
+  trusted: 'You and the builders who have earned the trusted rank decide together.',
+  everyone: 'Every builder on the project decides.',
+  council: 'The council you appoint decides.',
+  custom: 'The members these settings seat decide.',
+});
+const TO_CLOSE = Object.freeze({
+  first_ratifier: 'Each decision takes one yes from one of them.',
+  consent: 'Each decision passes unless one of them objects, once they have all voted (or its clock runs out, if one is set).',
+  majority: 'Each decision needs a yes from more than half of them.',
+  unanimous: 'Each decision needs everyone who votes to agree, and at least one yes.',
+});
+// A board of one: every rule comes down to that one person's vote.
+const TO_CLOSE_FOUNDER = Object.freeze({
+  first_ratifier: 'Each decision takes one yes from you.',
+  consent: 'Each decision takes your vote: it passes unless you object.',
+  majority: 'Each decision takes one yes from you.',
+  unanimous: 'Each decision takes one yes from you.',
+});
+
+// dutyOf(franchise, passRule) → { who_decides, to_close } in plain words.
+function dutyOf(franchise, passRule) {
+  const who = WHO_DECIDES[franchise] || WHO_DECIDES.custom;
+  const close = (franchise === 'founder' ? TO_CLOSE_FOUNDER : TO_CLOSE)[passRule]
+    || 'This pass rule is not one this version knows; only its clock can close a decision.';
+  return { who_decides: who, to_close: close };
+}
+
 const CUSTOM_EXPLANATION = 'These settings match no named form of government. They are still the real rules the board runs under.';
 
 const byKey = (list, key) => list.find((x) => x.key === key) || null;
@@ -152,8 +187,8 @@ function readCharter(board) {
   const passRule = byKey(PASS_RULE_OPTIONS, b.pass_rule) ? b.pass_rule : 'custom';
   const form = FORMS.find((f) => f.available && f.franchise === franchise && f.pass_rule === passRule);
   return Object.freeze(form
-    ? { form: form.key, name: form.name, explanation: form.explanation, franchise, pass_rule: passRule }
-    : { form: 'custom', name: 'Custom', explanation: CUSTOM_EXPLANATION, franchise, pass_rule: passRule });
+    ? { form: form.key, name: form.name, explanation: form.explanation, franchise, pass_rule: passRule, ...dutyOf(franchise, passRule) }
+    : { form: 'custom', name: 'Custom', explanation: CUSTOM_EXPLANATION, franchise, pass_rule: passRule, ...dutyOf(franchise, passRule) });
 }
 
 // Build the WHOLE constitution a charter choice makes, on top of the live one.
@@ -209,17 +244,62 @@ function buildCharterProposal(liveBoard, { form, franchise, councilRank, passRul
 // The whole vocabulary plus what the constitution in force reads as — the
 // payload the genesis charter and legislation stages render from.
 function charterView(liveBoard) {
+  const readsAs = readCharter(liveBoard);
   return {
-    forms: FORMS,
+    // Every form, each saying what it asks day to day, and the one in force marked.
+    forms: FORMS.map((f) => (f.available
+      ? { ...f, ...dutyOf(f.franchise, f.pass_rule), current: f.key === readsAs.form }
+      : { ...f, current: false })),
+    in_force: inForce(readsAs),
     variables: VARIABLES.map((v) => (
       v.key === 'franchise' ? { ...v, options: FRANCHISE_OPTIONS }
         : v.key === 'pass_rule' ? { ...v, options: PASS_RULE_OPTIONS }
           : v.key === 'trajectory' ? { ...v, options: TRAJECTORIES }
             : v)),
-    reads_as: readCharter(liveBoard),
+    reads_as: readsAs,
   };
 }
 
+// inForce(readsAs) → what is true NOW, said before the founder chooses (task 1005130):
+// every project opens as Monarchy / BDFL, and a founder should learn that from the
+// platform rather than infer it from a choice that does nothing.
+function inForce(readsAs) {
+  const opening = readsAs.form === 'monarchy'
+    ? ' Every project opens as one, so choosing Monarchy / BDFL changes nothing.'
+    : '';
+  return Object.freeze({
+    form: readsAs.form,
+    name: readsAs.name,
+    who_decides: readsAs.who_decides,
+    to_close: readsAs.to_close,
+    line: `This project runs as ${readsAs.name} now.${opening} ${readsAs.who_decides} ${readsAs.to_close}`,
+  });
+}
+
+// choiceOutcome(liveBoard, formKey) → what choosing a form would DO, in words: nothing
+// (it is already in force, so this part of the stage is done), or an amendment
+// decided under the government in force — and, when one yes carries it, whose.
+function choiceOutcome(liveBoard, formKey) {
+  const now = readCharter(liveBoard);
+  const f = byKey(FORMS, formKey);
+  if (!f) return null;
+  if (now.form === f.key) return Object.freeze({ changes: false, complete: true, line: alreadyLine(liveBoard) });
+  return Object.freeze({ changes: true, complete: false, line: `Choosing ${f.name} ${whatHappensNext(liveBoard)}` });
+}
+
+// whatHappensNext(liveBoard) → the rest of the sentence "Choosing X …": a change is
+// filed as an amendment and decided under the government in force, and who carries it.
+function whatHappensNext(liveBoard) {
+  const now = readCharter(liveBoard);
+  const oneYes = now.pass_rule === 'first_ratifier';
+  const whose = now.franchise === 'founder' ? 'your own one yes applies it' : 'one yes from a member applies it';
+  return `is filed as a change to the rules and decided under the government in force (${now.name}). ${oneYes ? `Under it, ${whose}.` : now.to_close}`;
+}
+// alreadyLine(liveBoard) → "You are already a Monarchy / BDFL. Nothing to change…"
+function alreadyLine(liveBoard) {
+  return `You are already a ${readCharter(liveBoard).name}. Nothing to change, and this choice is done.`;
+}
+
 module.exports = {
   FORMS,
   VARIABLES,
@@ -227,6 +307,10 @@ module.exports = {
   PASS_RULE_OPTIONS,
   TRAJECTORIES,
   readCharter,
+  dutyOf,
+  choiceOutcome,
+  alreadyLine,
+  whatHappensNext,
   buildCharterProposal,
   charterView,
 };

package/modules/government/migrations/government_039_vote_cast_via_filed.sql

@@ -0,0 +1,22 @@
+-- government_039_vote_cast_via_filed.sql — a third way a vote is cast (task 1005130).
+--
+-- A board of ONE under first_ratifier: the board exists only to collect that one
+-- person's yes, so asking them to vote on their own instruction is ceremony, not
+-- governance (owner feedback 2026-11-07; the same ruling task 1005121 shipped for
+-- closing a genesis stage). When that sole member FILES an amendment, their yes is
+-- cast in the same call (sole-member.js) — and, as with a stage close, the record
+-- says HOW it was cast rather than looking like a clicked ballot.
+--
+--   cast_via  'ballot'       a vote cast in the Board Room (the vote route)
+--             'stage_close'  the confirm given by closing a genesis stage
+--             'filed'        the sole member's confirm given by filing an amendment;
+--                            only board.js writes it, only on a
+--                            constitutional_amendment item, only yes
+
+BEGIN;
+
+ALTER TABLE government_board_votes DROP CONSTRAINT IF EXISTS government_board_votes_cast_via_check;
+ALTER TABLE government_board_votes ADD CONSTRAINT government_board_votes_cast_via_check
+  CHECK (cast_via IN ('ballot', 'stage_close', 'filed') AND (cast_via = 'ballot' OR direction = 'yes'));
+
+COMMIT;

package/modules/government/routes/government.js

@@ -137,7 +137,7 @@ const governmentPort = {
   // an ordinary amendment under the constitution in force — for the genesis
   // home, which renders the stages from GET /government/constitution's
   // `charter` block. Opening a sitting decides nothing; the vote does.
-  proposeCharter: board.proposeCharter,
+  proposeCharter: (a) => require('../sole-member').proposeCharter(a), // task 1005130: a board of one decides by filing (sole-member.js), here and on every amendment route
   charterAdvice: (input) => require('../charter-advice').charterAdvice(input), // task 1005119: advice only, never a write
   genesisStageStatus: board.genesisStageStatus,
   // task 1004529 — who decides what. The table, resolved, and the check a
@@ -972,7 +972,7 @@ module.exports = function buildGovernmentRouter() {
       });
     }
     try {
-      const out = await board.proposeAmendment({
+      const out = await require('../sole-member').proposeAmendment({
         proposal: req.body.proposal,
         rationaleMd: req.body.rationale_md ?? null,
         proposedBy: req.builder.id,
@@ -1002,7 +1002,7 @@ module.exports = function buildGovernmentRouter() {
       if (wording && typeof wording.flagInvestmentWording === 'function' && typeof req.body.rationale_md === 'string') {
         wording.flagInvestmentWording(req.body.rationale_md, { where: 'board item', ref: out.item && out.item.id });
       }
-      res.status(201).json({ ok: true, amendment: out.amendment, item: out.item });
+      res.status(201).json({ ok: true, amendment: out.amendment, item: out.item , decided: out.decided });
     } catch (err) {
       log.error('[gds] POST /government/board/items', err);
       res.fail('propose_failed', { status: 500, message: 'internal error' });
@@ -1033,7 +1033,7 @@ module.exports = function buildGovernmentRouter() {
       return res.fail('invalid_proposal', 400, { reason: 'bad_window_minutes', expected: 'null (no clock) or a whole number of minutes' });
     }
     try {
-      const out = await board.proposeCharter({
+      const out = await require('../sole-member').proposeCharter({
         form: body.form ?? undefined,
         franchise: body.franchise ?? undefined,
         councilRank: body.council_rank ?? undefined,
@@ -1054,7 +1054,7 @@ module.exports = function buildGovernmentRouter() {
           });
         }
         if (out.reason === 'no_change') {
-          return res.fail('no_change', 409, { reason: 'the constitution in force already has these settings' });
+          return res.fail('no_change', 409, { reason: 'the constitution in force already has these settings', in_force: out.in_force, complete: true, message: out.message });
         }
         return res.fail('invalid_charter', 400, {
           reason: out.reason,
@@ -1063,7 +1063,7 @@ module.exports = function buildGovernmentRouter() {
           ...(out.rank_key ? { rank_key: out.rank_key } : {}),
         });
       }
-      res.status(201).json({ ok: true, amendment: out.amendment, item: out.item, reads_as: out.reads_as });
+      res.status(201).json({ ok: true, amendment: out.amendment, item: out.item, reads_as: out.reads_as, what_happens_next: out.what_happens_next , decided: out.decided });
     } catch (err) {
       log.error('[gds] POST /government/board/charter', err);
       res.fail('charter_failed', { status: 500, message: 'internal error' });
@@ -1090,7 +1090,7 @@ module.exports = function buildGovernmentRouter() {
       rationale_md: { type: 'string', maxLength: 5000 },
     })) return;
     try {
-      const out = await board.proposeDecisionRules({
+      const out = await require('../sole-member').proposeDecisionRules({
         rules: req.body.rules,
         rationaleMd: req.body.rationale_md ?? null,
         proposedBy: req.builder.id,
@@ -1105,7 +1105,7 @@ module.exports = function buildGovernmentRouter() {
           ...(out.rank_key ? { rank_key: out.rank_key } : {}),
         });
       }
-      res.status(201).json({ ok: true, amendment: out.amendment, item: out.item, rules: out.rules });
+      res.status(201).json({ ok: true, amendment: out.amendment, item: out.item, rules: out.rules , decided: out.decided });
     } catch (err) {
       log.error('[gds] POST /government/board/decision-rules', err);
       res.fail('propose_failed', { status: 500, message: 'internal error' });
@@ -1129,7 +1129,7 @@ module.exports = function buildGovernmentRouter() {
       rationale_md: { type: 'string', maxLength: 5000 },
     })) return;
     try {
-      const out = await board.proposeLaws({
+      const out = await require('../sole-member').proposeLaws({
         enact: req.body.enact,
         repeal: req.body.repeal,
         rationaleMd: req.body.rationale_md ?? null,
@@ -1150,7 +1150,7 @@ module.exports = function buildGovernmentRouter() {
           ...(out.setting ? { setting: out.setting } : {}),
         });
       }
-      res.status(201).json({ ok: true, amendment: out.amendment, item: out.item, proposal: out.proposal });
+      res.status(201).json({ ok: true, amendment: out.amendment, item: out.item, proposal: out.proposal , decided: out.decided });
     } catch (err) {
       log.error('[gds] POST /government/board/laws', err);
       res.fail('propose_failed', { status: 500, message: 'internal error' });
@@ -1200,14 +1200,14 @@ module.exports = function buildGovernmentRouter() {
         if (sw.reason === 'preset_in_force') return res.fail('preset_in_force', 409, { preset: req.body.preset });
         return res.fail('invalid_preset', 400, { reason: sw.reason, ...(sw.expected ? { expected: sw.expected } : {}) });
       }
-      const out = await board.proposeLaws({ ...sw.proposal, rationaleMd: sw.rationale, proposedBy: req.builder.id });
+      const out = await require('../sole-member').proposeLaws({ ...sw.proposal, rationaleMd: sw.rationale, proposedBy: req.builder.id });
       if (!out.ok) {
         if (out.reason === 'already_in_force' || out.reason === 'setting_already_locked' || out.reason === 'not_in_force') {
           return res.fail(out.reason, 409, { ...(out.law_id ? { law_id: out.law_id } : {}), ...(out.setting ? { setting: out.setting } : {}) });
         }
         return res.fail('invalid_preset', 400, { reason: out.reason });
       }
-      res.status(201).json({ ok: true, preset: req.body.preset, amendment: out.amendment, item: out.item, proposal: out.proposal });
+      res.status(201).json({ ok: true, preset: req.body.preset, amendment: out.amendment, item: out.item, proposal: out.proposal , decided: out.decided });
     } catch (err) {
       log.error('[gds] POST /government/board/presets', err);
       res.fail('propose_failed', { status: 500, message: 'internal error' });

package/modules/government/sole-member.js

@@ -0,0 +1,75 @@
+'use strict';
+// modules/government/sole-member.js — a board of ONE decides by filing (task 1005130,
+// part C; owner feedback 2026-11-07, the ruling task 1005121 shipped for closing a
+// genesis stage, applied wherever it holds).
+//
+// WHY. Under monarchy the board is one person, and a sitting it opens exists only to
+// collect that person's yes. Asking them to vote on their own instruction is a second
+// step that decides nothing: "the government is in place after it is defined, but it
+// still asked me to cast a vote". So when the SOLE member files an amendment, their
+// yes is cast in the same call and the sitting closes.
+//
+// EXACTLY THREE CONDITIONS, read on the server from the item's own snapshot — the
+// constitution in force at the moment of filing — never from the request:
+//   1. the pass rule is first_ratifier (one yes decides);
+//   2. the board that snapshot seats has exactly one member (live rows, uncached);
+//   3. the person filing IS that member.
+// Anything else — two or more members, any other rule, a caller who is not the sole
+// member — returns the filing untouched, byte for byte what it was before. Under
+// first_ratifier the first yes closes regardless of a window or early-close setting,
+// so neither changes the outcome here.
+//
+// NOTHING IS SKIPPED. The filing ran its own permission gate, strict validation and
+// self-removal guard before this is reached; the yes goes through board.castVote,
+// which re-checks membership under the snapshot, the window and the clock; the close
+// goes through board.maybeCloseAfterVote → closeItem, so a passed amendment is applied
+// and recorded exactly as a clicked ballot's would be. The vote is that member's,
+// attributed and timestamped, marked cast_via 'filed' (government_039) so the record
+// tells it from a ballot — the stage-close precedent — and it earns no vote karma.
+//
+// FAIL-OPEN. The filing already stands; if the confirm or the close fails, the
+// sitting is simply left open for an ordinary vote, as before this existed.
+//
+// Composed only from board.js's exports, looked up at call time (genesis-close.js's
+// pattern), so a test's stubs on board's db bite exactly as they do for board itself.
+const board = require('./board.js');
+const { resolveBoardMembers } = require('./board-membership.js');
+const log = require('../../src/module-api').logger('government');
+
+// confirmIfSoleMember(out, filedBy) → the filing's answer, plus `decided` when the
+// sole member's filing decided it: { closed, outcome, cast_via, constitution_not_applied? }.
+async function confirmIfSoleMember(out, filedBy) {
+  if (!out || !out.ok || !out.item || filedBy == null || filedBy === '') return out;
+  const item = out.item;
+  const constitution = item.constitution || {};
+  if (constitution.pass_rule !== 'first_ratifier') return out;
+  try {
+    const members = await resolveBoardMembers(constitution);
+    if (members.length !== 1 || String(members[0].builder_id) !== String(filedBy)) return out;
+    const v = await board.castVote({ itemId: item.id, voterId: filedBy, direction: 'yes', castVia: 'filed' });
+    if (!v.ok || !v.fresh) return out;
+    const c = await board.maybeCloseAfterVote(item.id);
+    return {
+      ...out,
+      decided: {
+        closed: !!(c && c.closed),
+        outcome: (c && c.outcome) || null,
+        cast_via: 'filed',
+        ...(c && c.constitution_not_applied ? { constitution_not_applied: c.constitution_not_applied } : {}),
+      },
+    };
+  } catch (err) {
+    log.error('[government] sole-member confirm failed (the filing stands; the sitting is left open):', err);
+    return out;
+  }
+}
+
+// The amendment filers, each followed by the confirm. Same arguments, same answer,
+// plus `decided` when a board of one decided it.
+const wrap = (name) => async (args = {}) => confirmIfSoleMember(await board[name](args), args.proposedBy);
+const proposeAmendment = wrap('proposeAmendment');
+const proposeCharter = wrap('proposeCharter');
+const proposeLaws = wrap('proposeLaws');
+const proposeDecisionRules = wrap('proposeDecisionRules');
+
+module.exports = { proposeAmendment, proposeCharter, proposeLaws, proposeDecisionRules };

package/modules/hall-ui/public/ai-studio.html

@@ -92,7 +92,7 @@
 <script src="/builders/shell-game.js?v=2026-11-11-view2"></script>
 <script src="/builders/shell-trail.js?v=2026-11-05-numbers"></script>
 <script src="/builders/craft-mode.js?v=2026-11-10-visor"></script>
-<script src="/builders/shell.js?v=2026-11-11-view2"></script>
+<script src="/builders/shell.js?v=2026-11-13-founding"></script>
 <script src="/builders/hall-dialog.js"></script>
 <script src="/builders/palette.js" defer></script>
 <script src="/builders/tweak-editor-lib.js?v=2026-09-28-tw23"></script>

package/modules/hall-ui/public/atlas.html

@@ -93,7 +93,7 @@
 <script src="/builders/shell-game.js?v=2026-11-11-view2"></script>
 <script src="/builders/shell-trail.js?v=2026-11-05-numbers"></script>
 <script src="/builders/craft-mode.js?v=2026-11-10-visor"></script>
-<script src="/builders/shell.js?v=2026-11-11-view2"></script>
+<script src="/builders/shell.js?v=2026-11-13-founding"></script>
 <script src="/builders/hall-dialog.js"></script>
 <!-- jump palette (Ctrl/Cmd-K). Optional by design: without it the shell's slot stays hidden. -->
 <script src="/builders/palette.js" defer></script>