@bongos/core 1.19.933 → 1.19.935

package/tests/idea_completeness.mjs

@@ -32,6 +32,19 @@ const COMPLETE = Object.fromEntries(
   BASE_TEMPLATE.fields.map((f) => [f.key, `A real, substantive answer for ${f.key} that clears the declared floor easily.`]),
 );
 
+// The scorer is TEMPLATE-AGNOSTIC — that is the property BV1.R142 exists to have
+// — so this suite names fields BY POSITION rather than by the keys one vintage
+// happens to use. Before task 1004085 (BV2.R06) it spelled `purpose`,
+// `big_picture` and `why_matters`, and versioning the questions reddened five
+// cases that were making no claim about those names at all. A test that hardcodes
+// the current template's keys is quietly asserting the template never changes.
+const [FIELD_1, FIELD_2, , FIELD_4] = BASE_TEMPLATE.fields.map((f) => f.key);
+
+// Since task 1004091 (BV2.R12) the floors DIFFER per field, so a fixture may no
+// longer assume "40" — or, worse, assume that equal text in two sections is equal
+// credit. Every expectation below is derived from the declaration.
+const floorOf = (key) => BASE_TEMPLATE.fields.find((f) => f.key === key).substanceMin;
+
 test('a complete idea scores 100, an empty one 0', () => {
   assert.equal(C.completenessScore(COMPLETE), 100);
   assert.equal(C.completenessScore({}), 0);
@@ -43,21 +56,33 @@ test('same input, same score — byte-for-byte determinism', () => {
   assert.deepEqual(C.scoreFieldValues(COMPLETE), C.scoreFieldValues(COMPLETE));
 });
 
-test('a thin answer earns its proportion, not the full share', () => {
-  const oneThin = { ...COMPLETE, purpose: 'ten chars.' }; // 10 of the 40-char floor
+test('a thin answer earns its proportion of ITS OWN floor, not a flat share', () => {
+  const TEN = 'ten chars.'; // exactly 10 characters of substance
+  const oneThin = { ...COMPLETE, [FIELD_1]: TEN };
   const s = C.completenessScore(oneThin);
-  assert.ok(s > 80 && s < 100, `four full + one quarter-credit field ≈ 85, got ${s}`);
-  const breakdown = C.scoreFieldValues(oneThin).fields.find((f) => f.key === 'purpose');
+  assert.ok(s > 80 && s < 100, `four full fields + one part-credit field, got ${s}`);
+  const breakdown = C.scoreFieldValues(oneThin).fields.find((f) => f.key === FIELD_1);
   assert.equal(breakdown.substance, 10);
-  assert.equal(breakdown.ratio, 0.25);
+  assert.equal(breakdown.floor, floorOf(FIELD_1), 'the breakdown publishes the field\'s own floor');
+  assert.equal(breakdown.ratio, 10 / floorOf(FIELD_1));
+
+  // BV2.R12's actual deliverable: the same ten characters are worth DIFFERENT
+  // credit in different sections, because the questions are not interchangeable.
+  // A test that only ever looked at one field would pass just as happily against
+  // the flat-40 placeholder this task replaced.
+  const other = C.scoreFieldValues({ ...COMPLETE, [FIELD_2]: TEN })
+    .fields.find((f) => f.key === FIELD_2);
+  assert.equal(other.ratio, 10 / floorOf(FIELD_2));
+  assert.notEqual(other.ratio, breakdown.ratio,
+    'identical text scores lower where the question asks for more');
 });
 
 test('padding earns exactly nothing: whitespace and blank lines are not substance', () => {
-  const padded = { ...COMPLETE, purpose: '   \n\n\t   \n     \n\n        ' };
-  const b = C.scoreFieldValues(padded).fields.find((f) => f.key === 'purpose');
+  const padded = { ...COMPLETE, [FIELD_1]: '   \n\n\t   \n     \n\n        ' };
+  const b = C.scoreFieldValues(padded).fields.find((f) => f.key === FIELD_1);
   assert.equal(b.substance, 0, 'a page of blank lines is the nothing it is');
-  const spaced = { ...COMPLETE, purpose: 'a    b\n\n\nc         d e' }; // collapses to 9
-  const b2 = C.scoreFieldValues(spaced).fields.find((f) => f.key === 'purpose');
+  const spaced = { ...COMPLETE, [FIELD_1]: 'a    b\n\n\nc         d e' }; // collapses to 9
+  const b2 = C.scoreFieldValues(spaced).fields.find((f) => f.key === FIELD_1);
   assert.equal(b2.substance, 9, 'runs of whitespace collapse to one');
 });
 
@@ -68,7 +93,13 @@ test('one missing field costs exactly its equal share', () => {
 
 test('the breakdown comes back in TEMPLATE order, ready to render', () => {
   const keys = C.scoreFieldValues(COMPLETE).fields.map((f) => f.key);
-  assert.deepEqual(keys, ['purpose', 'big_picture', 'why_had', 'why_matters', 'fit']);
+  assert.deepEqual(keys, BASE_TEMPLATE.fields.map((f) => f.key));
+  // The claim is that the breakdown follows the DECLARATION, not that it matches
+  // some other list derived the same way — so it is also checked against a shuffled
+  // input, which is the only thing that distinguishes declaration order from
+  // insertion order.
+  const shuffled = Object.fromEntries(Object.entries(COMPLETE).reverse());
+  assert.deepEqual(C.scoreFieldValues(shuffled).fields.map((f) => f.key), keys);
 });
 
 test('it never throws: malformed input is a null score, not an exception', () => {
@@ -77,7 +108,7 @@ test('it never throws: malformed input is a null score, not an exception', () =>
   }
   assert.equal(C.completenessScore(COMPLETE, { templateKey: 'no-such-template' }), null);
   // a non-string FIELD does not throw either — it just earns nothing
-  assert.equal(typeof C.completenessScore({ ...COMPLETE, purpose: 42 }), 'number');
+  assert.equal(typeof C.completenessScore({ ...COMPLETE, [FIELD_1]: 42 }), 'number');
 });
 
 test('the scorer walks the declaration — a different template scores by ITS fields', () => {
@@ -97,25 +128,37 @@ test('the scorer walks the declaration — a different template scores by ITS fi
 // ── the sub-bar rejection payload (BV1.R09 of goal 1000069, criterion C2) ───
 
 test('the weakest section is the LOWEST ratio, with ties going to template order', () => {
-  const values = { ...COMPLETE, big_picture: 'thin', why_matters: 'thin' }; // two equally thin
+  // A GENUINE tie takes different amounts of text in each field now that the
+  // floors differ (BV2.R12): two-fifths of each field's OWN floor is the same
+  // ratio, where two identical strings would not be. The fixture asserts it is
+  // really a tie before asserting how the tie breaks — otherwise this case
+  // quietly stops testing tie-breaking at all.
+  const twoFifths = (key) => 'x'.repeat(Math.round(floorOf(key) * 0.4));
+  const values = { ...COMPLETE, [FIELD_2]: twoFifths(FIELD_2), [FIELD_4]: twoFifths(FIELD_4) };
+  const broken = C.scoreFieldValues(values).fields;
+  assert.equal(broken.find((f) => f.key === FIELD_2).ratio, broken.find((f) => f.key === FIELD_4).ratio,
+    'the fixture really is a tie');
   const worst = C.weakestField(values);
-  assert.equal(worst.key, 'big_picture', 'the earlier of two equal-thinnest fields, by template order');
+  assert.equal(worst.key, FIELD_2, 'the earlier of two equal-thinnest fields, by template order');
   // strictly-thinnest wins regardless of position
   assert.equal(C.weakestField({ ...COMPLETE, fit: 'x' }).key, 'fit');
 });
 
 test('the rejection payload is board-objection-shaped, names the template LABEL, and states the shortfall', () => {
   const flag = C.weakestSectionPayload({ ...COMPLETE, fit: 'too thin' });
+  const field = BASE_TEMPLATE.fields.find((f) => f.key === 'fit');
   assert.equal(flag.section_key, 'fit', 'exactly one of the five section keys — the board-vote shape');
-  assert.ok(flag.reason_md.includes('How does the Idea Fit'), 'the reason speaks the words the author saw');
+  // The LABEL, read off the template rather than retyped: the claim is that the
+  // reason speaks the words the author actually saw, and those words now depend
+  // on which vintage the author wrote under.
+  assert.ok(flag.reason_md.includes(field.label), 'the reason speaks the words the author saw');
   assert.ok(/\d+ characters? of substance against a floor of \d+/.test(flag.reason_md),
     'the shortfall is stated in the scorer\'s own honest terms');
-  const field = BASE_TEMPLATE.fields.find((f) => f.key === 'fit');
   assert.ok(flag.reason_md.includes(String(field.substanceMin)), 'the floor named is the template\'s real one');
 });
 
 test('the payload is DERIVED, deterministic, and null on unscorable input — never stored, never throws', () => {
-  const values = { ...COMPLETE, purpose: 'meh' };
+  const values = { ...COMPLETE, [FIELD_1]: 'meh' };
   assert.deepEqual(C.weakestSectionPayload(values), C.weakestSectionPayload(values),
     'same words, same flag — recomputable whenever R13 needs it, so storing it would only drift');
   for (const bad of [null, undefined, 42, [], 'text']) {

package/tests/idea_full_capture.mjs

@@ -61,8 +61,14 @@ function call(bodyIn) {
   });
 }
 
+// Since task 1004091 (BV2.R12) the floors differ per field, so one fixed
+// sentence no longer clears every one of them — this suite wants a payload that
+// scores 100, so each answer is padded to the field's OWN declared floor.
 const FULL = Object.fromEntries(
-  BASE_TEMPLATE.fields.map((f) => [f.key, `A substantive answer for ${f.key}, long enough to clear the floor.`]),
+  BASE_TEMPLATE.fields.map((f) => [
+    f.key,
+    `A substantive answer for ${f.key}, long enough to clear the floor.`.padEnd(f.substanceMin, '.'),
+  ]),
 );
 
 let passed = 0;

package/tests/idea_grades.mjs

@@ -37,6 +37,7 @@ api.pool.query = async (sql, params = []) => {
 };
 
 const inbox = require('../modules/ideas/inbox.js');
+const { DEFAULT_TEMPLATE_KEY } = inbox;
 
 let passed = 0;
 let failed = 0;
@@ -136,7 +137,7 @@ await test('a full idea round-trips its field values', async () => {
     why_it_matters: 'no re-interviewing the person who had the thought',
     how_it_fits: 'the first shipped goal of the ABI set',
   };
-  nextRows = [{ idea_id: '1', grade: 'full', template_key: 'base-v1', field_values: fields, completeness_score: null }];
+  nextRows = [{ idea_id: '1', grade: 'full', template_key: DEFAULT_TEMPLATE_KEY, field_values: fields, completeness_score: null }];
   const row = await inbox.setIdeaGrade('1', { grade: 'full', fieldValues: fields });
   const { sql, params } = queries[0];
   assert.match(sql, /INSERT INTO ideas_grades/i);
@@ -145,7 +146,11 @@ await test('a full idea round-trips its field values', async () => {
   // handing pg a bare JS object binds it as a Postgres record, not json.
   assert.match(sql, /\$4::jsonb/, 'field_values is not cast to jsonb');
   assert.equal(params[3], JSON.stringify(fields));
-  assert.equal(params[2], 'base-v1', 'the template key did not default to base-v1');
+  // The DEFAULT, read off the store rather than retyped. It moved 'base-v1' ->
+  // 'base-v2' in task 1004085 (BV2.R06) and will move again; what this asserts is
+  // that setIdeaGrade stamps the CURRENT default on a row whose caller named no
+  // template, which is the claim that stays true across every vintage.
+  assert.equal(params[2], DEFAULT_TEMPLATE_KEY, `the template key did not default to ${DEFAULT_TEMPLATE_KEY}`);
   assert.deepEqual(row.field_values, fields);
 });
 

package/tests/idea_hall_composer.mjs

@@ -25,7 +25,7 @@ import { createRequire } from 'node:module';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { assertCannotSwallow } from './helpers.mjs';
+import { assertCannotSwallow, namesFieldKey } from './helpers.mjs';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
@@ -34,7 +34,7 @@ const HALL = path.join(ROOT, 'modules/hall-ui/public');
 const api = require('../src/module-api.js');
 api.pool.query = async () => ({ rows: [] });
 
-const { BASE_TEMPLATE, fieldOrder } = require('../modules/ideas/templates.js');
+const { BASE_TEMPLATE, BUILTIN_TEMPLATES, fieldOrder } = require('../modules/ideas/templates.js');
 const { scoreFieldValues } = require('../modules/ideas/completeness.js');
 const routesFactory = require('../modules/ideas/routes/inbox.js');
 const router = routesFactory({});
@@ -81,9 +81,34 @@ async function test(name, fn) {
 // --- THE done-when: the page carries no copy of the rules ----------------
 
 await test('the PAGE names no field key — a hard-coded form is a forked template', () => {
-  for (const f of BASE_TEMPLATE.fields) {
-    assert.ok(!IDEAS_JS.includes(f.key), `ideas.js hard-codes the field key "${f.key}"`);
-    assert.ok(!IDEAS_HTML.includes(f.key), `ideas.html hard-codes the field key "${f.key}"`);
+  // EVERY vintage, not just the current one: a page that forked base-v1's five
+  // is just as forked for having been left behind by the default moving on.
+  for (const t of Object.values(BUILTIN_TEMPLATES)) {
+    for (const f of t.fields) {
+      assert.ok(!namesFieldKey(IDEAS_JS, f.key), `ideas.js hard-codes the field key "${f.key}"`);
+      assert.ok(!namesFieldKey(IDEAS_HTML, f.key), `ideas.html hard-codes the field key "${f.key}"`);
+    }
+  }
+});
+
+await test('the key test can still SEE a hard-coded field — it is not vacuous', () => {
+  // The predicate above got laxer to stop a false positive, so it is probed
+  // against sources that really do fork the template. A guard that admits
+  // everything reads exactly like a guard that finds nothing wrong.
+  const key = BASE_TEMPLATE.fields[0].key;
+  for (const forked of [
+    `const FIELDS = ['${key}', 'other'];`,
+    `<textarea name="${key}"></textarea>`,
+    `<textarea name=${key}></textarea>`,
+    `el.value = values.${key};`,
+  ]) {
+    assert.ok(namesFieldKey(forked, key), `a forked form spelled as \`${forked}\` must be caught`);
+  }
+  for (const innocent of [
+    '// the suggester is scoped per version',
+    '// The protected-scope wall. The server wrote the reason',
+  ]) {
+    assert.ok(!namesFieldKey(innocent, 'scope'), `prose must not read as a forked form: ${innocent}`);
   }
 });
 
@@ -197,6 +222,21 @@ await test('the template read returns the R141 declaration, in fieldOrder order'
   }
 });
 
+await test('the PREVIEW FIXTURE is the template the route actually returns', async () => {
+  // scripts/hall-preview/fixtures/inbox__template.json is a hand-written copy of
+  // this route's answer — the harness has no server behind it — so it is exactly
+  // the kind of file that keeps demoing a retired vintage after the questions
+  // change. It did: task 1004085 (BV2.R06) moved the default to base-v2 and the
+  // fixture still described base-v1's five, which would have had every composer
+  // render in the harness show questions the live page no longer asks. The
+  // module's own note calls this class of gap out — a page that only ever
+  // renders the wrong state cannot be looked at.
+  const fixture = JSON.parse(fs.readFileSync(
+    path.join(ROOT, 'scripts', 'hall-preview', 'fixtures', 'inbox__template.json'), 'utf8'));
+  const live = (await call(getTemplate)).payload;
+  assert.deepEqual(fixture, live, 'refresh the fixture from GET /inbox/template');
+});
+
 await test('an unknown template is a 404, not an empty form', async () => {
   const r = await call(getTemplate, { query: { template_key: 'no-such-template' } });
   assert.equal(r.status, 404);

package/tests/idea_ideate_full.mjs

@@ -33,6 +33,7 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { namesFieldKey } from './helpers.mjs';
 
 const require = createRequire(import.meta.url);
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
@@ -43,7 +44,7 @@ const SKILL = fs.readFileSync(path.join(ROOT, 'docs/packs/ideator.md'), 'utf8');
 // reflow that changed nothing. Structural assertions (code fences, list markers)
 // still use SKILL itself.
 const NORM = SKILL.replace(/\s+/g, ' ');
-const { BASE_TEMPLATE } = require('../modules/ideas/templates.js');
+const { BASE_TEMPLATE, BUILTIN_TEMPLATES } = require('../modules/ideas/templates.js');
 
 let passed = 0;
 let failed = 0;
@@ -145,9 +146,17 @@ test('the builder blesses it; the skill files it', () => {
 test('the skill names NO field key and NO field label', () => {
   // Same rule the hall composer obeys (R152): the questions are declared once, in
   // the R141 template, and a copy here would silently ignore a per-project one.
-  for (const f of BASE_TEMPLATE.fields) {
-    assert.ok(!SKILL.includes(f.key), `restates the field key "${f.key}"`);
-    assert.ok(!SKILL.includes(f.label), `restates the label "${f.label}"`);
+  // Every vintage, not just the current one — a skill that restates base-v1's
+  // five is just as forked for having been left behind by the default moving on.
+  // `namesFieldKey` rather than `includes`: base-v2's `scope` is an ordinary
+  // English word this skill uses in prose, and a substring match calls that a
+  // restatement (see the helper's own note). The LABEL is a whole sentence, so
+  // there `includes` is still the right test.
+  for (const t of Object.values(BUILTIN_TEMPLATES)) {
+    for (const f of t.fields) {
+      assert.ok(!namesFieldKey(SKILL, f.key), `restates the field key "${f.key}"`);
+      assert.ok(!SKILL.includes(f.label), `restates the label "${f.label}"`);
+    }
   }
 });
 

package/tests/idea_resubmit.mjs

@@ -48,7 +48,7 @@ api.pool.query = async (sql, params = []) => {
   return { rows: [] };
 };
 
-const { BASE_TEMPLATE } = require('../modules/ideas/templates.js');
+const { BASE_TEMPLATE, BASE_V1_TEMPLATE } = require('../modules/ideas/templates.js');
 const routesFactory = require('../modules/ideas/routes/inbox.js');
 const router = routesFactory({});
 const layer = router.stack.find((l) => l.route && l.route.path === '/inbox/:id/resubmit' && l.route.methods.post);
@@ -75,9 +75,22 @@ function call(bodyIn, { builderId = '9', id = '77' } = {}) {
 const FULL = Object.fromEntries(
   BASE_TEMPLATE.fields.map((f) => [f.key, `A substantive answer for ${f.key}, long enough to clear the floor.`]),
 );
+// A stored idea written against whatever vintage is current — `FULL` above is
+// derived from the same declaration, so the pair stays consistent as the default
+// moves. The PREVIOUS vintage gets its own case at the bottom of this file
+// (task 1004085 / BV2.R06), because resubmitting an old idea is precisely the
+// path that breaks if this route ever reaches for the default instead of the
+// row's own `template_key`.
+// Two fields named BY POSITION. Nothing below is a claim about which words the
+// current template uses — the cases are about a flagged section being reworked
+// or not — so naming them positionally keeps the suite from reddening every time
+// the questions change (task 1004085 / BV2.R06 reddened four cases that spelled
+// `purpose` and `big_picture` while asserting nothing about either).
+const [FIELD_1, FIELD_2] = BASE_TEMPLATE.fields.map((f) => f.key);
+
 const fullIdea = (over = {}) => ({
   id: '77', title: 'T', status: 'open', captured_by: '9',
-  grade: 'full', template_key: 'base-v1', field_values: { ...FULL, fit: 'thin' }, completeness_score: 55,
+  grade: 'full', template_key: BASE_TEMPLATE.key, field_values: { ...FULL, fit: 'thin' }, completeness_score: 55,
   ...over,
 });
 
@@ -106,11 +119,11 @@ await test('a quick idea cannot resubmit — the Full Idea loop only', async ()
 
 await test('a board objection outranks the mechanical flag, and an ANSWERED section reads changed:true', async () => {
   storedIdea = fullIdea();
-  rejectionAnswer = { source: 'board', item_id: '30', section_key: 'purpose', reason_md: 'purpose is vague', closed_at: 'T' };
-  const revised = { ...FULL, purpose: 'A completely reworked purpose that answers the objection head-on.' };
+  rejectionAnswer = { source: 'board', item_id: '30', section_key: FIELD_1, reason_md: 'that section is vague', closed_at: 'T' };
+  const revised = { ...FULL, [FIELD_1]: 'A completely reworked answer that meets the objection head-on.' };
   const r = await call({ field_values: revised });
   assert.equal(r.status, 200);
-  assert.equal(r.payload.flagged_section, 'purpose', 'the human objection wins over the weakest-section flag');
+  assert.equal(r.payload.flagged_section, FIELD_1, 'the human objection wins over the weakest-section flag');
   assert.equal(r.payload.flagged_section_changed, true);
   assert.equal(r.payload.rejection_source, 'board');
   // The pass rule rides along with the deadline (task 1003654): a clockless
@@ -122,8 +135,8 @@ await test('a board objection outranks the mechanical flag, and an ANSWERED sect
 
 await test('reworking everything EXCEPT the flagged section reads changed:false', async () => {
   storedIdea = fullIdea();
-  rejectionAnswer = { source: 'board', item_id: '30', section_key: 'purpose', reason_md: 'r', closed_at: 'T' };
-  const revised = Object.fromEntries(Object.entries(FULL).map(([k, v]) => [k, k === 'purpose' ? v : `${v} — now even better.`]));
+  rejectionAnswer = { source: 'board', item_id: '30', section_key: FIELD_1, reason_md: 'r', closed_at: 'T' };
+  const revised = Object.fromEntries(Object.entries(FULL).map(([k, v]) => [k, k === FIELD_1 ? v : `${v} — now even better.`]));
   storedIdea = fullIdea({ field_values: FULL });
   const r = await call({ field_values: revised });
   assert.equal(r.payload.flagged_section_changed, false, 'told plainly: the objected-to section did not move');
@@ -142,21 +155,47 @@ await test('with no board return, the sub-bar weakest-section flag is the fallba
 await test('a still-sub-bar resubmission gets FRESH feedback and no window', async () => {
   storedIdea = fullIdea();
   windowAnswer = { opened: false, reason: 'below_bar' };
-  const stillThin = { ...FULL, big_picture: 'x' }; // new weakest is big_picture
+  const stillThin = { ...FULL, [FIELD_2]: 'x' }; // the new weakest section
   const r = await call({ field_values: stillThin });
   assert.equal(r.status, 200);
   assert.equal(r.payload.board_window, undefined);
-  assert.equal(r.payload.idea.rejection.section_key, 'big_picture', 'the NEW weakest section, not the old flag');
+  assert.equal(r.payload.idea.rejection.section_key, FIELD_2, 'the NEW weakest section, not the old flag');
 });
 
 await test('an invalid field set is a 400 naming the field, before any write', async () => {
   storedIdea = fullIdea();
-  const r = await call({ field_values: { ...FULL, purpose: 42 } });
+  const r = await call({ field_values: { ...FULL, [FIELD_1]: 42 } });
   assert.equal(r.status, 400);
   assert.equal(r.payload.error, 'invalid_field_values');
   assert.ok(!queries.some((q) => /INSERT INTO ideas_grades/i.test(q.sql)));
 });
 
+// ── an idea filed under an EARLIER vintage still resubmits (task 1004085) ────
+
+await test('a base-v1 idea resubmits against base-v1, not against the current default', async () => {
+  // The whole reason the questions are versioned rather than edited. This route
+  // validates the submitted answers against the template the ROW names; if it
+  // ever read the default instead, every Full Idea filed before BV2.R06 would
+  // 400 on `invalid_field_values` the moment its author tried to answer the
+  // board's objection — the one action a returned idea exists to allow.
+  const v1Values = Object.fromEntries(
+    BASE_V1_TEMPLATE.fields.map((f) => [f.key, `A substantive v1 answer for ${f.key}, well past the floor.`]),
+  );
+  storedIdea = fullIdea({ template_key: 'base-v1', field_values: { ...v1Values, fit: 'thin' } });
+  rejectionAnswer = null;
+  const r = await call({ field_values: { ...v1Values, fit: 'A fit section with real substance now, past the floor.' } });
+  assert.equal(r.status, 200, 'a v1 payload against a v1 row is valid');
+  assert.equal(r.payload.flagged_section_changed, true);
+
+  // …and the CURRENT vintage's answers are not valid on that row, which is what
+  // makes the assertion above about the row's own template rather than about the
+  // validator having gone quiet.
+  storedIdea = fullIdea({ template_key: 'base-v1', field_values: v1Values });
+  const wrong = await call({ field_values: FULL });
+  assert.equal(wrong.status, 400, 'base-v2 answers are not a base-v1 Full Idea');
+  assert.equal(wrong.payload.error, 'invalid_field_values');
+});
+
 await test('a missing idea is 404', async () => {
   storedIdea = null;
   const r = await call({ field_values: FULL });

package/tests/idea_spark_hall.mjs

@@ -285,7 +285,9 @@ await test('the develop draft is stored under its OWN key', async () => {
   await settle(); await settle(); await settle();
   r.fill();
   // The draft write is debounced behind an input event; call the saver's trigger.
-  r.el('fi-f-purpose')._handlers.input();
+  // The first field of whatever vintage is current — the claim is about the
+  // DRAFT KEY, not about which question happens to sit at the top of the form.
+  r.el(`fi-f-${TEMPLATE.fields[0].key}`)._handlers.input();
   await new Promise((res) => setTimeout(res, 600));
   const keys = Object.keys(store);
   assert.ok(keys.length >= 1, `something was stored (${JSON.stringify(keys)})`);

package/tests/idea_templates.mjs

@@ -1,12 +1,20 @@
 // tests/idea_templates.mjs
 //
 // task 1002917 (BV1.R141, goal 1000062) — the Full Idea base template.
+// task 1004085 (BV2.R06, goal 1000095) — the questions, VERSIONED: `base-v2`
+// beside `base-v1`, and the §vintages block at the bottom.
 //
 // The claim these tests protect: THE TEMPLATE IS DATA. Validation follows the
 // declaration, order comes from the declaration, and swapping the registry
 // changes what is accepted with no code change — that is the task's done-when,
 // and the "swap" test at the bottom is the proof (the R156 per-project seam).
 //
+// THE SECOND CLAIM, ADDED BY BV2.R06: an idea is scored on the questions it was
+// actually asked. That is a statement about ALREADY-STORED rows, so the tests
+// that matter most here are the ones that feed a v1 payload and watch it keep
+// validating after the default moved past it. A suite written only against
+// "the current template" would pass with base-v1 deleted from the registry.
+//
 // Pure module — no DB, no doorway, no harness. inbox.js is required transitively
 // (templates.js reads DEFAULT_TEMPLATE_KEY / FIELD_VALUES_MAX from it), and it
 // destructures `pool` off the doorway at require time without querying, so a
@@ -28,35 +36,87 @@ function test(name, fn) {
   catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
 }
 
-// A complete, well-formed base payload — reused across tests.
-const FULL = {
-  purpose: 'A concrete purpose, written out.',
-  big_picture: 'What the world looks like once this exists.',
-  why_had: 'The observation that sparked it.',
-  why_matters: 'Why anyone should spend hours on it.',
-  fit: 'Where it sits in the project arc.',
-};
+// A complete, well-formed payload for a template — DERIVED from the declaration
+// rather than typed out, so a suite about "the template is data" is not itself a
+// second hand-maintained copy of the fields.
+function payloadFor(template) {
+  return Object.fromEntries(template.fields.map((f, i) =>
+    [f.key, `A real answer for ${f.key}, number ${i + 1}, long enough to read like one.`]));
+}
+
+// The CURRENT vintage — what an unqualified validate() call is about.
+const FULL = payloadFor(T.BASE_V2_TEMPLATE);
+// The PREVIOUS vintage — what hundreds of stored rows still carry.
+const FULL_V1 = payloadFor(T.BASE_V1_TEMPLATE);
 
 // ── the declaration ─────────────────────────────────────────────────────────
 
 test('base-v1 declares exactly the five owner fields, in brief order', () => {
-  assert.equal(T.BASE_TEMPLATE.key, DEFAULT_TEMPLATE_KEY, 'the base key IS the store default');
-  assert.deepEqual(T.fieldOrder(T.BASE_TEMPLATE),
+  assert.deepEqual(T.fieldOrder(T.BASE_V1_TEMPLATE),
     ['purpose', 'big_picture', 'why_had', 'why_matters', 'fit']);
-  for (const f of T.BASE_TEMPLATE.fields) {
+  for (const f of T.BASE_V1_TEMPLATE.fields) {
     assert.ok(f.label && f.required === true, `${f.key} carries a label and is required`);
     assert.ok(Number.isInteger(f.substanceMin) && f.substanceMin > 0,
       `${f.key} declares the substance floor the R142 scorer reads`);
   }
 });
 
+test('base-v2 declares the owner\'s new five, in order, and IS the store default', () => {
+  assert.equal(T.BASE_TEMPLATE, T.BASE_V2_TEMPLATE, 'BASE_TEMPLATE aliases the current vintage');
+  assert.equal(T.BASE_TEMPLATE.key, DEFAULT_TEMPLATE_KEY, 'the current key IS the store default');
+  assert.equal(DEFAULT_TEMPLATE_KEY, 'base-v2');
+  assert.deepEqual(T.fieldOrder(T.BASE_V2_TEMPLATE),
+    ['why_had', 'scope', 'build_context', 'fit', 'success']);
+  for (const f of T.BASE_V2_TEMPLATE.fields) {
+    assert.ok(f.label && f.required === true, `${f.key} carries a label and is required`);
+    assert.ok(Number.isInteger(f.substanceMin) && f.substanceMin > 0,
+      `${f.key} declares the substance floor the R142 scorer reads`);
+  }
+});
+
+// ── the substance floors (task 1004091, BV2.R12, spec R21) ──────────────────
+//
+// The floors are a PRICE, not a style note: `completeness_score` is the mean of
+// per-field ratios, and that number gates the ideator credit (economy's
+// IDEA_FULL_PASS_BAR) and whether a Full Idea reaches the board at all. So the
+// two claims worth pinning are the two that would be silently reverted: that the
+// floors actually differ per question, and that redistributing them did not
+// change what filing a Full Idea costs in total.
+
+test('BV2.R12: v2\'s floors differ per question, and total exactly what v1 cost', () => {
+  const total = (t) => t.fields.reduce((sum, f) => sum + f.substanceMin, 0);
+  assert.equal(total(T.BASE_V2_TEMPLATE), total(T.BASE_V1_TEMPLATE),
+    're-pricing what a thought costs to file is the owner\'s call, not this template\'s — '
+    + 'R12 distributes v1\'s total across questions that are not interchangeable, it does not move it');
+
+  const floors = T.BASE_V2_TEMPLATE.fields.map((f) => f.substanceMin);
+  assert.ok(new Set(floors).size > 1,
+    'flat floors are the placeholder BV2.R12 replaced — the questions are not interchangeable');
+
+  // Named by key, because the REASONING is what a future edit would undo: the
+  // field that invites the longest answer carries the highest floor, and the
+  // anti-ghost-writing field — the one nobody but the filer can answer — carries
+  // the lowest, so no floor ever pushes an agent to pad it (the Ideator pack).
+  const floorOf = (key) => T.BASE_V2_TEMPLATE.fields.find((f) => f.key === key).substanceMin;
+  assert.equal(Math.max(...floors), floorOf('scope'), '"scope it as best as you can" asks for the most');
+  assert.equal(Math.min(...floors), floorOf('why_had'), '"what made you have the idea" asks for the least');
+
+  // ADR 0186's interim karma-eligibility guard, restated here so a later
+  // reshuffle cannot drop the template below its own economics.
+  assert.ok(T.BASE_V2_TEMPLATE.fields.filter((f) => f.required).length >= 3
+    && total(T.BASE_V2_TEMPLATE) >= 120,
+  'ADR 0186 T5: ≥3 required fields and ≥120 total substanceMin to stay karma-eligible');
+});
+
 test('the declaration is frozen — a consumer cannot fork it in place', () => {
   assert.throws(() => { T.BASE_TEMPLATE.fields.push({ key: 'rogue' }); });
+  assert.throws(() => { T.BASE_V1_TEMPLATE.fields.push({ key: 'rogue' }); });
   assert.throws(() => { 'use strict'; T.BUILTIN_TEMPLATES['base-v1'] = null; });
 });
 
-test('templateFor: base key resolves, unknown/blank/non-string do not', () => {
-  assert.equal(T.templateFor('base-v1'), T.BASE_TEMPLATE);
+test('templateFor: both vintages resolve, unknown/blank/non-string do not', () => {
+  assert.equal(T.templateFor('base-v1'), T.BASE_V1_TEMPLATE);
+  assert.equal(T.templateFor('base-v2'), T.BASE_V2_TEMPLATE);
   assert.equal(T.templateFor('no-such-template'), null);
   assert.equal(T.templateFor(''), null);
   assert.equal(T.templateFor(null), null);
@@ -97,8 +157,8 @@ test('a missing or blank required field is named, per field', () => {
   const { fit, ...four } = FULL;
   let r = T.validateFieldValues(four);
   assert.deepEqual(r.errors, [{ field: 'fit', reason: 'missing_required' }]);
-  r = T.validateFieldValues({ ...FULL, purpose: '   ' });
-  assert.deepEqual(r.errors, [{ field: 'purpose', reason: 'missing_required' }]);
+  r = T.validateFieldValues({ ...FULL, scope: '   ' });
+  assert.deepEqual(r.errors, [{ field: 'scope', reason: 'missing_required' }]);
 });
 
 test('a non-string value is refused once, not double-reported', () => {
@@ -115,7 +175,7 @@ test('a non-object payload and an unknown template are structured refusals', ()
 });
 
 test('a payload over the store byte cap is a named refusal, not a DB 500', () => {
-  const r = T.validateFieldValues({ ...FULL, purpose: 'x'.repeat(40000) });
+  const r = T.validateFieldValues({ ...FULL, scope: 'x'.repeat(40000) });
   assert.deepEqual(r.errors, [{ field: null, reason: 'too_large' }]);
 });
 
@@ -125,6 +185,59 @@ test('substance is scored, not gated: a thin answer still validates', () => {
     'scoring never blocks capture — substanceMin is the scorer\'s, not the validator\'s');
 });
 
+// ── vintages: an idea is judged on the questions it was asked (BV2.R06) ─────
+
+test('an already-filed v1 payload still validates — against base-v1', () => {
+  // The whole promise of versioning rather than editing. If this ever fails,
+  // every Full Idea filed before BV2.R06 has lost its questions.
+  const r = T.validateFieldValues(FULL_V1, { templateKey: 'base-v1' });
+  assert.equal(r.ok, true, 'a stored v1 payload must keep validating forever');
+  assert.deepEqual(r.errors, []);
+  assert.equal(r.template, T.BASE_V1_TEMPLATE);
+});
+
+test('the two vintages are NOT interchangeable — each refuses the other\'s fields', () => {
+  // Read together with the test above, this is what makes the first one mean
+  // something: v1 keeps validating because its OWN declaration is still there,
+  // not because the validator has become lax about field names.
+  const asV2 = T.validateFieldValues(FULL_V1);
+  assert.equal(asV2.ok, false, 'a v1 payload is not a v2 Full Idea');
+  const unknownUnderV2 = asV2.errors.filter((e) => e.reason === 'unknown_field').map((e) => e.field).sort();
+  assert.deepEqual(unknownUnderV2, ['big_picture', 'purpose', 'why_matters'],
+    'the three v1-only fields are refused by name under v2');
+
+  const asV1 = T.validateFieldValues(FULL, { templateKey: 'base-v1' });
+  assert.equal(asV1.ok, false, 'a v2 payload is not a v1 Full Idea');
+  const unknownUnderV1 = asV1.errors.filter((e) => e.reason === 'unknown_field').map((e) => e.field).sort();
+  assert.deepEqual(unknownUnderV1, ['build_context', 'scope', 'success'],
+    'the three v2-only fields are refused by name under v1');
+});
+
+test('the two shared keys are shared, and their QUESTIONS are not', () => {
+  // `why_had` and `fit` are reused deliberately — that reuse is what makes this
+  // a registry entry rather than a data migration. The trap it creates is a
+  // renderer that flattens the vintages into one key->label map: it would then
+  // show one author the question a different author was asked. Different labels
+  // on the same key is the fact that forbids the flattening, so it is pinned.
+  const v1 = Object.fromEntries(T.BASE_V1_TEMPLATE.fields.map((f) => [f.key, f.label]));
+  const v2 = Object.fromEntries(T.BASE_V2_TEMPLATE.fields.map((f) => [f.key, f.label]));
+  const shared = Object.keys(v2).filter((k) => k in v1);
+  assert.deepEqual(shared.sort(), ['fit', 'why_had'], 'exactly two keys carry over');
+  for (const key of shared) {
+    assert.notEqual(v1[key], v2[key], `${key} asks a different question in each vintage`);
+  }
+});
+
+test('a retired vintage is never dropped from the registry', () => {
+  // The load-time pin in templates.js says the same thing; asserting it here is
+  // what makes a "tidy up the old template" edit fail in the unit gate rather
+  // than at boot on somebody's instance.
+  for (const key of ['base-v1', 'base-v2']) {
+    assert.ok(Object.hasOwn(T.BUILTIN_TEMPLATES, key), `${key} stays registered`);
+    assert.ok(T.templateFor(key), `${key} still resolves`);
+  }
+});
+
 // ── the done-when: swap the registry, behaviour follows (the R156 seam) ─────
 
 test('a different registry changes what is accepted — no code change', () => {