@bongos/core 1.19.1005 → 1.19.1007

package/tests/ideator_full_idea_shapes_space_proof.mjs

@@ -0,0 +1,638 @@
+// tests/ideator_full_idea_shapes_space_proof.mjs
+//
+// THE PROOF for criterion `ideator-full-idea-shapes-the-space` (goal 1000095,
+// BONGOS-V2), written under task 1004104 (BV2.R25, spec R25). Sibling of
+// tests/ideator_traceable_proof.mjs (BV2.R21) and tests/ideator_fork_pays_proof.mjs
+// (BV2.R23), and it keeps their standard: a proof whose only possible outcome is
+// "confirmed" is not a proof. Every claim below was probed by breaking the real
+// code and watching this file go red — see the proof record at
+// docs/governance/bongos-v2-ideator-full-idea-shapes-the-space-proof.md.
+//
+// THE CLAIM BEING PROVED, in the criterion's own words: an ideator's best work
+// becomes the structure other people's thinking lands in. Concretely — a Full
+// Idea written through the five questions, carried by the Board Room, ratified as
+// a GOAL, produces a goal that CARRIES ITS FIVE ANSWERS. Scope comes from "scope
+// it as best as you can here"; done-when comes from "what does a successful
+// implementation of the idea look like".
+//
+// WHAT MAKES THIS DIFFERENT FROM tests/idea_goal_ratification.mjs, which already
+// covers this route well. That suite asserts what was BOUND to the INSERT
+// statements — the correct question for the route. It cannot see the hop that
+// matters to THIS criterion: what a builder who later OPENS the goal actually
+// gets back. A composer could render all five answers into a parameter that the
+// read path then never returns, and every assertion over the bound parameters
+// would stay green. So this file WRITES and then READS BACK, through the real
+// read functions (`getGoal`, `listCriteriaForGoal`), and asserts over the rows
+// those hand a reader. "The goal carries the answers" is a statement about a
+// read, so it is tested as one.
+//
+// THE STORE IS SMALL, REAL AND STRICT. It is a set of in-memory tables, not a
+// recorded query log: the chain has to be written and then read back, since the
+// ratification INSERTs the rows the goal read later returns, and a log replaying
+// canned answers would assert the fixture rather than the code. AND IT THROWS ON
+// ANY SQL IT DOES NOT RECOGNISE. That is the whole design — a store answering an
+// unmatched query with `{ rows: [] }` would let a renamed column or a new join
+// turn this proof into a vacuous green, which is the failure mode
+// docs/governance/bongos-v2-ideator-fork-proof.md exists to warn about.
+//
+// EVERY HOP IS REAL CODE:
+//   - the five answers are validated by the real `validateFieldValues` and
+//     written by the real `setIdeaGrade` (so the proof cannot smuggle in a shape
+//     capture would have refused);
+//   - the board gate is the real `government.boardPassForIdea`, reading the real
+//     `getLatestPassedItem` SQL against the store — NOT a stub returning `true`;
+//   - the goal is created by the real `lifecycle.createRatifiedGoal`, so the
+//     version gate and both rank gates are exercised;
+//   - the route is the real POST /inbox/:id/ratify-goal handler;
+//   - the read-back is the real `getGoal` + `listCriteriaForGoal`.
+//
+// DB-free (no DATABASE_URL on a builder box): pool.query and pool.connect are
+// patched on the doorway before the modules load, so the transaction is driven
+// rather than skipped.
+//
+// Run:  node tests/ideator_full_idea_shapes_space_proof.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const api = require('../src/module-api.js');
+
+// ---------------------------------------------------------------------------
+// The store: in-memory tables, written and read back, strict about its SQL.
+// ---------------------------------------------------------------------------
+
+const db = {
+  ideas: new Map(),            // id -> idea_inbox row
+  grades: new Map(),           // idea_id -> ideas_grades row
+  boardItems: [],              // government_board_items rows
+  versions: new Map(),         // id -> versions row
+  goals: new Map(),            // id -> goals row
+  criteria: [],                // done_when_criteria rows
+  goalMembers: [],             // goal_members rows
+  admissions: [],              // lifecycle_goal_version_admissions rows
+  ratifications: [],           // ideas_goal_ratifications rows
+};
+let nextId = 5000;
+const mint = () => String(++nextId);
+
+// Statements the chain legitimately runs that write nothing this proof reads —
+// listed rather than swallowed by a catch-all, so a NEW statement still throws.
+const IGNORED = [
+  /^BEGIN$/i, /^COMMIT$/i, /^ROLLBACK$/i,
+];
+
+let queries = [];
+
+function answer(sql, params) {
+  const s = sql.replace(/\s+/g, ' ').trim();
+
+  for (const re of IGNORED) if (re.test(s)) return { rows: [] };
+
+  // --- ideas_grades: the five answers being written (real setIdeaGrade) -----
+  if (/^INSERT INTO ideas_grades/i.test(s)) {
+    const [ideaId, grade, templateKey, fieldValuesJson, completeness, recommendation] = params;
+    const row = {
+      idea_id: String(ideaId), grade, template_key: templateKey,
+      // Stored as jsonb would store it: the object, NOT the caller's key order.
+      // `jsonbOrder` below is what makes this a real hazard rather than a prop.
+      field_values: jsonbOrder(JSON.parse(fieldValuesJson)),
+      completeness_score: completeness, recommendation: recommendation ?? null,
+      created_at: 'T0', updated_at: 'T0',
+    };
+    db.grades.set(row.idea_id, row);
+    return { rows: [row] };
+  }
+
+  // --- the board's decision (real getLatestPassedItem) ----------------------
+  if (/FROM government_board_items WHERE subject_type = \$1 AND subject_id = \$2 AND outcome = 'passed'/i.test(s)) {
+    const [subjectType, subjectId] = params;
+    const hits = db.boardItems
+      .filter((r) => r.subject_type === subjectType
+        && String(r.subject_id) === String(subjectId)
+        && r.outcome === 'passed')
+      .sort((a, b) => String(b.closed_at).localeCompare(String(a.closed_at)));
+    return { rows: hits.slice(0, 1).map((r) => ({
+      item_id: r.id, closed_at: r.closed_at, opened_at: r.opened_at, decided_under: r.constitution,
+    })) };
+  }
+
+  // --- the idea + its grade, locked (real ratifyFullIdeaAsGoal step a) ------
+  if (/FROM idea_inbox i LEFT JOIN ideas_grades g ON g\.idea_id = i\.id/i.test(s)) {
+    const idea = db.ideas.get(String(params[0]));
+    if (!idea) return { rows: [] };
+    const g = db.grades.get(String(params[0])) || null;
+    return { rows: [{
+      id: idea.id, title: idea.title, kind: idea.kind, status: idea.status,
+      captured_by: idea.captured_by,
+      grade: g ? g.grade : 'quick',
+      template_key: g ? g.template_key : null,
+      field_values: g ? g.field_values : null,
+      recommendation: g ? g.recommendation : null,
+    }] };
+  }
+
+  // --- the version, locked (real getVersion, forUpdate) --------------------
+  if (/FROM versions WHERE id = \$1/i.test(s)) {
+    const v = db.versions.get(String(params[0]));
+    return { rows: v ? [v] : [] };
+  }
+
+  // --- createGoal: one statement that writes three tables ------------------
+  if (/INSERT INTO goals \(version_id, title, subtitle, description/i.test(s)) {
+    const [versionId, title, description, scopeModules, status, createdBy, subtitle,
+      categoryId, admittedBy, admitReason] = params;
+    const order = [...db.goals.values()].filter((g) => g.version_id === versionId).length;
+    const goal = {
+      id: mint(), version_id: versionId, title, subtitle: subtitle ?? null,
+      description: description ?? null, scope_modules: scopeModules || [], status,
+      visibility: 'public', accepting_requests: true, created_by: createdBy ?? null,
+      succeeded_by_goal_id: null, sort_order: order, category_id: categoryId ?? null,
+      is_maintenance: false, created_at: 'T1', updated_at: 'T1',
+    };
+    db.goals.set(goal.id, goal);
+    // The two CTE side-writes, modelled because they are what makes `created_by`
+    // a grant of authority — claim 8 reads them.
+    if (createdBy != null) db.goalMembers.push({ goal_id: goal.id, builder_id: String(createdBy), membership_kind: 'lead' });
+    if (admittedBy != null) db.admissions.push({ goal_id: goal.id, version_id: versionId, admitted_by: String(admittedBy), reason: admitReason });
+    return { rows: [goal] };
+  }
+
+  // --- createCriterion: next sort_order, then the insert -------------------
+  if (/SELECT COALESCE\(MAX\(sort_order\), 0\) \+ 1 AS next FROM done_when_criteria/i.test(s)) {
+    const mine = db.criteria.filter((c) => c.version_id === String(params[0]));
+    return { rows: [{ next: mine.length + 1 }] };
+  }
+  if (/^INSERT INTO done_when_criteria/i.test(s)) {
+    const [versionId, criterionId, criterionMd, goalId, sortOrder] = params;
+    if (db.criteria.some((c) => c.version_id === versionId && c.criterion_id === criterionId)) {
+      const err = new Error('duplicate key value violates unique constraint');
+      err.code = '23505';
+      throw err;
+    }
+    const row = {
+      id: mint(), version_id: versionId, criterion_id: criterionId, criterion_md: criterionMd,
+      goal_id: goalId == null ? null : String(goalId), sort_order: sortOrder, satisfied: false,
+    };
+    db.criteria.push(row);
+    return { rows: [row] };
+  }
+
+  // --- the idea marked promoted -------------------------------------------
+  if (/^UPDATE idea_inbox SET status = 'promoted'/i.test(s)) {
+    const idea = db.ideas.get(String(params[0]));
+    if (idea) { idea.status = 'promoted'; idea.promoted_to_task_id = null; idea.reviewed_at = 'T2'; }
+    return { rows: [] };
+  }
+
+  // --- the audit row -------------------------------------------------------
+  if (/^INSERT INTO ideas_goal_ratifications/i.test(s)) {
+    const [ideaId, goalId, criterionId, boardItemId, targetVersion, scopeModules,
+      recommendationAtFiling, proposedBy, ratifiedBy, notesMd] = params;
+    if (db.ratifications.some((r) => r.idea_id === String(ideaId))) {
+      const err = new Error('duplicate key value violates unique constraint');
+      err.code = '23505';
+      throw err;
+    }
+    const row = {
+      id: mint(), idea_id: String(ideaId), goal_id: String(goalId), criterion_id: String(criterionId),
+      board_item_id: boardItemId == null ? null : String(boardItemId), target_version: targetVersion,
+      scope_modules: scopeModules, recommendation_at_filing: recommendationAtFiling ?? null,
+      proposed_by: proposedBy == null ? null : String(proposedBy),
+      ratified_by: String(ratifiedBy), notes_md: notesMd, ratified_at: 'T3',
+    };
+    db.ratifications.push(row);
+    return { rows: [{ id: row.id, ratified_at: row.ratified_at }] };
+  }
+
+  // --- THE READ BACK: what a builder opening the goal actually gets ---------
+  if (/FROM goals WHERE id = \$1/i.test(s)) {
+    const g = db.goals.get(String(params[0]));
+    // PROJECTED to the columns the read actually SELECTS, never handed back
+    // whole. This is load-bearing rather than tidy, and it was added because a
+    // probe caught its absence: the claim under proof is that a READER gets the
+    // five answers, and with the whole row echoed back, deleting `description`
+    // from the goal read's column list left all twelve cases GREEN. The store
+    // was answering a question the read had stopped asking.
+    return { rows: g ? [project(g, s)] : [] };
+  }
+  if (/WITH crit AS \( SELECT id, version_id, criterion_id, criterion_md, satisfied, sort_order, goal_id FROM done_when_criteria WHERE goal_id = \$1/i.test(s)) {
+    const rows = db.criteria
+      .filter((c) => c.goal_id === String(params[0]))
+      .sort((a, b) => a.sort_order - b.sort_order || String(a.id).localeCompare(String(b.id)))
+      .map((c) => ({ ...c, linked_tasks: 0, unshipped_tasks: 0 }));
+    return { rows };
+  }
+
+  // THE POINT OF THE STORE. An unmatched statement is a renamed column, a new
+  // join, or a hop that moved — every one of which would otherwise turn this
+  // proof green by answering nothing.
+  throw new Error(`the store does not recognise this SQL — a hop moved:\n  ${s.slice(0, 220)}`);
+}
+
+// Narrow a stored row to the columns a SELECT actually names — the difference
+// between proving what the code WROTE and proving what a reader can READ. An
+// unrecognised column name throws, for the store's own reason: a column that
+// exists in the SQL and not in the row is a schema that moved.
+function project(row, sql) {
+  const list = /^SELECT (.+?) FROM goals/i.exec(sql);
+  if (!list) throw new Error(`cannot read the column list off: ${sql.slice(0, 120)}`);
+  const cols = list[1].split(',').map((c) => c.trim());
+  const out = {};
+  for (const c of cols) {
+    if (!Object.hasOwn(row, c)) throw new Error(`the goals read selects a column the store has never heard of: ${c}`);
+    out[c] = row[c];
+  }
+  return out;
+}
+
+// jsonb does not preserve key insertion order, and the composer is forbidden from
+// reading order off the stored row (modules/ideas/templates.js says so in its own
+// header). The store models that hazard rather than assuming it away: everything
+// written comes back in reverse-declared order.
+function jsonbOrder(obj) {
+  return Object.fromEntries([...Object.entries(obj)].reverse());
+}
+
+const record = async (sql, params = []) => {
+  queries.push({ sql: sql.replace(/\s+/g, ' ').trim(), params });
+  return answer(sql, params);
+};
+
+api.pool.query = record;
+api.pool.connect = async () => ({ query: record, release() {} });
+
+// ---------------------------------------------------------------------------
+// The ports — BOTH real. The board read is the real government function over the
+// store, not a stub answering `true`: a stubbed board would let claim 5 pass
+// while the gate it names had been deleted.
+// ---------------------------------------------------------------------------
+
+const goalFromIdea = require('../modules/lifecycle/goal-from-idea.js');
+const governmentBoard = require('../modules/government/board.js');
+if (!api.hasProvider('lifecycle')) {
+  api.registerProvider('lifecycle', { createRatifiedGoal: goalFromIdea.createRatifiedGoal });
+}
+if (!api.hasProvider('government')) {
+  api.registerProvider('government', { boardPassForIdea: governmentBoard.boardPassForIdea });
+}
+
+const { BASE_V2_TEMPLATE, fieldOrder, validateFieldValues } = require('../modules/ideas/templates.js');
+const grades = require('../modules/ideas/grades.js');
+const lifecycleDb = require('../modules/lifecycle/db.js');
+require('../modules/ideas/inbox.js'); // registerSeams() side effect
+require('../modules/ideas/routes/inbox.js')({});
+const routesFactory = require('../modules/ideas/routes/ratify-goal.js');
+
+const router = routesFactory({});
+function handlerFor(path, method) {
+  const layer = router.stack.find((l) => l.route && l.route.path === path && l.route.methods[method]);
+  assert.ok(layer, `route ${method.toUpperCase()} ${path} exists`);
+  const stack = layer.route.stack.map((s) => s.handle);
+  return stack[stack.length - 1];
+}
+const postRatifyGoal = handlerFor('/inbox/:id/ratify-goal', 'post');
+
+function drive(handler, { body = {}, params = {}, builderId = '9', rank = 'metic' } = {}) {
+  return new Promise((resolve, reject) => {
+    const req = { body, params, query: {}, builder: { id: builderId, rank } };
+    const res = {
+      statusCode: 200,
+      status(c) { this.statusCode = c; return this; },
+      json(payload) { resolve({ status: this.statusCode, payload }); },
+      fail(code, status, extra) {
+        const st = typeof status === 'number' ? status : (status && status.status) || 500;
+        resolve({ status: st, payload: { error: code, ...(extra || {}) } });
+      },
+    };
+    Promise.resolve(handler(req, res)).catch(reject);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// One Full Idea, written once, used by every case. The answers are distinctive
+// prose rather than markers, so an assertion that the goal "carries the answer"
+// is an assertion about the author's actual words.
+// ---------------------------------------------------------------------------
+
+const AUTHOR = '42';
+const RATIFIER = '9';
+const IDEA_ID = '77';
+
+const ANSWERS = Object.freeze({
+  why_had: 'Watching a builder re-derive a decision that an idea had already settled two weeks earlier.',
+  scope: 'The ideas module and the lifecycle goal tables only. No hall route changes, no migrations beyond the ratification audit row, and nothing that touches the task board.',
+  build_context: 'Ratification runs inside one transaction and the lifecycle port owns every goal-creation gate.',
+  fit: 'Long term it is what makes an ideator worth having: their thinking becomes the container other work lands in.',
+  success: 'A Full Idea the board carries becomes a goal whose done-when is the author’s own success answer, and whose description carries all five.',
+});
+
+function seedIdea() {
+  db.ideas.set(IDEA_ID, {
+    id: IDEA_ID, title: 'An idea should be able to become the shape of the work',
+    kind: 'feature', status: 'open', captured_by: AUTHOR,
+  });
+}
+function seedBoardPass() {
+  db.boardItems.push({
+    id: '900', subject_type: 'full_idea', subject_id: IDEA_ID, outcome: 'passed',
+    opened_at: 'A', closed_at: 'B', constitution: {},
+  });
+}
+
+// Writes the five answers through the REAL capture validator and the REAL grade
+// writer. A shape capture would refuse can therefore never reach the ratifier.
+async function writeFullIdea({ recommendation = 'goal', answers = ANSWERS } = {}) {
+  const check = validateFieldValues(answers, { templateKey: 'base-v2' });
+  assert.ok(check.ok, `the five answers are what capture accepts: ${JSON.stringify(check.errors)}`);
+  await grades.setIdeaGrade(IDEA_ID, {
+    grade: 'full', templateKey: 'base-v2', fieldValues: answers,
+    completenessScore: 90, recommendation,
+  });
+}
+
+function reset() {
+  queries = [];
+  db.ideas.clear(); db.grades.clear(); db.goals.clear(); db.versions.clear();
+  db.boardItems.length = 0; db.criteria.length = 0; db.goalMembers.length = 0;
+  db.admissions.length = 0; db.ratifications.length = 0;
+  nextId = 5000;
+  db.versions.set('TEST-V1', { id: 'TEST-V1', name: 'Test', status: 'planning', scope_doc_path: null, started_at: null, shipped_at: null, done_when: null });
+  seedIdea();
+}
+
+const OK_BODY = { target_version: 'TEST-V1', scope_modules: ['ideas'] };
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  reset();
+  try { await fn(); passed++; console.log(`PASS  ${name}`); }
+  catch (err) { failed++; console.error(`FAIL  ${name}\n    ${err.message}`); }
+}
+
+// The label a field is declared under — what a reader sees as a heading.
+const labelOf = (key) => BASE_V2_TEMPLATE.fields.find((f) => f.key === key).label;
+
+// ---------------------------------------------------------------------------
+// claim 1 — the goal, AS READ BACK, carries all five answers under their own
+// questions. Not "the INSERT was given them": the read is the claim.
+// ---------------------------------------------------------------------------
+
+await test('the goal a reader opens carries all five answers, each under the question that asked for it', async () => {
+  seedBoardPass();
+  await writeFullIdea();
+  const r = await drive(postRatifyGoal, { params: { id: IDEA_ID }, body: OK_BODY });
+  assert.equal(r.status, 201, JSON.stringify(r.payload));
+
+  // The read a builder opening the goal actually performs.
+  const goal = await lifecycleDb.getGoal(r.payload.goal.id);
+  assert.ok(goal, 'the goal is readable after the ratification committed');
+
+  for (const key of fieldOrder(BASE_V2_TEMPLATE)) {
+    assert.ok(
+      goal.description.includes(ANSWERS[key]),
+      `the goal a reader opens carries the "${key}" answer in full`,
+    );
+    assert.ok(
+      goal.description.includes(`### ${labelOf(key)}`),
+      `the "${key}" answer sits under its own question, not as loose prose`,
+    );
+  }
+  assert.equal(goal.title, db.ideas.get(IDEA_ID).title, 'and it is the idea’s own title');
+});
+
+// ---------------------------------------------------------------------------
+// claim 2 — the answers come back in the ORDER THEY WERE ASKED, not the order
+// the jsonb column happens to hold. The store returns them reversed; if the
+// composer walked Object.keys(field_values) this reads backwards.
+// ---------------------------------------------------------------------------
+
+await test('the five answers read in the order they were asked, not the order the column stored them', async () => {
+  seedBoardPass();
+  await writeFullIdea();
+  const stored = Object.keys(db.grades.get(IDEA_ID).field_values);
+  const declared = fieldOrder(BASE_V2_TEMPLATE);
+  assert.notDeepEqual(stored, declared, 'precondition: the store hands the answers back out of order');
+
+  const r = await drive(postRatifyGoal, { params: { id: IDEA_ID }, body: OK_BODY });
+  const goal = await lifecycleDb.getGoal(r.payload.goal.id);
+
+  const seen = declared
+    .map((k) => ({ key: k, at: goal.description.indexOf(`### ${labelOf(k)}`) }))
+    .sort((a, b) => a.at - b.at)
+    .map((x) => x.key);
+  assert.deepEqual(seen, declared, 'the declared order is what a reader sees');
+});
+
+// ---------------------------------------------------------------------------
+// claim 3 — the two mappings the criterion names, read back from the rows they
+// land in: done-when from "success", scope from "scope it as best as you can".
+// ---------------------------------------------------------------------------
+
+await test('done-when IS the success answer, read off the criterion row; the scope answer is in the goal', async () => {
+  seedBoardPass();
+  await writeFullIdea();
+  const r = await drive(postRatifyGoal, { params: { id: IDEA_ID }, body: OK_BODY });
+
+  const criteria = await lifecycleDb.listCriteriaForGoal(r.payload.goal.id);
+  assert.equal(criteria.length, 1, 'the goal is born with exactly one done-when criterion');
+  assert.equal(criteria[0].criterion_md, ANSWERS.success,
+    'the criterion a version-close reads IS the author’s success answer, verbatim');
+  assert.equal(criteria[0].satisfied, false, 'and it is open — a goal is not born achieved');
+  assert.equal(r.payload.done_when_from, 'success', 'the route says which answer became the gate');
+
+  const goal = await lifecycleDb.getGoal(r.payload.goal.id);
+  assert.ok(goal.description.includes(ANSWERS.scope),
+    'the scope answer is in the goal a builder reads');
+  // The success answer lands in BOTH places, deliberately (ratify.js says so):
+  // dropping it from the description to avoid duplication would take the
+  // clearest statement of purpose out of the one place someone looks.
+  assert.ok(goal.description.includes(ANSWERS.success),
+    'and the success answer is in the description too, not only in the criterion');
+});
+
+// ---------------------------------------------------------------------------
+// claim 4 — the goal names where it came from, by link, so a reader can go and
+// read the whole thought without asking anyone.
+// ---------------------------------------------------------------------------
+
+await test('the goal names the idea it came from, by link, and the machine record agrees', async () => {
+  seedBoardPass();
+  await writeFullIdea();
+  const r = await drive(postRatifyGoal, { params: { id: IDEA_ID }, body: OK_BODY });
+  const goal = await lifecycleDb.getGoal(r.payload.goal.id);
+
+  assert.ok(goal.description.includes(`/idea/${IDEA_ID}`),
+    'the provenance is a LINK a reader can follow, not a bare number');
+  assert.ok(goal.description.indexOf(`/idea/${IDEA_ID}`) < goal.description.indexOf('### '),
+    'and it is the first thing on the goal, above the answers');
+
+  // The durable machine record — the prose line is for humans, this is for code.
+  const audit = db.ratifications.find((x) => x.goal_id === String(goal.id));
+  assert.ok(audit, 'the ratification is on the record');
+  assert.equal(audit.idea_id, IDEA_ID);
+  assert.equal(audit.proposed_by, AUTHOR, 'the author keeps their claim on the thought');
+  assert.equal(audit.ratified_by, RATIFIER);
+  assert.equal(audit.board_item_id, '900', 'under the decision that carried it');
+  assert.equal(db.ideas.get(IDEA_ID).status, 'promoted', 'and the idea is no longer open');
+});
+
+// ---------------------------------------------------------------------------
+// claim 5 — the board DECIDES. Without a passing sitting nothing is written
+// anywhere, and the real board read is what says so.
+// ---------------------------------------------------------------------------
+
+await test('with no sitting that passed, nothing is created — the board decides, the ideator recommends', async () => {
+  await writeFullIdea(); // deliberately NO board pass seeded
+  const r = await drive(postRatifyGoal, { params: { id: IDEA_ID }, body: OK_BODY });
+  assert.equal(r.status, 409, JSON.stringify(r.payload));
+  assert.equal(r.payload.error, 'BOARD_HAS_NOT_PASSED');
+
+  assert.equal(db.goals.size, 0, 'no goal');
+  assert.equal(db.criteria.length, 0, 'no criterion');
+  assert.equal(db.ratifications.length, 0, 'no audit row');
+  assert.equal(db.ideas.get(IDEA_ID).status, 'open', 'and the idea is still open for the board');
+  assert.ok(queries.some((q) => /^ROLLBACK$/i.test(q.sql)), 'the transaction rolled back');
+});
+
+await test('an item the board OPENED but never closed passed is not a mandate either', async () => {
+  db.boardItems.push({
+    id: '901', subject_type: 'full_idea', subject_id: IDEA_ID, outcome: 'open',
+    opened_at: 'A', closed_at: null, constitution: {},
+  });
+  await writeFullIdea();
+  const r = await drive(postRatifyGoal, { params: { id: IDEA_ID }, body: OK_BODY });
+  assert.equal(r.payload.error, 'BOARD_HAS_NOT_PASSED', JSON.stringify(r.payload));
+  assert.equal(db.goals.size, 0, 'and still no goal');
+});
+
+// ---------------------------------------------------------------------------
+// claim 6 — the author's recommendation is RECORDED and never BRANCHED ON. The
+// board may decide the thought was bigger than its author thought.
+// ---------------------------------------------------------------------------
+
+await test('an author who recommended a criterion still gets a goal when the board chose one, with their recommendation kept', async () => {
+  seedBoardPass();
+  await writeFullIdea({ recommendation: 'criterion' });
+  const r = await drive(postRatifyGoal, { params: { id: IDEA_ID }, body: OK_BODY });
+  assert.equal(r.status, 201, JSON.stringify(r.payload));
+
+  const goal = await lifecycleDb.getGoal(r.payload.goal.id);
+  assert.ok(goal, 'the board’s decision stands over the recommendation');
+  assert.ok(goal.description.includes(ANSWERS.success), 'and the goal still carries the answers');
+
+  const audit = db.ratifications.find((x) => x.goal_id === String(goal.id));
+  assert.equal(audit.recommendation_at_filing, 'criterion',
+    'what the author asked for is on the record beside what the board did');
+  assert.equal(r.payload.recommendation_at_filing, 'criterion');
+});
+
+// ---------------------------------------------------------------------------
+// claim 7 — the same thought cannot become two goals. Ratifying twice refuses
+// and leaves the first goal exactly as it was.
+// ---------------------------------------------------------------------------
+
+await test('one thought, one goal — a second ratification refuses and changes nothing', async () => {
+  seedBoardPass();
+  await writeFullIdea();
+  const first = await drive(postRatifyGoal, { params: { id: IDEA_ID }, body: OK_BODY });
+  assert.equal(first.status, 201);
+  const before = await lifecycleDb.getGoal(first.payload.goal.id);
+
+  const second = await drive(postRatifyGoal, { params: { id: IDEA_ID }, body: OK_BODY });
+  assert.ok(second.status >= 400, `the second is refused, got ${second.status}`);
+  assert.equal(db.goals.size, 1, 'still exactly one goal');
+  assert.equal(db.criteria.length, 1, 'and one criterion');
+  assert.equal(db.ratifications.length, 1, 'and one ratification on the record');
+
+  const after = await lifecycleDb.getGoal(first.payload.goal.id);
+  assert.deepEqual(after, before, 'the first goal is untouched');
+});
+
+// ---------------------------------------------------------------------------
+// claim 8 — the thought is the author's; the AUTHORITY is the ratifier's. Filing
+// an idea is open to every rank, so owning the goal your idea became would turn
+// a liked thought into a grant of authority nobody reviewed.
+// ---------------------------------------------------------------------------
+
+await test('the goal is owned by the ratifier, not the author — while the author keeps the thought', async () => {
+  seedBoardPass();
+  await writeFullIdea();
+  const r = await drive(postRatifyGoal, { params: { id: IDEA_ID }, body: OK_BODY });
+  const goal = await lifecycleDb.getGoal(r.payload.goal.id);
+
+  assert.equal(String(goal.created_by), RATIFIER, 'the ratifier owns the goal');
+  const leads = db.goalMembers.filter((m) => m.goal_id === String(goal.id) && m.membership_kind === 'lead');
+  assert.deepEqual(leads.map((m) => m.builder_id), [RATIFIER],
+    'and the lead membership — the authority to author tasks inside the wall — is theirs alone');
+  assert.ok(!leads.some((m) => m.builder_id === AUTHOR),
+    'filing an idea the board liked did not make its author a goal lead');
+
+  // What the author DOES keep.
+  assert.equal(r.payload.proposer_id, AUTHOR);
+  assert.ok(goal.description.includes(`/idea/${IDEA_ID}`), 'the goal still points at their thought');
+});
+
+// ---------------------------------------------------------------------------
+// claim 9 — the gates POST /goals applies are applied here too. `idea.ratify`'s
+// floor is metic, so a path that skipped them would be a Metic-reachable way
+// around all of them, with the gates still in the code and no longer in the way.
+// ---------------------------------------------------------------------------
+
+await test('ratification is not a way around the goal-creation gates a Metic cannot otherwise pass', async () => {
+  seedBoardPass();
+  await writeFullIdea();
+  // A protected scope is Archon-only wherever a goal is created.
+  const protectedScope = api.moduleScopeMap.moduleKeys()
+    .find((k) => api.moduleScopeMap.scopeIncludesProtected([k]));
+  assert.ok(protectedScope, 'precondition: this instance declares at least one protected module');
+
+  const r = await drive(postRatifyGoal, {
+    params: { id: IDEA_ID },
+    body: { target_version: 'TEST-V1', scope_modules: [protectedScope] },
+    rank: 'metic',
+  });
+  assert.equal(r.status, 403, JSON.stringify(r.payload));
+  assert.equal(db.goals.size, 0, 'and no goal was created on the way to the refusal');
+  assert.equal(db.ideas.get(IDEA_ID).status, 'open', 'the idea is untouched');
+});
+
+await test('a version that will not take a new goal refuses the ratification too', async () => {
+  seedBoardPass();
+  await writeFullIdea();
+  db.versions.set('TEST-V1', { id: 'TEST-V1', name: 'Test', status: 'building', scope_doc_path: null, started_at: null, shipped_at: null, done_when: null });
+
+  const r = await drive(postRatifyGoal, { params: { id: IDEA_ID }, body: OK_BODY, rank: 'metic' });
+  assert.ok(r.status >= 400, `a building version's goal set is closed to a Metic, got ${r.status}`);
+  assert.equal(db.goals.size, 0, 'no goal');
+  assert.equal(db.criteria.length, 0, 'no criterion');
+});
+
+// ---------------------------------------------------------------------------
+// claim 10 — a goal is never born without its gate. The pair is one act, so a
+// composer that produced a description but no done-when writes neither row.
+// ---------------------------------------------------------------------------
+
+await test('a Full Idea missing the success answer produces NO goal, not a goal with no gate', async () => {
+  seedBoardPass();
+  await writeFullIdea();
+  // Reach past capture: a stored row whose success answer has gone blank is the
+  // only way this reaches the composer, and the composer must still refuse —
+  // ADR 0263's close gate reads done-when criteria, so a goal born with none
+  // holds its version open forever.
+  const g = db.grades.get(IDEA_ID);
+  g.field_values = jsonbOrder({ ...ANSWERS, success: '   ' });
+
+  const r = await drive(postRatifyGoal, { params: { id: IDEA_ID }, body: OK_BODY });
+  assert.equal(r.status, 400, JSON.stringify(r.payload));
+  assert.equal(r.payload.error, 'CANNOT_COMPOSE_GOAL');
+  assert.equal(r.payload.field, 'success', 'and it names the answer that was missing');
+  assert.equal(db.goals.size, 0, 'no goal was created');
+  assert.equal(db.criteria.length, 0, 'and no criterion');
+});
+
+// ---------------------------------------------------------------------------
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);