@bongos/core 1.19.934 → 1.19.936

package/modules/ideas/grades.js

@@ -18,6 +18,7 @@ const { pool } = api;
 const {
   IDEA_COLS_Q, GRADE_COLS_Q,
   VALID_GRADES, DEFAULT_TEMPLATE_KEY, TEMPLATE_KEY_RE, TEMPLATE_KEY_MAX, FIELD_VALUES_MAX,
+  VALID_RECOMMENDATIONS, isValidRecommendation,
 } = require('./projection');
 const { skillFrictionHiddenClause } = require('./skill-friction');
 // developSpark reads the whole idea back to build the idea.graded.full payload.
@@ -121,7 +122,7 @@ async function countSparkQueue({ viewerRank = null } = {}, deps = {}) {
 // Structured throws (not raw constraint violations) so the routes that land on
 // top of this — R143's Full Idea capture, R144's mark-as-spark — return a clean
 // 400/404 rather than a 500 with a Postgres message in it.
-function assertGradePayload({ grade, templateKey, fieldValues, completenessScore }) {
+function assertGradePayload({ grade, templateKey, fieldValues, completenessScore, recommendation = null }) {
   if (!VALID_GRADES.includes(grade)) {
     throw { code: 'BAD_GRADE', grade, valid: VALID_GRADES };
   }
@@ -141,27 +142,45 @@ function assertGradePayload({ grade, templateKey, fieldValues, completenessScore
       throw { code: 'BAD_COMPLETENESS', completeness_score: completenessScore };
     }
   }
+  // task 1004092 / BV2.R13. NULL is legal and permanent ("the author did not
+  // say"); anything outside the closed vocabulary is a structured throw here so
+  // the route returns a named 400 rather than letting
+  // ideas_grades_recommendation_chk surface as a 500.
+  if (!isValidRecommendation(recommendation)) {
+    throw { code: 'BAD_RECOMMENDATION', recommendation, valid: VALID_RECOMMENDATIONS };
+  }
 }
 
+// THE RECOMMENDATION IS INSIDE THE WHOLE-ROW CONTRACT, NOT BESIDE IT (task
+// 1004092 / BV2.R13). It defaults to null, so a caller that omits it CLEARS it
+// — deliberately the same rule as field_values, and for the same reason: it is
+// current content the author states, not a historical fact about who acted
+// (which is why developed_by/developed_at sit outside the contract instead).
+// The consequence the callers must honour: POST /inbox/:id/resubmit re-states
+// the whole Full Idea, so it passes the STORED recommendation forward unless
+// the body names a new one — otherwise answering a board objection would
+// silently withdraw the scope the board was shown.
 async function setIdeaGrade(ideaId, {
   grade,
   templateKey = DEFAULT_TEMPLATE_KEY,
   fieldValues = {},
   completenessScore = null,
+  recommendation = null,
 } = {}) {
-  assertGradePayload({ grade, templateKey, fieldValues, completenessScore });
+  assertGradePayload({ grade, templateKey, fieldValues, completenessScore, recommendation });
   try {
     const { rows } = await pool.query(
-      `INSERT INTO ideas_grades (idea_id, grade, template_key, field_values, completeness_score)
-       VALUES ($1, $2, $3, $4::jsonb, $5)
+      `INSERT INTO ideas_grades (idea_id, grade, template_key, field_values, completeness_score, recommendation)
+       VALUES ($1, $2, $3, $4::jsonb, $5, $6)
        ON CONFLICT (idea_id) DO UPDATE
           SET grade              = EXCLUDED.grade,
               template_key       = EXCLUDED.template_key,
               field_values       = EXCLUDED.field_values,
-              completeness_score = EXCLUDED.completeness_score
+              completeness_score = EXCLUDED.completeness_score,
+              recommendation     = EXCLUDED.recommendation
        RETURNING idea_id, grade, template_key, field_values, completeness_score,
-                 created_at, updated_at`,
-      [ideaId, grade, templateKey, JSON.stringify(fieldValues), completenessScore]
+                 recommendation, created_at, updated_at`,
+      [ideaId, grade, templateKey, JSON.stringify(fieldValues), completenessScore, recommendation]
     );
     return rows[0];
   } catch (err) {
@@ -185,7 +204,7 @@ async function setIdeaCompleteness(ideaId, completenessScore) {
         SET completeness_score = $2
       WHERE idea_id = $1
       RETURNING idea_id, grade, template_key, field_values, completeness_score,
-                created_at, updated_at`,
+                recommendation, created_at, updated_at`,
     [ideaId, completenessScore]
   );
   return rows[0] ?? null;
@@ -237,11 +256,11 @@ async function setIdeaCompleteness(ideaId, completenessScore) {
 // work, not current content, and setIdeaGrade's ON CONFLICT SET list omits both
 // columns — so a later re-score or an author's R13 resubmission preserves the
 // developer's attribution instead of silently erasing it.
-async function developSpark(ideaId, { developedBy, templateKey = DEFAULT_TEMPLATE_KEY, fieldValues = {}, completenessScore = null } = {}) {
+async function developSpark(ideaId, { developedBy, templateKey = DEFAULT_TEMPLATE_KEY, fieldValues = {}, completenessScore = null, recommendation = null } = {}) {
   // Reuse the R140 payload validator so a bad template key or an oversize
   // field_values map is a structured throw here rather than a constraint
   // violation surfacing as a 500 (the assertGradePayload contract).
-  assertGradePayload({ grade: 'full', templateKey, fieldValues, completenessScore });
+  assertGradePayload({ grade: 'full', templateKey, fieldValues, completenessScore, recommendation });
   if (developedBy == null) throw { code: 'MISSING_DEVELOPER' };
   const { rows } = await pool.query(
     `UPDATE ideas_grades
@@ -250,15 +269,21 @@ async function developSpark(ideaId, { developedBy, templateKey = DEFAULT_TEMPLAT
             field_values       = $3::jsonb,
             completeness_score = $4,
             developed_by       = $5,
-            developed_at       = now()
+            developed_at       = now(),
+            -- task 1004092 / BV2.R13: developing a spark IS filing the Full
+            -- Idea, so the developer states its scope recommendation here. A
+            -- spark has none to inherit (the question belongs to the full
+            -- grade), so an omitted value writing NULL is the honest outcome,
+            -- not a loss.
+            recommendation     = $6
       WHERE idea_id = $1
         AND grade = 'spark'
         AND EXISTS (
           SELECT 1 FROM idea_inbox i WHERE i.id = $1 AND i.status = 'open'
         )
       RETURNING idea_id, grade, template_key, field_values, completeness_score,
-                developed_by, developed_at, created_at, updated_at`,
-    [ideaId, templateKey, JSON.stringify(fieldValues), completenessScore, developedBy]
+                developed_by, developed_at, recommendation, created_at, updated_at`,
+    [ideaId, templateKey, JSON.stringify(fieldValues), completenessScore, developedBy, recommendation]
   );
   // null = "this row was not a developable spark when we looked". THREE ways to
   // get here, and the caller re-reads to say which: it was never a spark,
@@ -288,6 +313,10 @@ async function developSpark(ideaId, { developedBy, templateKey = DEFAULT_TEMPLAT
         grade: 'full',
         completeness_score: graded.completeness_score,
         developed_by: graded.developed_by,
+        // Stated from the write's own RETURNING rather than left to the re-read
+        // above, for the same reason completeness_score is: the listener acts on
+        // what this transition actually wrote.
+        recommendation: graded.recommendation ?? null,
       });
     } catch { /* a listener, or the read that feeds it, must never cost the ideator their grade */ }
   }
@@ -299,7 +328,7 @@ async function developSpark(ideaId, { developedBy, templateKey = DEFAULT_TEMPLAT
 async function getIdeaGrade(ideaId) {
   const { rows } = await pool.query(
     `SELECT idea_id, grade, template_key, field_values, completeness_score,
-            created_at, updated_at
+            recommendation, created_at, updated_at
        FROM ideas_grades
       WHERE idea_id = $1`,
     [ideaId]

package/modules/ideas/inbox.js

@@ -31,6 +31,7 @@ const ideasConfig = require('./config');
 const {
   IDEA_COLS, IDEA_COLS_Q, GRADE_COLS_Q, IDEA_JOIN_GRADE, ungradedProjection,
   DEFAULT_GRADE, VALID_GRADES, DEFAULT_TEMPLATE_KEY, TEMPLATE_KEY_MAX, FIELD_VALUES_MAX,
+  VALID_RECOMMENDATIONS, isValidRecommendation, normalizeRecommendation,
 } = require('./projection');
 // The carved domains. Each is re-exported at the bottom of this file, so every
 // existing caller of `require('./inbox')` keeps working unchanged — the same
@@ -796,6 +797,12 @@ module.exports = {
   DEFAULT_TEMPLATE_KEY,
   TEMPLATE_KEY_MAX,
   FIELD_VALUES_MAX,
+  // the recommendation vocabulary (task 1004092 / BV2.R13) — goal | criterion,
+  // re-exported so the routes and the composer's template read declare it from
+  // the same place the SQL CHECK mirrors
+  VALID_RECOMMENDATIONS,
+  isValidRecommendation,
+  normalizeRecommendation,
   // skill-friction marker + rank visibility gate (V3.R70 / #289; the kind
   // itself landed in task 1003105 — both markers are live, see above)
   SKILL_FRICTION_TAG,

package/modules/ideas/migrations/ideas_009_recommendation.sql

@@ -0,0 +1,62 @@
+-- ideas_009_recommendation.sql — a Full Idea carries a RECOMMENDATION: goal or
+-- criterion (task 1004092 / BV2.R13, spec R22 in
+-- docs/specs/bongos-v2-ideator-surface.md; spec decision 9).
+--
+-- WHAT THIS IS, AND WHAT IT IS NOT. It is the ideator's answer to "how big did
+-- this turn out to be" — a goal (a gravity well of its own) or a criterion (a
+-- ring inside an existing one). It is NOT a decision. The owner's recorded
+-- reasoning: scope is the thing you learn last, so the person who had the
+-- thought writes down what they think it is and the board, reading it, decides.
+-- Nothing in the system may branch on this column as if it were an outcome —
+-- the ratification half (BV2.R17) reads what the BOARD chose, and this column
+-- only travels alongside it so voters can see what was proposed.
+--
+-- WHY A COLUMN AND NOT A SIXTH TEMPLATE FIELD. The five questions are prose an
+-- author writes and the completeness scorer measures; this is a closed
+-- two-value vocabulary that nothing scores. Putting it in `field_values` would
+-- make it a scored field (`completeness.js` walks every declared field), would
+-- change what a Full Idea costs to file, and would have to be declared once per
+-- vintage — while the recommendation is the same question under any template.
+-- It is a property OF the grade row, beside `completeness_score`, not one of
+-- the answers inside it.
+--
+-- NULLABLE, AND THAT IS PERMANENT. Every Full Idea filed before today has no
+-- recommendation, and inventing one for them would put words in an author's
+-- mouth — the never-invent-a-field rule (the Ideator pack) is exactly about
+-- this. So NULL means "the author did not say", every reader must render that
+-- honestly, and there is no backfill. The hall composer requires a choice
+-- going forward (that is where the question is actually asked); the API keeps
+-- it optional, because a reader that can handle NULL for the historical rows
+-- can handle NULL for a terse CLI filing too, and a required body field would
+-- 400 every already-shipped client against an upgraded instance.
+--
+-- Text + CHECK rather than a Postgres enum TYPE, matching
+-- `ideas_grades_grade_chk` one column over: the vocabulary is pinned closed
+-- today (an unknown recommendation is refused, never silently stored) and
+-- widening it later is a one-line constraint change in a subsequent ideas_*
+-- migration rather than an enum-type migration.
+--
+-- Module migrations are ADDITIVE and NAMESPACED (ADR 0083 §Decision #5): this
+-- touches only `ideas_grades`, a table this module owns. There is no
+-- down-migration. Idempotent: safe to re-run.
+
+BEGIN;
+
+ALTER TABLE ideas_grades
+  ADD COLUMN IF NOT EXISTS recommendation text;
+
+-- Added separately and guarded, because ADD COLUMN IF NOT EXISTS skips the
+-- whole clause on a re-run — an inline CONSTRAINT would then never be created
+-- on an instance where the column already landed without it.
+DO $$
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1 FROM pg_constraint WHERE conname = 'ideas_grades_recommendation_chk'
+  ) THEN
+    ALTER TABLE ideas_grades
+      ADD CONSTRAINT ideas_grades_recommendation_chk
+      CHECK (recommendation IS NULL OR recommendation IN ('goal', 'criterion'));
+  END IF;
+END $$;
+
+COMMIT;

package/modules/ideas/projection.js

@@ -80,6 +80,40 @@ const TEMPLATE_KEY_MAX = 64;
 // payload gets a structured 400 instead of a constraint-violation 500.
 const FIELD_VALUES_MAX = 32768;
 
+// -------------------------------------------------------------------------
+// The recommendation (task 1004092 / BV2.R13, spec R22)
+//
+// What the author thinks their Full Idea turned out to be: a goal (a gravity
+// well of its own) or a criterion (a ring inside an existing one). A CLOSED
+// vocabulary, mirroring ideas_grades_recommendation_chk so an unknown value is
+// a named 400 at the route rather than a constraint-violation 500 in the
+// driver.
+//
+// NULL IS A FIRST-CLASS VALUE AND ALWAYS WILL BE — "the author did not say".
+// Every Full Idea filed before this shipped has no recommendation, and there is
+// no backfill, because inventing one would put a scope opinion in someone's
+// mouth. Every reader must render the absence honestly; nothing may substitute
+// a default.
+//
+// IT IS A RECOMMENDATION, NEVER A DECISION (spec decision 9). The ideator
+// recommends; the board decides. Nothing may branch on this column as if it
+// were the outcome — BV2.R17's ratification reads what the board chose.
+const VALID_RECOMMENDATIONS = ['goal', 'criterion'];
+
+// The one predicate. `undefined` and `null` both mean "not given" and are
+// legal; anything else must be a declared member. Pure, so a route can refuse
+// before any write and a test can exercise it with no harness.
+function isValidRecommendation(v) {
+  return v === null || v === undefined || VALID_RECOMMENDATIONS.includes(v);
+}
+
+// Normalise a request-supplied value to what the column stores. Written once
+// because three routes (capture, develop, resubmit) all take the same field and
+// all have to turn "absent" into NULL rather than into the string 'undefined'.
+function normalizeRecommendation(v) {
+  return v === undefined || v === '' ? null : v;
+}
+
 // The grade half of an idea read: the COALESCE above, plus the template-shaped
 // store and the score. `g.*` columns are NULL for an ungraded idea, which is
 // exactly right — it has no template and no score, it just has a default grade.
@@ -89,16 +123,22 @@ const FIELD_VALUES_MAX = 32768;
 // hall detail view (R153) and the R147 credit split all want it. NULL for the
 // overwhelming majority of rows — a quick idea and a self-authored Full Idea were
 // never developed by anyone — which is the honest answer, not a missing one.
+//
+// `recommendation` (ideas_009, task 1004092 / BV2.R13) rides along for the same
+// reason developed_by does: it is part of a Full Idea's identity from filing
+// onwards, and the board item, the detail read and the author's own trail all
+// want it without a second query. NULL for every quick idea and for every Full
+// Idea filed before the question existed — the honest answer, not a missing one.
 const GRADE_COLS_Q = `COALESCE(g.grade, '${DEFAULT_GRADE}') AS grade,
             g.template_key, g.field_values, g.completeness_score,
-            g.developed_by, g.developed_at`;
+            g.developed_by, g.developed_at, g.recommendation`;
 const IDEA_JOIN_GRADE = `LEFT JOIN ideas_grades g ON g.idea_id = i.id`;
 
 // The same projection for a row that provably has no grade row yet (a just-
 // INSERTed idea), so INSERT…RETURNING does not need a second round trip to
 // return the same shape every other read returns.
 function ungradedProjection() {
-  return { grade: DEFAULT_GRADE, template_key: null, field_values: null, completeness_score: null, developed_by: null, developed_at: null };
+  return { grade: DEFAULT_GRADE, template_key: null, field_values: null, completeness_score: null, developed_by: null, developed_at: null, recommendation: null };
 }
 
 module.exports = {
@@ -110,6 +150,9 @@ module.exports = {
   TEMPLATE_KEY_RE,
   TEMPLATE_KEY_MAX,
   FIELD_VALUES_MAX,
+  VALID_RECOMMENDATIONS,
+  isValidRecommendation,
+  normalizeRecommendation,
   GRADE_COLS_Q,
   IDEA_JOIN_GRADE,
   ungradedProjection,

package/modules/ideas/routes/inbox.js

@@ -122,6 +122,26 @@ function boardWindowPayload(item) {
   };
 }
 
+// THE RECOMMENDATION A FULL IDEA CARRIES (task 1004092 / BV2.R13, spec R22).
+// 'goal' or 'criterion' — the author's reading of how big the thought turned
+// out, carried from filing to the board item so voters see what was proposed.
+// IT IS NOT A DECISION (spec decision 9): the board decides, and no branch in
+// this module may treat it as the outcome.
+//
+// Spelled once because all three filing paths take the same field — capture,
+// develop and resubmit — and a second copy of the refusal is a second place for
+// the vocabulary to drift from ideas_grades_recommendation_chk. Returns true
+// when it has already answered the request.
+function refuseBadRecommendation(res, raw) {
+  if (inbox.isValidRecommendation(raw)) return false;
+  res.fail('bad_recommendation', 400, {
+    recommendation: raw,
+    allowed: inbox.VALID_RECOMMENDATIONS,
+    reason: 'a Full Idea recommends a goal or a criterion; the board decides which it becomes.',
+  });
+  return true;
+}
+
 module.exports = function buildInboxRouter() {
   registerSeams();
   const router = express.Router();
@@ -152,6 +172,10 @@ module.exports = function buildInboxRouter() {
       grade: { type: 'string', maxLength: 16 },
       template_key: { type: 'string', maxLength: inbox.TEMPLATE_KEY_MAX },
       field_values: { type: 'object' },
+      // task 1004092 / BV2.R13 — the author's own reading of how big this
+      // turned out: 'goal' or 'criterion'. OPTIONAL, permanently (see the
+      // refusal below and ideas_009's header).
+      recommendation: { type: 'string', maxLength: 16 },
     })) return;
     const body = req.body || {};
     if (body.kind === 'criterion-proposal') {
@@ -180,6 +204,18 @@ module.exports = function buildInboxRouter() {
       });
     }
     const templateKey = body.template_key ?? undefined;
+    // task 1004092 / BV2.R13. Checked BEFORE any write, like the field values
+    // below — and REFUSED on a non-full capture rather than dropped, because a
+    // quick idea writes no grade row at all, so silently accepting one would
+    // return 201 for a recommendation that was never stored anywhere.
+    if (refuseBadRecommendation(res, body.recommendation)) return;
+    if (body.recommendation !== undefined && grade !== 'full') {
+      return res.fail('recommendation_needs_full_grade', 400, {
+        grade: grade ?? 'quick',
+        reason: 'only a Full Idea recommends a scope — a quick idea has no grade row to carry one.',
+      });
+    }
+    const recommendation = inbox.normalizeRecommendation(body.recommendation);
     if (grade === 'full') {
       // Validate BEFORE any write, so a bad payload is a named 400 and no
       // orphan idea lands. Each error carries { field, reason } — the
@@ -236,11 +272,13 @@ module.exports = function buildInboxRouter() {
             ...(templateKey ? { templateKey } : {}),
             fieldValues: body.field_values,
             completenessScore: completenessScore(body.field_values, templateKey ? { templateKey } : undefined),
+            recommendation,
           });
           idea.grade = row.grade;
           idea.template_key = row.template_key;
           idea.field_values = row.field_values;
           idea.completeness_score = row.completeness_score;
+          idea.recommendation = row.recommendation ?? null;
 
           // Stream 2 (ADR 0172 / IC2): a Full Idea that clears the completeness
           // bar pays its author, once, on the IDEATOR credit lane — a separate
@@ -502,6 +540,22 @@ module.exports = function buildInboxRouter() {
             substance_min: f.substanceMin || 0,
           };
         }),
+        // task 1004092 / BV2.R13. The recommendation is NOT a sixth field — it
+        // is not prose, it is not scored, and it is the same closed question
+        // under every vintage — so it rides beside `fields` rather than in it.
+        // Served from here for the same reason the fields are: a hard-coded
+        // radio pair in the browser is the "second copy of the rules" defect
+        // one step earlier, and it would offer a vocabulary the CHECK
+        // constraint could already have widened past.
+        recommendation: {
+          label: 'What do you think this is',
+          hint: 'Your reading of how big it turned out. The board decides — this is what they read while deciding.',
+          required: false,
+          options: inbox.VALID_RECOMMENDATIONS.map((value) => ({
+            value,
+            label: value === 'goal' ? 'A goal of its own' : 'A criterion inside an existing goal',
+          })),
+        },
       },
     });
   }, { errorCode: 'template_read_failed' }));
@@ -748,7 +802,9 @@ module.exports = function buildInboxRouter() {
     if (validateOrRespond(req, res, {
       field_values: { required: true, type: 'object' },
       template_key: { type: 'string', maxLength: 64 },
+      recommendation: { type: 'string', maxLength: 16 },
     })) return;
+    if (refuseBadRecommendation(res, req.body.recommendation)) return;
     try {
       const idea = await inbox.getIdea(id);
       if (!idea) return res.fail('idea_not_found', 404);
@@ -798,8 +854,15 @@ module.exports = function buildInboxRouter() {
         ...(templateKey ? { templateKey } : {}),
         fieldValues: req.body.field_values,
         completenessScore: completenessScore(req.body.field_values, templateKey ? { templateKey } : undefined),
+        // task 1004092 / BV2.R13. CARRIED FORWARD FROM THE STORED ROW when the
+        // body names none — the same `?? idea.…` shape template_key uses two
+        // lines up, and for a sharper reason. setIdeaGrade writes the WHOLE
+        // row, so defaulting to null here would mean that answering a board
+        // objection silently withdrew the scope recommendation the board had
+        // been shown, on a request that never mentioned it.
+        recommendation: inbox.normalizeRecommendation(req.body.recommendation ?? idea.recommendation ?? undefined),
       });
-      const out = { ...idea, grade: row.grade, template_key: row.template_key, field_values: row.field_values, completeness_score: row.completeness_score };
+      const out = { ...idea, grade: row.grade, template_key: row.template_key, field_values: row.field_values, completeness_score: row.completeness_score, recommendation: row.recommendation ?? null };
 
       try {
         const reward = api.resolveOptional && api.resolveOptional('reward');
@@ -995,7 +1058,9 @@ module.exports = function buildInboxRouter() {
     if (validateOrRespond(req, res, {
       field_values: { required: true, type: 'object' },
       template_key: { type: 'string', maxLength: 64 },
+      recommendation: { type: 'string', maxLength: 16 },
     })) return;
+    if (refuseBadRecommendation(res, req.body.recommendation)) return;
 
     const idea = await inbox.getIdea(id);
     if (!idea) return res.fail('idea_not_found', 404);
@@ -1040,6 +1105,11 @@ module.exports = function buildInboxRouter() {
       ...(templateKey ? { templateKey } : {}),
       fieldValues: req.body.field_values,
       completenessScore: completenessScore(req.body.field_values, templateKey ? { templateKey } : undefined),
+      // task 1004092 / BV2.R13. No `?? idea.recommendation` fallback here, and
+      // that is not an omission: a spark has no recommendation to inherit (the
+      // question belongs to the full grade), so the developer is the first
+      // person ever asked it on this row.
+      recommendation: inbox.normalizeRecommendation(req.body.recommendation),
     });
     // Zero rows means the guard fired: somebody else developed this spark between
     // the read above and this write. Their work stands; this caller is told so
@@ -1070,6 +1140,7 @@ module.exports = function buildInboxRouter() {
       completeness_score: row.completeness_score,
       developed_by: row.developed_by,
       developed_at: row.developed_at,
+      recommendation: row.recommendation ?? null,
     };
 
     // Fail-open, exactly like the capture and resubmit paths: the development has

package/modules/ideas/templates.js

@@ -82,20 +82,48 @@ const BASE_V1_TEMPLATE = Object.freeze({
 // the v1 label. `purpose`, `big_picture` and `why_matters` are NOT carried over —
 // they belong to v1 and stay there.
 //
-// THE FLOORS ARE FLAT 40, MATCHING v1, AND THAT IS TEMPORARY. The new questions
-// are not interchangeable ("scope it as best as you can" deserves more room than
-// "what made you have the idea"), but the score feeds credits, so choosing the
-// numbers is its own deliberate act — task 1004091 (BV2.R12) owns it. Shipping a
-// guess here would have been an unreviewed change to what a thought pays.
+// THE FLOORS, CHOSEN PER FIELD (task 1004091 / BV2.R12, spec R21). v2 shipped at
+// a placeholder flat 40 because picking the numbers is its own deliberate act:
+// `completeness_score` is the mean of per-field ratios, and that number gates
+// both the ideator credit (economy's IDEA_FULL_PASS_BAR = 60) and whether a Full
+// Idea reaches the board at all (government's FULL_IDEA_PASS_BAR). A floor is not
+// a style note; it is a price.
+//
+// THE TOTAL IS HELD AT 200, EXACTLY v1's FIVE × 40. What a thought costs to file
+// is an economic decision the owner has already made once; this task was asked to
+// distribute that cost across questions that are not interchangeable, not to
+// re-price filing. Redistributing inside a fixed total is the change that needs no
+// owner ruling. (It also keeps the template clear of ADR 0186's interim karma-
+// eligibility guard — ≥3 required fields and ≥120 total `substanceMin`.)
+//
+// WHY EACH NUMBER, IN ONE LINE EACH. The rule is how much text the question
+// HONESTLY takes, never how much we would like to receive:
+//   why_had 25       — the anti-ghost-writing field, and the shortest honest
+//                      answer is a sentence. Nobody but the filer can say what
+//                      made them have the idea, so this is precisely the floor
+//                      that must NOT push an agent to pad; the never-invent-a-
+//                      field rule (the Ideator pack) is strongest here.
+//   scope 65         — "as best as you can" is an invitation to the longest
+//                      answer in the set, and this field is the one that becomes
+//                      the work. The highest floor in the template.
+//   build_context 45 — a prior-knowledge dump: real but bounded, and legitimately
+//                      short when there genuinely is little to know.
+//   fit 30           — an argument, and a good one is compact. Deliberately low:
+//                      a long justification is usually a weak one.
+//   success 35       — a concrete picture of the finished thing; a few sentences.
+//
+// EACH RATIO IS CAPPED AT 1, SO THE TOTAL IS NOT A BUDGET. A 600-character scope
+// answer cannot buy a blank `why_had`; the floors bind field by field, which is
+// the whole reason they differ.
 const BASE_V2_TEMPLATE = Object.freeze({
   key: 'base-v2',
   label: 'Full Idea',
   fields: Object.freeze([
-    Object.freeze({ key: 'why_had',       label: 'What made you have the idea',                                required: true, substanceMin: 40 }),
-    Object.freeze({ key: 'scope',         label: 'Scope it as best as you can here',                           required: true, substanceMin: 40 }),
-    Object.freeze({ key: 'build_context', label: 'What should an engineer or artist know prior to building',    required: true, substanceMin: 40 }),
-    Object.freeze({ key: 'fit',           label: 'How is this long term justified in the project',              required: true, substanceMin: 40 }),
-    Object.freeze({ key: 'success',       label: 'What does a successful implementation of the idea look like', required: true, substanceMin: 40 }),
+    Object.freeze({ key: 'why_had',       label: 'What made you have the idea',                                required: true, substanceMin: 25 }),
+    Object.freeze({ key: 'scope',         label: 'Scope it as best as you can here',                           required: true, substanceMin: 65 }),
+    Object.freeze({ key: 'build_context', label: 'What should an engineer or artist know prior to building',    required: true, substanceMin: 45 }),
+    Object.freeze({ key: 'fit',           label: 'How is this long term justified in the project',              required: true, substanceMin: 30 }),
+    Object.freeze({ key: 'success',       label: 'What does a successful implementation of the idea look like', required: true, substanceMin: 35 }),
   ]),
 });
 

package/package-lock.json

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

package/package.json

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

package/src/module-api.js

@@ -71,7 +71,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.934'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.936'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/government_board_view.mjs

@@ -69,7 +69,11 @@ test('the assembled view: enrichment, the open ballot, the snapshot, the databas
 
   const idea = view.open[0];
   assert.deepEqual(idea.subject,
-    { title: 'A big idea', author_id: '9', field_values: { purpose: 'p' }, template_key: 'base-v1', completeness_score: 82 },
+    // `recommendation: null` is the stored row's own answer, not a filler: this
+    // stub idea has no recommendation column set, and BV2.R13's whole posture is
+    // that "the author did not say" must reach the room as itself rather than
+    // being dropped or defaulted to one of the two values.
+    { title: 'A big idea', author_id: '9', field_values: { purpose: 'p' }, template_key: 'base-v1', completeness_score: 82, recommendation: null },
     'an idea shows its title, author, AND its five sections — the voter decides with the idea in front of them (R17)');
   assert.equal(idea.remaining_seconds, 540, 'the DATABASE clock, passed through — the client never does clock math');
   assert.deepEqual(idea.constitution, MONARCHY, 'the SNAPSHOT rides along — the room describes the rule the item runs under');

package/tests/idea_completeness.mjs

@@ -40,6 +40,11 @@ const COMPLETE = Object.fromEntries(
 // 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);
@@ -51,13 +56,25 @@ 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, [FIELD_1]: '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}`);
+  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', () => {
@@ -111,7 +128,16 @@ 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, [FIELD_2]: 'thin', [FIELD_4]: '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, FIELD_2, 'the earlier of two equal-thinnest fields, by template order');
   // strictly-thinnest wins regardless of position

package/tests/idea_develop_spark.mjs

@@ -145,7 +145,12 @@ await test('a DISTINCT developer is recorded, and both parties are named in the
   assert.equal(r.payload.developer_id, '42');
   assert.equal(r.payload.author_id, '9');
   assert.equal(r.payload.self_developed, false);
-  assert.equal(updateQ().params.at(-1), '42', 'the developer is the AUTHENTICATED builder, not a body field');
+  // The developer is $5 in developSpark's UPDATE. Pinned by INDEX, not by
+  // `.at(-1)`: task 1004092 appended `recommendation` as $6, and a pin that
+  // meant "the developer" while reading "the last parameter" then failed for a
+  // reason that had nothing to do with what it was asserting.
+  assert.equal(updateQ().params[4], '42', 'the developer is the AUTHENTICATED builder, not a body field');
+  assert.equal(updateQ().params.length, 6, 'developSpark binds six parameters — a new one must be placed deliberately');
 });
 
 await test('self-development is legal and reported as such', async () => {