@bongos/core 1.19.301 → 1.19.303

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.301",
-  "core_contract": "1.19.301",
-  "source_commit": "5c6946b0ce2a4a6744b21c6d69a318d5a73180aa",
+  "core_version": "1.19.303",
+  "core_contract": "1.19.303",
+  "source_commit": "fd08cc750b621521b54d357645136366c89f0316",
   "source_ref": "HEAD",
-  "built_at": "2026-08-22T22:20:55.084Z",
+  "built_at": "2026-08-22T23:32:40.774Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 322,
     "agent_docs_stubbed": 22,
-    "functional_verbatim": 1410,
+    "functional_verbatim": 1412,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 1754,
-  "tree_sha256": "b6f2413f697c124e4166c36184b7e875a371c45b35f8703f13190354b3533f51",
+  "file_count": 1756,
+  "tree_sha256": "42829db3492386930a68c9936d55f1e7d7895fc1e6194a65e6d659e81be98c05",
   "files": [
     {
       "path": ".claude/skills/blocker-review/SKILL.md",
@@ -172,7 +172,7 @@
     {
       "path": ".claude/skills/idea-triage/SKILL.md",
       "mode": "0000644",
-      "sha256": "c74c93659c4576b32d829ebb2774feb8771125b31b677e070841f4cc25ed0232"
+      "sha256": "b64fe42bb2a542304802b48bea348ae817608ac47f026d98c4de9bea5aa90174"
     },
     {
       "path": ".claude/skills/ideate/SKILL.md",
@@ -4577,12 +4577,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "c7582438fd23701a58ddcc6a35f6b4d0ea388fe47be83d5df29f0e79961a7b6c"
+      "sha256": "5721cb7973d1dc844692348aeb2462d3adfcba9929f7146f6a872c6de15dd710"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "85fdb6e71f1b13ed512137e259e3f6019a2bb71f50b8558db745f609b5f11d00"
+      "sha256": "441e6e4bea0f538d4c0e63eb17cee0f65077775be47c930b8876cb022bc0966b"
     },
     {
       "path": "public-docs/index.html",
@@ -5572,7 +5572,7 @@
     {
       "path": "scripts/gds/render-ideas.js",
       "mode": "0000644",
-      "sha256": "55dd4f844b1a4b2b898731f4d6c9fb03676037a10cc42473a67d0214b2aadabd"
+      "sha256": "3f72b5fb4740550965da5417de7bb83464a26f59edabe4bd52e14f50499cc5ee"
     },
     {
       "path": "scripts/gds/repo-metrics.js",
@@ -5847,7 +5847,7 @@
     {
       "path": "scripts/gds/triage.js",
       "mode": "0000644",
-      "sha256": "1c43db4e69ff4966addd91314638b3b2a0c3f7c91f832f09e4a162e5fd0789aa"
+      "sha256": "5255bafa71699cadd345c5bb2ba6e99700cdd5d90fd165b949ef6595c5a83386"
     },
     {
       "path": "scripts/gds/update-channel.js",
@@ -6237,7 +6237,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "f40f5b93ecdce691250c1d263c9e68d6bd9b06a93ce2a3e3ef70520faad961b9"
+      "sha256": "dcb27806a84ffee473f8e69ca78530535b7d7c51e30780e09982ba8489768f9c"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -7609,6 +7609,16 @@
       "mode": "0000644",
       "sha256": "836ee90dd24736c84fede53394d0d724915f73540c9b99c41762da1d37c447b2"
     },
+    {
+      "path": "tests/idea_triage_grade.mjs",
+      "mode": "0000644",
+      "sha256": "4e75030cf2320c2715c5e764394e9d56f66861712176261c878bc99183622b69"
+    },
+    {
+      "path": "tests/idea_triage_recommends.mjs",
+      "mode": "0000644",
+      "sha256": "c7ba20839a7b33df0eb7e8bfc2f463217e7d3a538d888e89774107d55d34556d"
+    },
     {
       "path": "tests/idp_device_exchange.mjs",
       "mode": "0000644",

package/.claude/skills/idea-triage/SKILL.md

@@ -72,6 +72,25 @@ walk interactively instead.)
 
 If `open_count` is 0, print "inbox empty — nothing to triage today" and exit.
 
+**Read the GRADE on every row, and walk in two groups** (task 1002924 / BV1.R148).
+Each idea carries `grade` (`quick` | `spark` | `full`) and, for a Full Idea, a
+`completeness_score` out of 100. The grade decides what kind of verdict the idea
+even needs, so it is the first thing to read, not a detail:
+
+| Grade | What it is | What triage does with it |
+|---|---|---|
+| `full` | five answered fields, scored | **Do not auto-convert.** Reason about the right shape — a goal, a task, or a merge — and *recommend* it (that is R149's rule; an ideator often lacks the full picture). |
+| `spark` | a quick idea its **author** offered up for development | Leave it for someone to develop — it is already in the spark queue at `/builders/ideas`. Promoting it discards the author's invitation. |
+| `quick` | a thought filed fast | Promotes straight to a task, as it always did. |
+
+Walk **Full Ideas first, best-formed first (highest completeness), then quick
+ideas and sparks newest-first.** Two runs, not one list sorted by score: a single
+score-sorted list puts every unscored idea after every scored one, and in a long
+inbox nobody reaches them. `node scripts/gds/triage.js` already walks in exactly
+this order and prints the grade on each card, and `render-ideas.js` renders the
+same two sections — so the interactive walk, the generated file and this skill all
+show the same idea the same way.
+
 **Step 1.5 — develop the open ideas in parallel (task 930).**
 
 **Before spawning any subagents, run a cheap staleness pass over the list first** — a quick skim of each idea's title/body against the current codebase/CLAUDE.md to catch ideas that are already implemented, already superseded, or otherwise obviously stale. A recent triage found 47 of 170 open ideas already stale; filtering those out first means the expensive multi-agent development pass below is only spent on ideas that still need it.
@@ -115,6 +134,54 @@ Then ask the user (concise prompt — Lars is an EE, not a software engineer; fr
 
 > Idea #N: "{title}". {one-sentence developed summary}. **Open questions:** {the subagent's open_questions}. **Promote, discard, or merge with another idea?**
 
+**Step 2.5 — for a FULL IDEA, work out its SHAPE and recommend one (task 1002925 / BV1.R149).**
+
+Only for `grade='full'`. A quick idea promotes straight to a task — that is what a
+quick idea is *for* — and a spark is not yours to convert at all (its author
+offered it up for development, and promoting it discards that invitation).
+
+**Why this step exists, in the owner's words:** *for ideators it is hard to say
+what is a task or a goal, because it is often hard to have the full picture.* So a
+Full Idea gets **thought about** at triage instead of being forced down a fixed
+path. The person who wrote it was not required to know whether it was one task or
+a quarter of work; that is the judgement triage adds.
+
+**Three shapes it can take.** Read the five answers — especially *how does it fit*
+— and decide which one it actually is:
+
+| Shape | It looks like this | What you would create |
+|---|---|---|
+| **Goal** | several distinct pieces of work, or an outcome you would measure rather than finish; the "big picture" answer names more than one surface | a goal, plus **draft done-when criteria** taken from what the idea says "done" means |
+| **Task** | one concrete change with an obvious end | a single task in whatever goal already owns that area |
+| **Merge** | work that already exists — an open goal, a live task, or another idea says the same thing | nothing; point it at the existing record |
+
+**Do the legwork before recommending.** A recommendation with nothing behind it is
+worse than no recommendation, because it looks like an answer. Run
+`/recall <the idea's subject>`, check the goal board
+(`node scripts/gds/goal.js list`), and look for an existing task before proposing
+anything new — "merge" is the recommendation people skip, and it is often the right
+one.
+
+**Then RECOMMEND, and show the reasoning.** Say which shape and *why*, name the
+alternative you rejected and why, and — for a goal — sketch the criteria you would
+draft. One short paragraph, not a report:
+
+> Idea #N (Full, 84/100) — **I'd make this a goal.** Its "big picture" answer names
+> three separate surfaces (the CLI, the hall, and the Discord mirror), so a single
+> task would either be a month long or quietly deliver only one of them. Draft
+> criteria: *(1) the CLI can do X; (2) the same is reachable in the hall; (3) the
+> Discord path stops needing the old flag.* I considered a task in goal 1000071
+> since the routing work overlaps, but this outlives that goal's scope.
+> **Goal, task, or merge?**
+
+**NOTHING CONVERTS UNTIL THEY ANSWER.** The recommendation is a recommendation:
+do not create the goal, do not create the task, do not mark the idea promoted
+until the human has chosen. If they pick a different shape than you recommended,
+that is the step working — build what they chose, not what you argued for. (The
+server backs this up at the capture end: a Full Idea never auto-routes,
+`full_idea_never_routes` in `modules/ideas/routing.js`. This step is the same rule
+at the triage end, where the judgement is.)
+
 **Step 3 — apply the verdict.**
 
 **Promote → pick the tier (BV1.R64 / ADR 0086).** An idea no longer only becomes a *task* — it can promote into any tier of the work hierarchy: a **goal** (a whole module-scoped workspace), a **criterion** (a new done-when test), or a **task** (a single unit of work). Choose by the idea's size: a broad objective → goal; a "we should also require X to be done" → criterion; a concrete piece of work → task. Frame the choice to the user in those terms, then create the right record and mark the idea promoted.

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.301",
+  "version": "1.19.303",
   "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/scripts/gds/render-ideas.js

@@ -51,12 +51,29 @@ function daysAgo(iso) {
   return ms / (1000 * 60 * 60 * 24);
 }
 
+// The grade, in words, for a triage surface (task 1002924 / BV1.R148). An idea
+// with no ideas_grades row reads as 'quick' — the R140 absence-is-quick design —
+// so a missing grade is a real answer here, not a gap to hide.
+function gradeLabel(idea) {
+  const g = idea.grade || 'quick';
+  if (g === 'full') {
+    const s = idea.completeness_score;
+    return Number.isInteger(s) ? `FULL ${s}/100` : 'FULL (unscored)';
+  }
+  if (g === 'spark') return 'SPARK — awaiting development';
+  return 'quick';
+}
+
 function renderIdea(idea) {
   const lines = [];
   const titleSuffix = idea.kind ? ` _(${idea.kind})_` : '';
   lines.push(`### #${idea.id} — ${idea.title}${titleSuffix}`);
   lines.push('');
   const meta = [];
+  // FIRST in the meta run, deliberately: the grade decides what kind of verdict
+  // this idea even needs (a Full Idea gets a recommended shape, R149; a quick one
+  // promotes straight to a task), so it is the first thing a triager should read.
+  meta.push(`**${gradeLabel(idea)}**`);
   meta.push(`captured ${fmtTimestamp(idea.captured_at)}`);
   if (idea.reviewed_at) meta.push(`reviewed ${fmtTimestamp(idea.reviewed_at)}`);
   if (idea.suggested_version) meta.push(`suggested → ${idea.suggested_version}`);
@@ -96,6 +113,17 @@ async function fetchAllIdeas() {
   return data.ideas || [];
 }
 
+// Full ideas rank by how completely they were answered; everything else by
+// recency. Kept as one comparator per bucket rather than one clever composite:
+// mixing a 0-100 score and a timestamp into a single ordering is how a quick idea
+// ends up sorted by a number it does not have.
+const byCompletenessDesc = (a, b) => {
+  const sa = Number.isInteger(a.completeness_score) ? a.completeness_score : -1;
+  const sb = Number.isInteger(b.completeness_score) ? b.completeness_score : -1;
+  if (sa !== sb) return sb - sa;
+  return new Date(b.captured_at).getTime() - new Date(a.captured_at).getTime();
+};
+
 function partition(ideas) {
   const open = [];
   const promoted = [];
@@ -116,24 +144,41 @@ function partition(ideas) {
   // Newest first within each bucket.
   const byCapturedDesc = (a, b) =>
     new Date(b.captured_at).getTime() - new Date(a.captured_at).getTime();
-  open.sort(byCapturedDesc);
   promoted.sort(byCapturedDesc);
   discarded.sort(byCapturedDesc);
   merged.sort(byCapturedDesc);
-  return { open, promoted, discarded, merged };
+
+  // TWO OPEN SECTIONS, NOT ONE SORTED LIST (task 1002924 / R148). The done-when
+  // wants full ideas ordered by completeness AND quick ideas and sparks still
+  // visible rather than buried under scored ideas — and a single list sorted by
+  // score cannot do both: every unscored idea lands after every scored one, which
+  // for a long inbox means nobody ever reads them. Two labelled runs give each
+  // kind its own ordering and its own top.
+  const openFull = open.filter((i) => (i.grade || 'quick') === 'full').sort(byCompletenessDesc);
+  const openRest = open.filter((i) => (i.grade || 'quick') !== 'full').sort(byCapturedDesc);
+  return { open, openFull, openRest, promoted, discarded, merged };
 }
 
 function render(ideas) {
-  const { open, promoted, discarded, merged } = partition(ideas);
+  const { open, openFull, openRest, promoted, discarded, merged } = partition(ideas);
   const renderedAt = new Date().toISOString().replace('T', ' ').slice(0, 16) + ' UTC';
 
   const parts = [
     HEADER,
-    `_Last rendered: ${renderedAt} · ${open.length} open · ${promoted.length} promoted (last ${RECENT_DAYS}d) · ${discarded.length} discarded (last ${RECENT_DAYS}d) · ${merged.length} merged (last ${RECENT_DAYS}d)_`,
+    `_Last rendered: ${renderedAt} · ${open.length} open (${openFull.length} full, ${openRest.length} quick/spark) · ${promoted.length} promoted (last ${RECENT_DAYS}d) · ${discarded.length} discarded (last ${RECENT_DAYS}d) · ${merged.length} merged (last ${RECENT_DAYS}d)_`,
     '',
     '---',
     '',
-    renderSection('Open', open, 'No open ideas. Inbox zero — capture one with /builder-capture.'),
+    renderSection(
+      'Open — Full Ideas (best-formed first)',
+      openFull,
+      'No Full Ideas open. One is written at /builders/ideas, or by developing a spark.'
+    ),
+    renderSection(
+      'Open — quick ideas and sparks (newest first)',
+      openRest,
+      'No quick ideas open. Inbox zero — capture one with node scripts/gds/capture.js.'
+    ),
     renderSection(
       `Recently Promoted (last ${RECENT_DAYS} days)`,
       promoted,
@@ -167,7 +212,15 @@ async function main() {
   console.log(`Wrote ${OUT_PATH} (${ideas.length} idea${ideas.length === 1 ? '' : 's'} fetched)`);
 }
 
-main().catch((err) => {
-  console.error(err.stack || err.message || err);
-  process.exit(1);
-});
+// Exported so the R148 ordering + grade label are unit-testable without a
+// session or the network — they are the whole substance of this file now, and the
+// pure functions are the right seam. Guarded main(), the capture.js pattern:
+// without it a require() for the test would run the renderer.
+module.exports = { gradeLabel, partition };
+
+if (require.main === module) {
+  main().catch((err) => {
+    console.error(err.stack || err.message || err);
+    process.exit(1);
+  });
+}

package/scripts/gds/triage.js

@@ -243,10 +243,19 @@ async function createTask({ versionId, title, description, priority, sourceRef,
   return r.data?.task;
 }
 
+// The grade, spelled out (task 1002924 / BV1.R148). Reused from render-ideas.js
+// rather than restated so the two triage surfaces cannot describe the same idea
+// differently — the whole point of a grade at a glance is that it reads the same
+// everywhere.
+const { gradeLabel } = require('./render-ideas');
+
 function printIdea(idea, idx, total) {
   const sep = '─'.repeat(72);
   console.log(`\n${sep}`);
-  console.log(`Idea ${idx + 1}/${total}  #${idea.id}  kind=${idea.kind || '—'}  suggested_version=${idea.suggested_version || '—'}  priority=${idea.suggested_priority ?? '—'}`);
+  // The grade leads the line: it decides what kind of verdict this idea needs at
+  // all (a Full Idea gets a recommended shape — R149; a quick one promotes
+  // straight to a task), so a triager should not have to hunt for it.
+  console.log(`Idea ${idx + 1}/${total}  #${idea.id}  [${gradeLabel(idea)}]  kind=${idea.kind || '—'}  suggested_version=${idea.suggested_version || '—'}  priority=${idea.suggested_priority ?? '—'}`);
   console.log(`Captured: ${idea.captured_at}  by builder #${idea.captured_by ?? '—'}`);
   console.log(`Title:    ${idea.title}`);
   if (idea.body_md && idea.body_md.trim()) {
@@ -280,7 +289,15 @@ async function main() {
     process.exit(0);
   }
 
-  console.log(`📥 ${ideas.length} open idea${ideas.length === 1 ? '' : 's'} to triage.`);
+  // WALK ORDER (task 1002924 / R148): Full Ideas first, best-formed first, then
+  // quick ideas and sparks newest-first. Two runs rather than one score-sorted
+  // list, for the reason render-ideas.js records: a single list sorted by score
+  // puts every unscored idea after every scored one, and in a long inbox nobody
+  // reaches them. Grouping gives each kind its own top.
+  const { partition } = require('./render-ideas');
+  const grouped = partition(ideas);
+  ideas = grouped.openFull.concat(grouped.openRest);
+  console.log(`📥 ${ideas.length} open idea${ideas.length === 1 ? '' : 's'} to triage — ${grouped.openFull.length} Full Idea${grouped.openFull.length === 1 ? '' : 's'} first (best-formed first), then ${grouped.openRest.length} quick/spark (newest first).`);
 
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   const summary = { promoted: 0, discarded: 0, merged: 0, skipped: 0 };

package/src/module-api.js

@@ -1029,8 +1029,12 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 //         landed since 1.19.299 with no explicit bump. run 32601521458. (task 1002620)
 //   1.19.301 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
 //         landed since 1.19.300 with no explicit bump. run 32602146266. (task 1002620)
+//   1.19.302 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.301 with no explicit bump. run 32604538465. (task 1002620)
+//   1.19.303 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.302 with no explicit bump. run 32605477232. (task 1002620)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.301'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.303'; // CI auto-patch carrier (ADR 0161); see changelog above
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/idea_triage_grade.mjs

@@ -0,0 +1,167 @@
+// tests/idea_triage_grade.mjs
+//
+// task 1002924 (BV1.R148, goal 1000062) — the grade on the triage surfaces, and
+// the ordering.
+//
+// The done-when has three clauses and the THIRD is the one with a trap in it:
+//   1. each idea in triage shows its grade at a glance;
+//   2. full ideas sort by completeness;
+//   3. quick ideas and sparks remain visible rather than being buried under
+//      scored ideas.
+//
+// (2) and (3) cannot both be satisfied by one list sorted on completeness: every
+// unscored idea lands after every scored one, so in a long inbox nobody reaches
+// them. The answer is two ordered groups, and that is what these assertions pin —
+// including that the group split is on GRADE and not on "has a score", which
+// would misfile an unscored Full Idea.
+//
+// Pure require of the two exported helpers; no session, no network.
+//
+// Run:  node tests/idea_triage_grade.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const { gradeLabel, partition } = require('../scripts/gds/render-ideas.js');
+
+const open = (o) => ({ status: 'open', captured_at: '2026-08-01T00:00:00Z', ...o });
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+// --- (1) the grade at a glance ------------------------------------------
+
+test('a Full Idea shows its grade AND its score', () => {
+  assert.equal(gradeLabel({ grade: 'full', completeness_score: 88 }), 'FULL 88/100');
+});
+
+test('a Full Idea with no score says unscored rather than implying zero', () => {
+  // R142 returns null for anything it cannot score, and that is a legal stored
+  // state — "unscorable" and "not yet scored" deliberately look the same.
+  assert.equal(gradeLabel({ grade: 'full', completeness_score: null }), 'FULL (unscored)');
+  assert.doesNotMatch(gradeLabel({ grade: 'full', completeness_score: null }), /0/);
+});
+
+test('a spark says what it is waiting for', () => {
+  assert.match(gradeLabel({ grade: 'spark' }), /awaiting development/);
+});
+
+test('a missing grade reads as quick — the R140 absence-is-quick design', () => {
+  // Not a gap to hide: an idea with no ideas_grades row IS quick.
+  assert.equal(gradeLabel({}), 'quick');
+  assert.equal(gradeLabel({ grade: null }), 'quick');
+});
+
+// --- (2) full ideas sort by completeness --------------------------------
+
+test('Full Ideas are ordered best-formed first', () => {
+  const g = partition([
+    open({ id: 1, grade: 'full', completeness_score: 40 }),
+    open({ id: 2, grade: 'full', completeness_score: 95 }),
+    open({ id: 3, grade: 'full', completeness_score: 70 }),
+  ]);
+  assert.deepEqual(g.openFull.map((i) => i.id), [2, 3, 1]);
+});
+
+test('ties among Full Ideas fall back to recency, so the order is stable', () => {
+  const g = partition([
+    open({ id: 1, grade: 'full', completeness_score: 70, captured_at: '2026-07-01T00:00:00Z' }),
+    open({ id: 2, grade: 'full', completeness_score: 70, captured_at: '2026-08-01T00:00:00Z' }),
+  ]);
+  assert.deepEqual(g.openFull.map((i) => i.id), [2, 1]);
+});
+
+test('an UNSCORED Full Idea sorts last among full ideas, but stays a full idea', () => {
+  // The split is on GRADE, not on "has a score" — filing it with the quick ideas
+  // would hide a five-field idea from the group a triager reads for five-field
+  // ideas, purely because the scorer could not score it.
+  const g = partition([
+    open({ id: 1, grade: 'full', completeness_score: null }),
+    open({ id: 2, grade: 'full', completeness_score: 10 }),
+  ]);
+  assert.deepEqual(g.openFull.map((i) => i.id), [2, 1]);
+  assert.equal(g.openRest.length, 0);
+});
+
+// --- (3) quick ideas and sparks are NOT buried --------------------------
+
+test('quick ideas and sparks get their OWN group, newest first', () => {
+  const g = partition([
+    open({ id: 1, grade: 'quick', captured_at: '2026-07-01T00:00:00Z' }),
+    open({ id: 2, grade: 'spark', captured_at: '2026-08-10T00:00:00Z' }),
+    open({ id: 3, captured_at: '2026-08-05T00:00:00Z' }),
+  ]);
+  assert.deepEqual(g.openRest.map((i) => i.id), [2, 3, 1]);
+  assert.equal(g.openFull.length, 0);
+});
+
+test('a quick idea is NEVER pushed behind scored ideas — it has its own top', () => {
+  // The trap the done-when names. With one score-sorted list, id 99 would be
+  // 50th; in its own group it is first.
+  const many = Array.from({ length: 49 }, (_, i) => open({ id: i + 1, grade: 'full', completeness_score: 50 + (i % 40) }));
+  const g = partition([...many, open({ id: 99, grade: 'quick', captured_at: '2026-08-20T00:00:00Z' })]);
+  assert.equal(g.openRest[0].id, 99, 'first in its own group, not last in a merged one');
+  assert.equal(g.openFull.length, 49);
+});
+
+test('every open idea lands in exactly one group — none is dropped', () => {
+  const ideas = [
+    open({ id: 1, grade: 'full', completeness_score: 80 }),
+    open({ id: 2, grade: 'spark' }),
+    open({ id: 3, grade: 'quick' }),
+    open({ id: 4 }),
+    open({ id: 5, grade: 'full', completeness_score: null }),
+  ];
+  const g = partition(ideas);
+  const seen = [...g.openFull, ...g.openRest].map((i) => i.id).sort((a, b) => a - b);
+  assert.deepEqual(seen, [1, 2, 3, 4, 5]);
+  assert.equal(g.open.length, 5, 'the undivided open list is still returned for the count');
+});
+
+test('a non-open idea is not in either open group', () => {
+  const g = partition([
+    open({ id: 1, grade: 'full', completeness_score: 90 }),
+    { id: 2, status: 'discarded', grade: 'full', completeness_score: 99, captured_at: new Date().toISOString() },
+  ]);
+  assert.deepEqual(g.openFull.map((i) => i.id), [1]);
+  assert.ok(!g.openRest.some((i) => i.id === 2));
+});
+
+// --- the surfaces agree --------------------------------------------------
+
+test('the interactive walk and the generated file share ONE grade label', () => {
+  // Two triage surfaces describing the same idea differently defeats the point of
+  // a grade at a glance, so triage.js imports the label rather than restating it.
+  const triage = fs.readFileSync(path.join(ROOT, 'scripts/gds/triage.js'), 'utf8');
+  assert.match(triage, /require\('\.\/render-ideas'\)/, 'triage.js imports the shared helpers');
+  assert.match(triage, /gradeLabel\(idea\)/, 'and prints the shared label on each card');
+  assert.ok(!/FULL \$\{|SPARK —/.test(triage), 'triage.js does not restate the label text');
+});
+
+test('the walk is ordered by the shared partition, not re-sorted locally', () => {
+  const triage = fs.readFileSync(path.join(ROOT, 'scripts/gds/triage.js'), 'utf8');
+  assert.match(triage, /partition\(ideas\)/);
+  assert.match(triage, /openFull\.concat\(grouped\.openRest\)/, 'full ideas first, then the rest');
+});
+
+test('the skill documents the grade and the two-group walk', () => {
+  const skill = fs.readFileSync(path.join(ROOT, '.claude/skills/idea-triage/SKILL.md'), 'utf8');
+  assert.match(skill, /completeness_score/);
+  assert.match(skill, /Full Ideas first, best-formed first/);
+  // And it must carry the REASON, not just the instruction — the next person to
+  // "simplify" this into one sorted list needs to know why it is two.
+  assert.match(skill, /nobody reaches them/);
+  assert.match(skill, /Do not auto-convert/, 'and R149\'s rule for a Full Idea');
+});
+
+console.log(`\nidea_triage_grade: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/tests/idea_triage_recommends.mjs

@@ -0,0 +1,155 @@
+// tests/idea_triage_recommends.mjs
+//
+// task 1002925 (BV1.R149, goal 1000062) — a Full Idea's SHAPE is recommended, not
+// decided for the builder.
+//
+// The done-when: "triage presents a recommendation plus its reasoning; the human
+// decides; nothing converts without that decision."
+//
+// Two halves, and they live in different places:
+//   • the SERVER half already exists and is enforced — a Full Idea never
+//     auto-routes at capture (routing.js). This file re-asserts it, because R149's
+//     rule is meaningless if the row can convert itself before triage ever sees
+//     it, and an invariant relied on by a prompt should be pinned next to that
+//     prompt's test too.
+//   • the TRIAGE half is a prompt, so what is checkable is the CONTRACT: a
+//     recommendation is required to carry reasoning, the three shapes are named,
+//     the legwork is required before recommending, and nothing converts until the
+//     human answers.
+//
+// Prose assertions run against a whitespace-normalised copy — markdown is
+// hard-wrapped, and a phrase worth asserting will straddle a newline.
+//
+// Run:  node tests/idea_triage_recommends.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const SKILL = fs.readFileSync(path.join(ROOT, '.claude/skills/idea-triage/SKILL.md'), 'utf8');
+const NORM = SKILL.replace(/\s+/g, ' ');
+const { decideLanding } = require('../modules/ideas/routing.js');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+// --- the server half: it cannot convert itself before triage looks -------
+
+test('a Full Idea never auto-routes, whatever else is true of it', () => {
+  // R149's whole premise is that a human judges the shape. If capture-time
+  // routing could turn a Full Idea into a task, that judgement would arrive too
+  // late to matter.
+  for (const grade of ['full', 'FULL', 'Full']) {
+    const d = decideLanding({ goalId: 1000062, kind: 'feature', grade, filerRank: 'archon' });
+    assert.equal(d.route, false, `grade ${grade}`);
+    assert.equal(d.reason, 'full_idea_never_routes');
+  }
+});
+
+test('and a quick idea still routes — R149 is not a brake on everything', () => {
+  // The contrast is the point: quick ideas promoting straight through is what a
+  // quick idea is FOR, and slowing that down would be a regression dressed as care.
+  const d = decideLanding({ goalId: 1000062, kind: 'bug', grade: 'quick', filerRank: 'archon' });
+  assert.equal(d.route, true);
+});
+
+// --- the triage half: recommend, with reasoning --------------------------
+
+test('the step is scoped to a Full Idea, and says what the other grades do', () => {
+  assert.match(NORM, /Only for `grade='full'`/);
+  assert.match(NORM, /quick idea promotes straight to a task/);
+  // A spark is not triage's to convert: promoting it discards its author's offer.
+  assert.match(NORM, /discards that invitation/);
+});
+
+test('it carries the owner\'s REASON, not just the instruction', () => {
+  // Without the why, "recommend instead of convert" reads as ceremony and gets
+  // optimised away by the next person trying to make triage faster.
+  assert.match(NORM, /hard to say what is a task or a goal/);
+  assert.match(NORM, /full picture/);
+});
+
+test('all three shapes are named — including MERGE', () => {
+  assert.match(NORM, /\*\*Goal\*\*/);
+  assert.match(NORM, /\*\*Task\*\*/);
+  assert.match(NORM, /\*\*Merge\*\*/);
+  // Merge is the one people skip, and it is often right.
+  assert.match(NORM, /"merge" is the recommendation people skip/);
+});
+
+test('a goal recommendation drafts criteria rather than just naming the tier', () => {
+  assert.match(NORM, /draft.{0,4}done-when criteria/i);
+});
+
+test('the legwork is REQUIRED before recommending', () => {
+  // A recommendation with nothing behind it is worse than none, because it looks
+  // like an answer.
+  assert.match(NORM, /worse than no recommendation/);
+  assert.match(NORM, /\/recall/);
+  assert.match(NORM, /goal\.js list/);
+});
+
+test('the reasoning must include the REJECTED alternative', () => {
+  // "I recommend a goal" is an assertion; "a task would deliver only one of the
+  // three surfaces" is a reason someone can disagree with.
+  assert.match(NORM, /name the alternative you rejected/i);
+});
+
+// --- nothing converts without the human ---------------------------------
+
+test('the no-convert rule is stated absolutely, and enumerated', () => {
+  assert.match(NORM, /NOTHING CONVERTS UNTIL THEY ANSWER/);
+  // Enumerated because "do not convert" is vague about the three separate writes
+  // an eager agent might make.
+  assert.match(NORM, /do not create the goal, do not create the task, do not mark the idea promoted/);
+});
+
+test('a human choosing differently is framed as the step WORKING', () => {
+  // Otherwise the recommendation becomes something to defend, and the next turn
+  // is an argument instead of a build.
+  assert.match(NORM, /that is the step working/);
+  assert.match(NORM, /build what they chose, not what you argued for/);
+});
+
+test('it names the server invariant it leans on', () => {
+  // So the next reader knows the two halves are one rule in two places, and does
+  // not "simplify" either half away believing the other covers it.
+  assert.match(NORM, /full_idea_never_routes/);
+});
+
+// --- it does not restate the template ----------------------------------
+
+test('the skill restates no field label, and no key as a code identifier', () => {
+  const { BASE_TEMPLATE } = require('../modules/ideas/templates.js');
+  // LABELS are checked over the whole file: they are distinctive canonical
+  // question text, so any occurrence is a restatement.
+  for (const f of BASE_TEMPLATE.fields) {
+    assert.ok(!SKILL.includes(f.label), `restates the label "${f.label}"`);
+  }
+  // KEYS are checked only inside CODE — backticks and fenced blocks. One of them
+  // is `fit`, an ordinary English word, and this skill legitimately says "how does
+  // it fit" in prose. What would actually be a forked template is a key written as
+  // an identifier: a hard-coded field list, a JSON example, a payload sketch. So
+  // the assertion follows the meaning rather than the substring.
+  const code = [
+    ...[...SKILL.matchAll(/```[\s\S]*?```/g)].map((m) => m[0]),
+    ...[...SKILL.matchAll(/`([^`\n]+)`/g)].map((m) => m[1]),
+  ].join('\n');
+  for (const f of BASE_TEMPLATE.fields) {
+    assert.ok(
+      !new RegExp(`\\b${f.key}\\b`).test(code),
+      `the key "${f.key}" appears as a code identifier — the template is being restated`,
+    );
+  }
+});
+
+console.log(`\nidea_triage_recommends: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);