@bongos/core 1.19.301 → 1.19.302

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.302",
+  "core_contract": "1.19.302",
+  "source_commit": "d2bc099b7707a0e3e29c2b48b796bc95785d7c74",
   "source_ref": "HEAD",
-  "built_at": "2026-08-22T22:20:55.084Z",
+  "built_at": "2026-08-22T23:12:06.332Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 322,
     "agent_docs_stubbed": 22,
-    "functional_verbatim": 1410,
+    "functional_verbatim": 1411,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 1754,
-  "tree_sha256": "b6f2413f697c124e4166c36184b7e875a371c45b35f8703f13190354b3533f51",
+  "file_count": 1755,
+  "tree_sha256": "f1bb517fc8d0b3ac176f07c721aaa32bec280b6937905b78fdde9966e084d99e",
   "files": [
     {
       "path": ".claude/skills/blocker-review/SKILL.md",
@@ -172,7 +172,7 @@
     {
       "path": ".claude/skills/idea-triage/SKILL.md",
       "mode": "0000644",
-      "sha256": "c74c93659c4576b32d829ebb2774feb8771125b31b677e070841f4cc25ed0232"
+      "sha256": "cbecde1c3fe60e02e6b008b80232e8866d7924aaefa9614377044dce5973d1d0"
     },
     {
       "path": ".claude/skills/ideate/SKILL.md",
@@ -4577,12 +4577,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "c7582438fd23701a58ddcc6a35f6b4d0ea388fe47be83d5df29f0e79961a7b6c"
+      "sha256": "06de1a2274d6eafe7a544b7e0c1f157b42191eb0ad151d6e7f821180604d74bb"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "85fdb6e71f1b13ed512137e259e3f6019a2bb71f50b8558db745f609b5f11d00"
+      "sha256": "45ca3b2302b14730ce004fdc64f37ab82cc0dc85518c55c4c3119b85851ddf20"
     },
     {
       "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": "938f69ad6350189382990706f63b41c1781f9c7b19610d7275144152c65412d7"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -7609,6 +7609,11 @@
       "mode": "0000644",
       "sha256": "836ee90dd24736c84fede53394d0d724915f73540c9b99c41762da1d37c447b2"
     },
+    {
+      "path": "tests/idea_triage_grade.mjs",
+      "mode": "0000644",
+      "sha256": "4e75030cf2320c2715c5e764394e9d56f66861712176261c878bc99183622b69"
+    },
     {
       "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.

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.301",
+  "version": "1.19.302",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.301",
+      "version": "1.19.302",
       "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.302",
   "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,10 @@ 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)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.301'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.302'; // 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);