@bongos/core 1.19.295 → 1.19.297

package/modules/ideas/inbox.js

@@ -100,15 +100,22 @@ const FIELD_VALUES_MAX = 32768;
 // 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.
+// developed_by/developed_at (ideas_005, task 1002922 / BV1.R146) ride along on
+// EVERY idea read rather than needing a second query: "who developed this" is
+// part of an idea's identity once it has been developed, and the R145 queue, the
+// 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.
 const GRADE_COLS_Q = `COALESCE(g.grade, '${DEFAULT_GRADE}') AS grade,
-            g.template_key, g.field_values, g.completeness_score`;
+            g.template_key, g.field_values, g.completeness_score,
+            g.developed_by, g.developed_at`;
 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 };
+  return { grade: DEFAULT_GRADE, template_key: null, field_values: null, completeness_score: null, developed_by: null, developed_at: null };
 }
 
 // -------------------------------------------------------------------------
@@ -782,6 +789,91 @@ async function countRoutedAwaitingNod(deps = {}) {
   return rows[0] ? rows[0].n : 0;
 }
 
+// -------------------------------------------------------------------------
+// The spark queue (task 1002921 / BV1.R145, goal 1000062)
+//
+// "What Big Idea Sparks are awaiting development?" — the ideator craft's pickup
+// surface, and the first place in this codebase where one craft sources work
+// from another craft's output.
+//
+// THE PREDICATE IS grade='spark' AND status='open', AND THAT IS THE WHOLE
+// QUEUE. There is deliberately no `developed` flag and no separate queue table:
+// R146 develops a spark into a Full Idea IN PLACE on the same idea_inbox row
+// (same id, same captured_by), which flips its grade spark→full — so a developed
+// spark leaves this queue as a CONSEQUENCE of being developed, not because
+// anything remembered to remove it. A second source of truth for "still
+// waiting" is a thing that can disagree with the grade; this cannot.
+//
+// AN INNER JOIN, WHICH INVERTS THIS MODULE'S USUAL RULE ON PURPOSE. Every other
+// idea read LEFT JOINs ideas_grades and COALESCEs to 'quick', because an
+// un-graded idea must still appear. Here the opposite is correct and safe:
+// grade='spark' can never be implicit — absence of a row means quick — so a
+// spark ALWAYS has a real row, and starting from ideas_grades lets
+// ideas_grades_grade_score_idx (ideas_001, written for this very read) drive the
+// scan instead of filtering a full idea_inbox pass afterwards.
+//
+// ORDERING — "newest-or-best first", and only the newest half is real. A spark
+// carries no completeness score by construction (it has no template fields to
+// score), so there is no "best" signal to sort by: upvotes live on builders as
+// karma, not per-idea, and inventing a quality metric for an undeveloped thought
+// is exactly the guess this queue should not be making. captured_at DESC, id
+// DESC as a stable tiebreak for same-timestamp rows. When a real per-idea
+// signal exists, this ORDER BY is the one line that changes.
+//
+// The skill-friction visibility gate (V3.R70) is applied here too, on the same
+// title-prefix rule listOpenIdeas uses. A routine-filed friction row is unlikely
+// to ever be sparked (marking requires an author), but the two idea listings
+// agreeing by construction beats them agreeing by accident.
+function sparkQueueWhere(viewerRank, params) {
+  const where = [`g.grade = 'spark'`, `i.status = 'open'`];
+  if (!rankCanSeeSkillFriction(viewerRank)) {
+    params.push(`${SKILL_FRICTION_TAG}%`);
+    where.push(`i.title NOT LIKE $${params.length}`);
+  }
+  return where;
+}
+
+async function listSparkQueue({ limit = 50, viewerRank = null } = {}, deps = {}) {
+  const activePool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : pool;
+  const params = [];
+  const where = sparkQueueWhere(viewerRank, params);
+  params.push(limit);
+  const { rows } = await activePool.query(
+    // `b.github_login` because attribution is the POINT of this surface: an
+    // ideator picking work up should see whose thought they are developing, and
+    // R146 has to preserve that name. LEFT JOIN — a builder row can be missing.
+    `SELECT ${IDEA_COLS_Q}, ${GRADE_COLS_Q},
+            b.github_login AS filed_by_login
+       FROM ideas_grades g
+       JOIN idea_inbox i ON i.id = g.idea_id
+       LEFT JOIN builders b ON b.id = i.captured_by
+      WHERE ${where.join(' AND ')}
+      ORDER BY i.captured_at DESC, i.id DESC
+      LIMIT $${params.length}`,
+    params
+  );
+  return rows;
+}
+
+// The count behind the queue's pill — the SAME predicate as the list (the
+// countRoutedAwaitingNod / countOpenIdeas precedent), so the number a viewer is
+// shown can never disagree with the rows they can actually see. It deliberately
+// takes viewerRank too: a count that ignored the visibility gate would tell a
+// Xenos there are sparks they cannot find.
+async function countSparkQueue({ viewerRank = null } = {}, deps = {}) {
+  const activePool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : pool;
+  const params = [];
+  const where = sparkQueueWhere(viewerRank, params);
+  const { rows } = await activePool.query(
+    `SELECT COUNT(*)::int AS n
+       FROM ideas_grades g
+       JOIN idea_inbox i ON i.id = g.idea_id
+      WHERE ${where.join(' AND ')}`,
+    params
+  );
+  return rows[0] ? rows[0].n : 0;
+}
+
 // -------------------------------------------------------------------------
 // Grade writes (task 1002916 / BV1.R140)
 //
@@ -866,6 +958,81 @@ async function setIdeaCompleteness(ideaId, completenessScore) {
   return rows[0] ?? null;
 }
 
+// -------------------------------------------------------------------------
+// developSpark — turn a Big Idea Spark into a Full Idea IN PLACE
+// (task 1002922 / BV1.R146, goal 1000062)
+//
+// The pickup half of the spark handoff: R144 recorded the author's consent, R145
+// made the spark findable, and this is another builder filling in the five
+// template fields.
+//
+// IN PLACE, ON THE SAME ROW, AND THAT IS A DONE-WHEN. idea_inbox.id,
+// captured_by and captured_at are NOT touched — only the grade row moves. A new
+// row for the developed version would break the hall's /#/idea/N deep link,
+// ideas_task_lineage.idea_id, and the per-idea credit_log reason key. The
+// author's claim on their own thought is precisely what must survive being
+// developed by someone else; it is what the R147 split pays against.
+//
+// ONE GUARDED UPDATE, WHICH IS WHERE "ONLY ONCE" ACTUALLY LIVES. The predicate
+// carries `AND grade = 'spark'`, so the database decides whether this row was
+// still developable. A read-then-write ("is it a spark? ok, develop it") looks
+// identical in a test and loses a race in production: two builders picking the
+// same spark off the R145 queue at the same moment would both pass the check and
+// the second would overwrite the first's work AND their attribution. Here the
+// second UPDATE matches zero rows and the route turns that into a 409. Zero rows
+// is therefore NOT an error condition to log — it is the answer.
+//
+// It is also why this is not expressed as setIdeaGrade + a second write:
+// two statements cannot carry one guard, and a Full Idea with no recorded
+// developer is the exact state the done-when forbids.
+//
+// THE STATUS HALF OF THE GUARD, AND WHY IT IS NOT REDUNDANT WITH THE ROUTE'S
+// PRE-CHECK. Triage (`updateIdea`) writes idea_inbox.status and NEVER touches
+// ideas_grades — so a spark that a Metic+ triager discards, merges or promotes
+// keeps grade='spark' forever. Grade alone therefore does NOT mean "still
+// developable", and a develop that trusted it would resurrect content the triage
+// flow already decided was dead, opening a fresh board ratification window for
+// it. The R145 queue already filters on status and the R144 mark already requires
+// it; this closes the same hole on the write. In the PREDICATE rather than only
+// in the handler because a triager discarding an idea mid-request is the same
+// class of race as two developers colliding — and the fix for a race is never a
+// check that ran earlier.
+//
+// NOTE ON setIdeaGrade's whole-row contract: developed_by/developed_at are
+// deliberately OUTSIDE it. That contract exists so a grade change cannot inherit
+// stale field_values; but a developer is a historical FACT about who did the
+// 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 } = {}) {
+  // 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 });
+  if (developedBy == null) throw { code: 'MISSING_DEVELOPER' };
+  const { rows } = await pool.query(
+    `UPDATE ideas_grades
+        SET grade              = 'full',
+            template_key       = $2,
+            field_values       = $3::jsonb,
+            completeness_score = $4,
+            developed_by       = $5,
+            developed_at       = now()
+      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]
+  );
+  // 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,
+  // somebody else developed it first, or a triager closed the idea underneath us.
+  return rows[0] ?? null;
+}
+
 // The grade row on its own. null = no row, which reads as grade='quick'
 // everywhere the idea itself is read (see DEFAULT_GRADE).
 async function getIdeaGrade(ideaId) {
@@ -1101,6 +1268,8 @@ module.exports = {
   updateIdeaBody,
   setIdeaGrade,
   setIdeaCompleteness,
+  // develop a spark into a Full Idea, in place (task 1002922, BV1.R146)
+  developSpark,
   // idea → task lineage (task 1002997 / BV1.R173) — the one-idea-many-tasks
   // link stream 1 (IC4) pays against
   linkIdeaTask,
@@ -1109,6 +1278,9 @@ module.exports = {
   // the nod queue (task 1003066, BV1.R05)
   listRoutedAwaitingNod,
   countRoutedAwaitingNod,
+  // the spark queue (task 1002921, BV1.R145) — sparks awaiting development
+  listSparkQueue,
+  countSparkQueue,
   // criterion-proposal ratification (V3.R31 / #252)
   ratifyCriterionProposal,
   parseProposalBody,

package/modules/ideas/migrations/ideas_005_grade_developed_by.sql

@@ -0,0 +1,85 @@
+-- ideas_005_grade_developed_by.sql — who developed this spark into a Full Idea
+-- (task 1002922, BV1.R146, goal 1000062 "three grades of idea").
+--
+-- WHY. R144 let an author mark a quick idea as a Big Idea Spark ("I have the
+-- spark but not the full picture, someone develop this") and R145 made those
+-- sparks browsable. R146 is the pickup itself: another builder fills in the five
+-- template fields and the spark becomes a Full Idea. The done-when requires the
+-- row to keep its id and its ORIGINAL author while a DISTINCT developer is
+-- recorded — and ideas_grades had nowhere to record the second person. This adds
+-- that place.
+--
+-- WHY IN-PLACE, ON THE SAME ROW. The alternative — a new idea_inbox row for the
+-- developed version — breaks every reference to the original: the hall's
+-- /#/idea/N deep link, ideas_task_lineage.idea_id, the credit_log reason key
+-- `idea.credit.full_pass:<id>`, and any prose that cited it. "References to the
+-- idea never break" is a done-when, so development mutates the grade row and
+-- leaves idea_inbox.id / captured_by / captured_at untouched. That is also why
+-- the developer needs its own column instead of overwriting captured_by: the
+-- author's claim on their own thought is exactly what must survive being
+-- developed by someone else, and it is what the R147 credit split pays against.
+--
+-- WHY developed_at, AND NOT JUST updated_at. ideas_001 put a touch trigger on
+-- this table, so updated_at moves on EVERY later write — a re-score, a
+-- resubmission, a triage-adjacent grade rewrite. An attribution record whose
+-- only timestamp drifts cannot answer "when was this developed", which is the
+-- question the R147 split and any dispute about it will ask. One extra column is
+-- cheaper than an unanswerable question.
+--
+-- SELF-DEVELOPMENT IS LEGAL, SO THERE IS NO developed_by <> captured_by CHECK.
+-- An author may mark their own idea as needing development and then develop it
+-- themselves (they may have had the full picture a week later). Forbidding that
+-- would add a rule the owner never asked for; R147 simply sees a split where
+-- both halves are the same person. The pair-coherence CHECK below is the only
+-- constraint, and it guards a shape this module's own code controls.
+--
+-- Module migrations are ADDITIVE and NAMESPACED: every object here targets the
+-- ideas_-owned ideas_grades table, no down-migration, idempotent (safe to re-run).
+
+BEGIN;
+
+-- ON DELETE SET NULL, matching the builders-FK posture of every other module
+-- table that names a person (agents_001, government_001): losing a builder row
+-- must never cascade away an idea's grade. The attribution degrades to "someone",
+-- which the read path already renders (R145's queue prints "an unnamed builder").
+ALTER TABLE ideas_grades
+  ADD COLUMN IF NOT EXISTS developed_by bigint REFERENCES builders(id) ON DELETE SET NULL;
+
+ALTER TABLE ideas_grades
+  ADD COLUMN IF NOT EXISTS developed_at timestamptz;
+
+-- The two columns are written together by developSpark() and mean nothing apart:
+-- a developer with no timestamp cannot be dated, and a timestamp with no
+-- developer names nobody. Defense in depth against a future partial write.
+ALTER TABLE ideas_grades DROP CONSTRAINT IF EXISTS ideas_grades_developed_pair_chk;
+ALTER TABLE ideas_grades ADD CONSTRAINT ideas_grades_developed_pair_chk
+  CHECK ((developed_by IS NULL) = (developed_at IS NULL));
+
+-- "What has this builder developed?" — the read the R147 credit split walks, and
+-- the one a builder's own profile will want. PARTIAL, because the overwhelming
+-- majority of grade rows have no developer at all (every quick idea, every
+-- self-authored full idea), so indexing them would be paying for empty space.
+CREATE INDEX IF NOT EXISTS ideas_grades_developed_by_idx
+  ON ideas_grades (developed_by)
+  WHERE developed_by IS NOT NULL;
+
+-- SAFETY NET — a migration that cannot prove its own effect must not report
+-- success (the ideas_003 precedent). Read-only, no DDL: if either column is
+-- missing, the ADD silently did nothing and R146's route would fail at runtime
+-- on the one write whose whole job is preserving attribution.
+DO $$
+DECLARE missing text;
+BEGIN
+  SELECT string_agg(c, ', ') INTO missing
+    FROM unnest(ARRAY['developed_by', 'developed_at']) AS c
+   WHERE NOT EXISTS (
+     SELECT 1 FROM information_schema.columns
+      WHERE table_name = 'ideas_grades' AND column_name = c
+   );
+  IF missing IS NOT NULL THEN
+    RAISE EXCEPTION
+      'ideas_005: column(s) % missing from ideas_grades after ADD COLUMN — the migration did not take.', missing;
+  END IF;
+END $$;
+
+COMMIT;

package/modules/ideas/routes/inbox.js

@@ -312,6 +312,43 @@ module.exports = function buildInboxRouter() {
     }
   });
 
+
+  // GET /inbox/sparks — THE SPARK QUEUE (task 1002921 / BV1.R145, goal 1000062).
+  //
+  // Big Idea Sparks awaiting development: the ideator craft's pickup surface,
+  // and the first place one craft sources work from another craft's output.
+  //
+  // READABLE BY ANY BUILDER, by design and by the done-when. A pickup surface
+  // that only trusted builders could read would defeat its own purpose — the
+  // whole point is that someone OTHER than the author comes along and develops
+  // the thought. The author's consent is already recorded (the R144 mark is what
+  // put the row here), so no further gate belongs on the read. Contrast
+  // /inbox/awaiting-nod directly above, which IS gated: that queue exists to be
+  // ACTED on by a triager, this one to be BROWSED by anyone.
+  //
+  // DECLARED BEFORE `GET /inbox/:id` DELIBERATELY — and this ordering is
+  // load-bearing, not stylistic. Express matches in declaration order, so with
+  // the routes the other way round `/inbox/sparks` binds `:id = 'sparks'` and
+  // parseId turns the whole queue into a 400 bad_id. Same reason
+  // /inbox/awaiting-nod sits above it. tests/idea_spark_queue.mjs pins the
+  // relative order so a future insertion cannot quietly re-shadow it.
+  //
+  // rank: any-builder — a pickup surface is public to builders (the R144 mark is
+  // the consent). Deliberately NOT pinned in route-rank-check: a read with no
+  // gate to protect has no downgrade to catch, and pinning it would only assert
+  // that a read stays open.
+  router.get('/inbox/sparks', api.requireBuilder, api.asyncHandler('GET /inbox/sparks', async (req, res) => {
+    const limitRaw = Number(req.query.limit);
+    const limit = Number.isInteger(limitRaw) && limitRaw > 0 && limitRaw <= 100 ? limitRaw : 50;
+    // Both halves take the viewer's rank so the pill can never claim sparks the
+    // list will not show (the countRoutedAwaitingNod precedent).
+    const viewerRank = req.builder && req.builder.rank;
+    const [sparks, count] = await Promise.all([
+      inbox.listSparkQueue({ limit, viewerRank }),
+      inbox.countSparkQueue({ viewerRank }),
+    ]);
+    return res.json({ sparks, count });
+  }, { errorCode: 'spark_queue_failed' }));
   // rank: any-builder — single idea read for the "#NNN" deep-link resolver
   // (#1047). Mirrors GET /blockers/:id. The hall resolves /#/idea/N by id, but
   // the /inbox LIST returns only the open-first-50, so a closed/older idea ref
@@ -556,6 +593,160 @@ module.exports = function buildInboxRouter() {
     });
   }, { errorCode: 'idea_unspark_failed' }));
 
+  // POST /inbox/:id/develop — DEVELOP A SPARK INTO A FULL IDEA
+  // (task 1002922 / BV1.R146, goal 1000062).
+  //
+  // The pickup half of the handoff R144 and R145 set up: the author consented by
+  // marking the spark, the queue made it findable, and now another builder fills
+  // in the five template fields and the thought becomes a Full Idea.
+  //
+  // OPEN TO ANY BUILDER, INCLUDING THE AUTHOR. Cross-builder development is the
+  // entire point, so there is no author check here — the mirror image of R144,
+  // where the gate was the whole feature. The consent was already given and is
+  // already recorded (this row is a spark BECAUSE its author said so), and
+  // re-asking for it would make the queue unpickable. Self-development is
+  // likewise legal: an author may mark a thought and come back to it themselves.
+  //
+  // ONLY A SPARK CAN BE DEVELOPED, and "only once" is enforced by the DATABASE,
+  // not by this handler. developSpark's UPDATE carries `AND grade = 'spark'`, so
+  // two builders picking the same spark off the queue at the same instant cannot
+  // both succeed — the second matches zero rows. The pre-read below exists ONLY
+  // to tell a 404 apart from a 409 and to give a useful message; it is not the
+  // guard, and it deliberately does not try to be.
+  //
+  // WHAT THIS ROUTE DELIBERATELY DOES NOT DO: pay the stream-2 "Full Idea passed"
+  // credit. Capture and resubmit both fire it, but on those paths the recipient
+  // is unambiguously the author. Here there are two people, and choosing between
+  // them is R147's job (task 1002923 — "karma for a ratified Full Idea, scaled by
+  // completeness and SPLIT WITH THE SPARK AUTHOR"). Firing it here would not just
+  // pre-empt that decision, it would corrupt it: awardIdeaFullPassCredit's
+  // idempotency predicate is (builder_id, `idea.credit.full_pass:<id>`), so a
+  // payment to the DEVELOPER does not block a later payment to the AUTHOR — one
+  // idea would pay twice. The credit is idempotent per idea+builder, so R147 can
+  // still pay it at the right time, to the right people, in the right shares.
+  //
+  // The board window IS opened, because it is recipient-agnostic (it takes an
+  // idea and a score, not a builder) and without it a developed Full Idea could
+  // never reach ratification — the handoff would dead-end one step from done.
+  // Fail-open like every other caller of that port.
+  //
+  // rank: any-builder — development is the pickup, and the author's mark is the
+  // consent. Deliberately NOT pinned in route-rank-check: there is no gate here
+  // to protect, and pinning it would only assert that an open route stays open.
+  router.post('/inbox/:id/develop', api.requireBuilder, api.asyncHandler('POST /inbox/:id/develop', async (req, res) => {
+    const id = parseId(req, res, { code: 'bad_id', positiveInt: true });
+    if (id === null) return;
+    if (validateOrRespond(req, res, {
+      field_values: { required: true, type: 'object' },
+      template_key: { type: 'string', maxLength: 64 },
+    })) return;
+
+    const idea = await inbox.getIdea(id);
+    if (!idea) return res.fail('idea_not_found', 404);
+    if (idea.grade !== 'spark') {
+      return res.fail('not_a_spark', 409, {
+        grade: idea.grade,
+        ...(idea.developed_by ? { developed_by: idea.developed_by } : {}),
+        reason: idea.grade === 'full'
+          ? 'this idea has already been developed into a Full Idea'
+          : 'only a Big Idea Spark can be developed — its author has to mark it first, which is what makes developing it fair',
+      });
+    }
+    // A SPARK IS NOT NECESSARILY STILL DEVELOPABLE. Triage writes
+    // idea_inbox.status and never touches ideas_grades, so an idea a triager
+    // discarded, merged or promoted keeps grade='spark' forever. Developing one
+    // would resurrect content the triage flow already decided was dead — and
+    // worse, open a fresh board ratification window for it. The R144 mark and the
+    // R145 queue both require status='open'; this is the same rule on the write.
+    // (developSpark's predicate carries it too, for the mid-request race.)
+    if (idea.status !== 'open') {
+      return res.fail('idea_not_open', 409, {
+        status: idea.status,
+        reason: 'this idea is no longer open, so it is not awaiting development',
+      });
+    }
+
+    // Same validation the capture and resubmit paths use, against the same
+    // template declaration — a developed Full Idea is a Full Idea, and must not
+    // be held to a looser standard just because someone else wrote it.
+    const templateKey = req.body.template_key ?? idea.template_key ?? undefined;
+    let v;
+    try {
+      v = validateFieldValues(req.body.field_values, templateKey ? { templateKey } : undefined);
+    } catch (validationErr) {
+      api.logger('ideas').error(`POST /inbox/:id/develop validation threw: ${validationErr && validationErr.message}`);
+      return res.fail('invalid_field_values', 400, { errors: [{ field: null, reason: 'unvalidatable' }] });
+    }
+    if (!v.ok) return res.fail('invalid_field_values', 400, { errors: v.errors, template_key: templateKey ?? null });
+
+    const row = await inbox.developSpark(id, {
+      developedBy: req.builder.id,
+      ...(templateKey ? { templateKey } : {}),
+      fieldValues: req.body.field_values,
+      completenessScore: completenessScore(req.body.field_values, templateKey ? { templateKey } : undefined),
+    });
+    // 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
+    // rather than silently overwriting it.
+    if (!row) {
+      // The guard fired between the read above and the write. THREE causes now,
+      // and guessing would misinform: another developer got there first, or a
+      // triager closed the idea. One extra read on a rare path buys an honest
+      // answer instead of a plausible one.
+      const now = await inbox.getIdea(id);
+      if (now && now.status !== 'open') {
+        return res.fail('idea_not_open', 409, {
+          status: now.status,
+          reason: 'a triager closed this idea while you were developing it',
+        });
+      }
+      return res.fail('spark_already_developed', 409, {
+        ...(now && now.developed_by ? { developed_by: now.developed_by } : {}),
+        reason: 'another builder developed this spark first — their version stands',
+      });
+    }
+
+    const out = {
+      ...idea,
+      grade: row.grade,
+      template_key: row.template_key,
+      field_values: row.field_values,
+      completeness_score: row.completeness_score,
+      developed_by: row.developed_by,
+      developed_at: row.developed_at,
+    };
+
+    let board_window;
+    try {
+      const government = api.resolveOptional && api.resolveOptional('government');
+      if (government && government.openBoardWindowForIdea) {
+        const w = await government.openBoardWindowForIdea({ ideaId: id, completenessScore: row.completeness_score });
+        if (w && w.opened && w.item) board_window = { item_id: w.item.id, closes_at: w.item.closes_at };
+        else if (w && w.reason === 'below_bar') {
+          // The same honest feedback the resubmit path gives: which section is
+          // thinnest, computed from what was just written. Derived, never stored.
+          const flag = weakestSectionPayload(req.body.field_values, templateKey ? { templateKey } : undefined);
+          if (flag) out.rejection = flag;
+        }
+      }
+    } catch (boardErr) {
+      // Fail-open, like every other caller of this port: the development landed
+      // and must not be rolled back because the board could not be told.
+      api.logger('ideas').error(`develop: board-window open failed (development intact, window skipped): ${boardErr && boardErr.message}`);
+    }
+
+    return res.json({
+      idea: out,
+      developed: true,
+      // Named explicitly so a caller never has to compare two ids to find out,
+      // and so the R147 split reads its two parties off one response.
+      author_id: idea.captured_by ?? null,
+      developer_id: row.developed_by,
+      self_developed: idea.captured_by != null && String(idea.captured_by) === String(row.developed_by),
+      ...(board_window ? { board_window } : {}),
+    });
+  }, { errorCode: 'idea_develop_failed' }));
+
   // Metic+ (#360 / ADR 0018): idea triage (promote/discard/merge) shapes the
   // backlog. Criterion C2 assigns triage to Metic, so this widened from
   // archon-only to metic+archon when the three-rank model went live. Any

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.295",
+  "version": "1.19.297",
   "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",