@bongos/core 1.19.161 → 1.19.163

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.161",
-  "core_contract": "1.19.161",
-  "source_commit": "206359b5cf85472d7b4def6050a2766f001569ea",
+  "core_version": "1.19.163",
+  "core_contract": "1.19.163",
+  "source_commit": "cf29eabb9874ecd380580fa762e09cf7ab412a1e",
   "source_ref": "HEAD",
-  "built_at": "2026-08-16T16:41:02.340Z",
+  "built_at": "2026-08-16T16:52:34.284Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 305,
     "agent_docs_stubbed": 21,
-    "functional_verbatim": 1259,
+    "functional_verbatim": 1262,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 1585,
-  "tree_sha256": "67b93c7d90a238fa234b0e809aee4545bf5190f1cd5f86513a294c4adb4244db",
+  "file_count": 1588,
+  "tree_sha256": "5c874eb035676d192575fc9366d0ddb5dac5a4af849f8c7034694ddb591d421c",
   "files": [
     {
       "path": ".claude/skills/blocker-review/SKILL.md",
@@ -2662,7 +2662,7 @@
     {
       "path": "modules/dev-box/app/src/vendor/bongos-client.cjs",
       "mode": "0000644",
-      "sha256": "2c199a1ad61c8ca8a015b0918368da4c3bf4a8e6196edfd46b93048dda8e9eb5"
+      "sha256": "257ac54c66f7969090065a34c29e2874fa6f9d111b6e75f0510ab1a2fcb3ef17"
     },
     {
       "path": "modules/dev-box/app/test/unit.mjs",
@@ -3454,6 +3454,11 @@
       "mode": "0000644",
       "sha256": "73349f0209190305a61e2f4d771fa466c12be4f9034b4134b60a9e4a560e1c5a"
     },
+    {
+      "path": "modules/ideas/completeness.js",
+      "mode": "0000644",
+      "sha256": "84d977372c79a46f8481176b7cdc740cbaca9480af3464b7b66183aad6d6e180"
+    },
     {
       "path": "modules/ideas/inbox.js",
       "mode": "0000644",
@@ -4197,12 +4202,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "8bd2f7c052801d8b86e46c98ea962ecb4b23164a82ae96282e9789fb64da10c9"
+      "sha256": "572ae700360b73fdbc62135f01397fd335bcb5a735d113962a8343377672268c"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "113553d6b43e63c5c34c77934179cb762626a81c13d63865e02de74c8c361633"
+      "sha256": "1460066c89ad9a7db9dc62ae0b6766c5e11cc18d8268fb95a4ae8767325569c5"
     },
     {
       "path": "public-docs/index.html",
@@ -5797,7 +5802,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "9c0be130573a1045b0a96d8db4b8ede624b304cdb5095c209fbec1c9c0d1248c"
+      "sha256": "4e7edb74be33ea3e2b126dadb6a51dce083c4df6eb8c0521c0c7f484997edbe4"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -6904,11 +6909,21 @@
       "mode": "0000644",
       "sha256": "7d384cd84cdc93b8e7b57df291a4600a40f43346fd2a52168324ecde219f1388"
     },
+    {
+      "path": "tests/idea_completeness.mjs",
+      "mode": "0000644",
+      "sha256": "e7b6af463185ea77f40d62408026c55c7fb077f18999b972564b3b5bc7656ca5"
+    },
     {
       "path": "tests/idea_grades.mjs",
       "mode": "0000644",
       "sha256": "07cacc97990f0e775342f8b30171c87128e0acb1abd38d64c683c3f257927ebd"
     },
+    {
+      "path": "tests/idea_quick_guard.mjs",
+      "mode": "0000644",
+      "sha256": "9be4414bbbbb92513a7737d4494265b24c5f5db71a67e840016cc275442df1fb"
+    },
     {
       "path": "tests/idea_templates.mjs",
       "mode": "0000644",

package/modules/dev-box/app/src/vendor/bongos-client.cjs

@@ -354,6 +354,8 @@ function createClient(opts = {}) {
       deleteGovernanceRolesRoleKeyPermissionsPermissionKey: (args) => request("DELETE", "/governance/roles/{roleKey}/permissions/{permissionKey}", { hasBody: false }, args),
       // PUT /governance/roles/{roleKey}/permissions/{permissionKey} — rank: archon — PUT /governance/roles/:roleKey/permissions/:permissionKey
       putGovernanceRolesRoleKeyPermissionsPermissionKey: (args) => request("PUT", "/governance/roles/{roleKey}/permissions/{permissionKey}", { hasBody: true }, args),
+      // POST /governance/roles/{roleKey}/reset — rank: archon — POST /governance/roles/:roleKey/reset
+      postGovernanceRolesRoleKeyReset: (args) => request("POST", "/governance/roles/{roleKey}/reset", { hasBody: true }, args),
     },
     "grades": {
       // GET /grades/by-builder — rank: metic+archon — GET /grades/by-builder

package/modules/ideas/completeness.js

@@ -0,0 +1,72 @@
+// modules/ideas/completeness.js — the deterministic Full Idea completeness
+// scorer (task 1002918, BV1.R142, goal 1000062).
+//
+// WHY DETERMINISTIC (the owner's call, recorded on the goal): the score feeds
+// karma (R147), so it must be predictable, free and reproducible — the same
+// input scores the same number on every machine, every day, with no model
+// having a good day. An AI depth-judge is a deliberately LATER seam; nothing
+// here calls a network or reads a clock.
+//
+// WHAT IT MEASURES — PRESENCE + SUBSTANCE, NOTHING SMARTER. It walks the R141
+// template declaration (never five hard-coded names): each declared field
+// contributes equally; a field earns its share in proportion to how much
+// actual text it carries against the template's `substanceMin` floor, capped
+// at 1. "Actual text" is the trimmed, whitespace-collapsed length, so a page
+// of blank lines scores as the nothing it is. That is the whole algorithm —
+// honest about its limit: a determined padder can beat a character counter,
+// and catching THAT is the future AI seam (goal notes), not a cleverness this
+// number should pretend to.
+//
+// NEVER THROWS INTO THE CAPTURE PATH (the task's hard requirement): malformed
+// input — unknown template, non-object values, non-string fields — returns a
+// null score, not an exception. A null completeness_score is a legal stored
+// state (ideas_001_grades.sql: scoring never blocks capture), so "could not
+// score" and "not scored yet" deliberately look the same downstream.
+//
+// The write side already exists (inbox.js setIdeaCompleteness, 0–100 int);
+// capture (R143) computes-and-stores via this module, and the triage ordering
+// (R148) reads the stored number — neither re-implements the arithmetic.
+
+'use strict';
+
+const { templateFor, BUILTIN_TEMPLATES } = require('./templates');
+const { DEFAULT_TEMPLATE_KEY } = require('./inbox');
+
+// The substance of a value: the length of its trimmed, whitespace-collapsed
+// text. Non-strings carry no substance (validation refuses them upstream; the
+// scorer just declines to credit them).
+function substanceOf(value) {
+  if (typeof value !== 'string') return 0;
+  return value.trim().replace(/\s+/g, ' ').length;
+}
+
+// Score field_values against a template. Returns
+//   { score, fields: [{ key, substance, floor, ratio }] }
+// where score is an integer 0–100 (ready for setIdeaCompleteness) or NULL when
+// the input cannot be scored. `fields` is the per-field breakdown in TEMPLATE
+// ORDER (fieldOrder's contract) — the hall's live meter (R152) and the triage
+// view (R148) render it without redoing the arithmetic.
+function scoreFieldValues(fieldValues, { templateKey = DEFAULT_TEMPLATE_KEY, registry = BUILTIN_TEMPLATES } = {}) {
+  const template = templateFor(templateKey, registry);
+  if (!template || !template.fields.length) return { score: null, fields: [] };
+  if (!fieldValues || typeof fieldValues !== 'object' || Array.isArray(fieldValues)) {
+    return { score: null, fields: [] };
+  }
+  const fields = template.fields.map((f) => {
+    const substance = substanceOf(fieldValues[f.key]);
+    const floor = f.substanceMin > 0 ? f.substanceMin : 1;
+    return { key: f.key, substance, floor, ratio: Math.min(1, substance / floor) };
+  });
+  const mean = fields.reduce((sum, f) => sum + f.ratio, 0) / fields.length;
+  return { score: Math.round(mean * 100), fields };
+}
+
+// The one-number convenience for callers that only store: integer 0–100, or
+// null when unscorable. This is what R143's capture writes through
+// setIdeaCompleteness — and because it never throws, the capture path needs no
+// guard around it.
+function completenessScore(fieldValues, opts) {
+  return scoreFieldValues(fieldValues, opts).score;
+}
+
+module.exports = { completenessScore, scoreFieldValues, substanceOf };

package/package-lock.json

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

package/package.json

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

@@ -749,8 +749,12 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 //         landed since 1.19.159 with no explicit bump. run 31959145128. (task 1002620)
 //   1.19.161 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
 //         landed since 1.19.160 with no explicit bump. run 31959299652. (task 1002620)
+//   1.19.162 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.161 with no explicit bump. run 31959496815. (task 1002620)
+//   1.19.163 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.162 with no explicit bump. run 31959864781. (task 1002620)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.161'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.163'; // 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_completeness.mjs

@@ -0,0 +1,98 @@
+// tests/idea_completeness.mjs
+//
+// task 1002918 (BV1.R142, goal 1000062) — the deterministic completeness scorer.
+//
+// The three claims under guard, straight from the task's done-when:
+//   1. SAME INPUT, SAME SCORE — determinism is what lets the number feed karma.
+//   2. The empty / thin / padded / complete shapes score sensibly, with padding
+//      (whitespace, blank lines) earning exactly nothing.
+//   3. IT NEVER THROWS — malformed input is a null score, because scoring must
+//      never block capture (the R140 schema's contract).
+//
+// Pure module, pure tests — no DB, no harness.
+//
+// Run:  node tests/idea_completeness.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const C = require('../modules/ideas/completeness.js');
+const { BASE_TEMPLATE } = require('../modules/ideas/templates.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}`); }
+}
+
+// Five answers comfortably past every substanceMin (40 chars).
+const COMPLETE = Object.fromEntries(
+  BASE_TEMPLATE.fields.map((f) => [f.key, `A real, substantive answer for ${f.key} that clears the declared floor easily.`]),
+);
+
+test('a complete idea scores 100, an empty one 0', () => {
+  assert.equal(C.completenessScore(COMPLETE), 100);
+  assert.equal(C.completenessScore({}), 0);
+});
+
+test('same input, same score — byte-for-byte determinism', () => {
+  const a = C.completenessScore(COMPLETE);
+  for (let i = 0; i < 5; i++) assert.equal(C.completenessScore({ ...COMPLETE }), a);
+  assert.deepEqual(C.scoreFieldValues(COMPLETE), C.scoreFieldValues(COMPLETE));
+});
+
+test('a thin answer earns its proportion, not the full share', () => {
+  const oneThin = { ...COMPLETE, purpose: 'ten chars.' }; // 10 of the 40-char floor
+  const s = C.completenessScore(oneThin);
+  assert.ok(s > 80 && s < 100, `four full + one quarter-credit field ≈ 85, got ${s}`);
+  const breakdown = C.scoreFieldValues(oneThin).fields.find((f) => f.key === 'purpose');
+  assert.equal(breakdown.substance, 10);
+  assert.equal(breakdown.ratio, 0.25);
+});
+
+test('padding earns exactly nothing: whitespace and blank lines are not substance', () => {
+  const padded = { ...COMPLETE, purpose: '   \n\n\t   \n     \n\n        ' };
+  const b = C.scoreFieldValues(padded).fields.find((f) => f.key === 'purpose');
+  assert.equal(b.substance, 0, 'a page of blank lines is the nothing it is');
+  const spaced = { ...COMPLETE, purpose: 'a    b\n\n\nc         d e' }; // collapses to 9
+  const b2 = C.scoreFieldValues(spaced).fields.find((f) => f.key === 'purpose');
+  assert.equal(b2.substance, 9, 'runs of whitespace collapse to one');
+});
+
+test('one missing field costs exactly its equal share', () => {
+  const { fit, ...four } = COMPLETE;
+  assert.equal(C.completenessScore(four), 80, 'five equal fields: one absent = -20');
+});
+
+test('the breakdown comes back in TEMPLATE order, ready to render', () => {
+  const keys = C.scoreFieldValues(COMPLETE).fields.map((f) => f.key);
+  assert.deepEqual(keys, ['purpose', 'big_picture', 'why_had', 'why_matters', 'fit']);
+});
+
+test('it never throws: malformed input is a null score, not an exception', () => {
+  for (const bad of [null, undefined, [], 'a string', 42]) {
+    assert.equal(C.completenessScore(bad), null, `completenessScore(${JSON.stringify(bad)})`);
+  }
+  assert.equal(C.completenessScore(COMPLETE, { templateKey: 'no-such-template' }), null);
+  // a non-string FIELD does not throw either — it just earns nothing
+  assert.equal(typeof C.completenessScore({ ...COMPLETE, purpose: 42 }), 'number');
+});
+
+test('the scorer walks the declaration — a different template scores by ITS fields', () => {
+  const registry = {
+    'two-v1': { key: 'two-v1', label: 'Two', fields: [
+      { key: 'a', label: 'A', required: true, substanceMin: 10 },
+      { key: 'b', label: 'B', required: true, substanceMin: 10 },
+    ] },
+  };
+  const opts = { templateKey: 'two-v1', registry };
+  assert.equal(C.completenessScore({ a: 'ten chars!', b: 'ten chars!' }, opts), 100);
+  assert.equal(C.completenessScore({ a: 'ten chars!' }, opts), 50);
+  // base fields mean nothing to it
+  assert.equal(C.completenessScore(COMPLETE, opts), 0);
+});
+
+console.log(`\nidea_completeness: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/tests/idea_quick_guard.mjs

@@ -0,0 +1,142 @@
+// tests/idea_quick_guard.mjs
+//
+// task 1002926 (BV1.R150, goal 1000062) — the regression guard: THE QUICK IDEA
+// PATH IS UNTOUCHED by the grade era.
+//
+// Quick Idea exists to turn a thought into a task fast (the owner's brief), and
+// goal 1000062's C1 says it "is never silently treated as an unfinished Full
+// Idea". This file is that promise as executable assertions, pinned from FOUR
+// angles so any future grade/template work that taxes the quick path fails CI
+// here, by name, instead of quietly adding friction:
+//
+//   1. THE CAPTURE CONTRACT — captureIdea takes the same fields it always took,
+//      title is the only requirement, and its INSERT touches idea_inbox alone:
+//      ZERO statements against ideas_grades. A quick idea is quick because no
+//      grade row exists (the R140 design), not because one was written.
+//   2. THE ROUTE SCHEMA — POST /inbox's validator declares exactly the pre-grade
+//      field set. No grade / template_key / field_values key exists in it, so no
+//      client is asked for (or may smuggle) grade-era input on the quick path.
+//   3. THE READ — an idea with no grade row reads back grade='quick' with null
+//      template/score, via the LEFT JOIN + COALESCE (idea_grades.mjs owns the
+//      deep version of this; here it is asserted once as part of the contract).
+//   4. THE PROMOTE — a triage promote writes idea_inbox verdict columns only;
+//      it neither reads nor writes ideas_grades.
+//
+// DB-free, the tests/idea_grades.mjs way: inbox.js destructures `pool` off the
+// doorway at require time, so patching pool.query BEFORE requiring it
+// intercepts every statement.
+//
+// Run:  node tests/idea_quick_guard.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 __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const api = require('../src/module-api.js');
+
+let queries = [];
+let nextRows = [];
+api.pool.query = async (sql, params = []) => {
+  queries.push({ sql, params });
+  return { rows: nextRows };
+};
+
+const inbox = require('../modules/ideas/inbox.js');
+
+let passed = 0;
+let failed = 0;
+async function test(name, fn) {
+  queries = [];
+  nextRows = [{ id: '41', title: 'an idea', status: 'open', grade: 'quick' }];
+  try { await fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.error(`  FAIL ${name}\n    ${err.message}`); }
+}
+
+const grades = (q) => q.filter((x) => /ideas_grades/i.test(x.sql));
+
+// ── 1. the capture contract ─────────────────────────────────────────────────
+
+await test('capture: title alone is enough — the same minimal call as before the grade era', async () => {
+  await inbox.captureIdea({ title: 'just a thought', capturedBy: '7' });
+  assert.equal(queries.length, 1, 'one statement, the idea INSERT');
+  assert.match(queries[0].sql, /INSERT INTO idea_inbox/);
+});
+
+await test('capture: writes ZERO ideas_grades statements — quick is the absence of a row', async () => {
+  await inbox.captureIdea({
+    title: 'a fully-optioned quick idea',
+    bodyMd: 'with a body',
+    kind: 'feature',
+    suggestedVersion: 'BONGOS-V1',
+    suggestedPriority: 3,
+    capturedBy: '7',
+  });
+  assert.equal(grades(queries).length, 0, 'no grade row is written or read at capture');
+});
+
+await test('capture: accepts no grade-era argument — an unknown field is simply not a parameter', async () => {
+  // captureIdea's signature is destructured; passing grade-era keys must change
+  // nothing about what runs (they are not smuggled into SQL params).
+  await inbox.captureIdea({ title: 't', capturedBy: '7', grade: 'full', field_values: { purpose: 'x' } });
+  assert.equal(queries.length, 1);
+  const flat = JSON.stringify(queries[0].params);
+  assert.doesNotMatch(flat, /purpose/, 'grade-era keys never reach the INSERT params');
+  assert.equal(grades(queries).length, 0);
+});
+
+await test('capture: the title requirement is the SAME refusal it always was', async () => {
+  try { await inbox.captureIdea({ capturedBy: '7' }); assert.fail('should refuse'); }
+  catch (err) { assert.equal(err.code, 'TITLE_REQUIRED'); }
+  assert.equal(queries.length, 0, 'refused before any query');
+});
+
+// ── 2. the route schema ─────────────────────────────────────────────────────
+
+await test('POST /inbox declares the pre-grade field set — nothing grade-era, nothing newly required', () => {
+  const src = fs.readFileSync(path.join(__dirname, '..', 'modules', 'ideas', 'routes', 'inbox.js'), 'utf8');
+  const post = src.slice(src.indexOf("router.post('/inbox'"), src.indexOf('captureIdea('));
+  const schema = post.slice(post.indexOf('{', post.indexOf('validateOrRespond')), post.indexOf('})') + 1);
+  for (const key of ['title', 'body_md', 'kind', 'suggested_version', 'suggested_priority']) {
+    assert.ok(schema.includes(key), `the quick path still accepts ${key}`);
+  }
+  assert.doesNotMatch(schema, /grade|template|field_values|completeness/,
+    'no grade-era key in the quick capture schema');
+  const required = [...schema.matchAll(/(\w+):\s*\{[^}]*required:\s*true/g)].map((m) => m[1]);
+  assert.deepEqual(required, ['title'], 'title is the ONLY required field, as it always was');
+});
+
+// ── 3. the read ──────────────────────────────────────────────────────────────
+
+await test('read: an ungraded idea comes back grade=quick with null template/score', async () => {
+  nextRows = [{ id: '41', title: 'an idea', status: 'open', grade: 'quick', template_key: null, field_values: null, completeness_score: null }];
+  const idea = await inbox.getIdea('41');
+  assert.equal(idea.grade, 'quick');
+  assert.equal(idea.template_key, null);
+  assert.equal(idea.completeness_score, null);
+  assert.match(queries[0].sql, /LEFT JOIN ideas_grades/, 'the read is a LEFT JOIN — absence reads as quick');
+  assert.match(queries[0].sql, /COALESCE\(g\.grade/, 'the COALESCE is what defaults it');
+});
+
+// ── 4. the promote ───────────────────────────────────────────────────────────
+
+await test('promote: mutates idea_inbox only — the grade table is read (one CTE), never written', async () => {
+  nextRows = [{ id: '41', title: 'an idea', status: 'promoted', promoted_to_task_id: '900' }];
+  await inbox.updateIdea('41', { status: 'promoted', promoted_to_task_id: '900' });
+  assert.ok(queries.length >= 1);
+  for (const q of queries) {
+    // Reading the grade is CORRECT here (the CTE joins it so an already-sparked
+    // idea is not misreported as quick); what the guard forbids is any MUTATION
+    // of the grade table riding along with a triage verdict.
+    assert.doesNotMatch(q.sql, /UPDATE\s+ideas_grades|INSERT\s+INTO\s+ideas_grades|DELETE\s+FROM\s+ideas_grades/i,
+      'promote must not mutate the grade table');
+  }
+  assert.ok(queries.some((q) => /UPDATE idea_inbox/i.test(q.sql)), 'the promote is the same idea_inbox UPDATE');
+});
+
+console.log(`\nidea_quick_guard: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);