@bongos/core 1.19.162 → 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.162",
-  "core_contract": "1.19.162",
-  "source_commit": "1db6240e60bde4c45db842d783f1a109da3684e5",
+  "core_version": "1.19.163",
+  "core_contract": "1.19.163",
+  "source_commit": "cf29eabb9874ecd380580fa762e09cf7ab412a1e",
   "source_ref": "HEAD",
-  "built_at": "2026-08-16T16:44:59.964Z",
+  "built_at": "2026-08-16T16:52:34.284Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 305,
     "agent_docs_stubbed": 21,
-    "functional_verbatim": 1260,
+    "functional_verbatim": 1262,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 1586,
-  "tree_sha256": "b21ff15e6dc8e250c96a99b03f62b79b69a99a870c2aca7d2db4bbc8a1e1f0f9",
+  "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": "0fa4ce8b1bb49791c487d1b90ac7f0ddea7577cf4c14db1b6366ccdccaed06ad"
+      "sha256": "572ae700360b73fdbc62135f01397fd335bcb5a735d113962a8343377672268c"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "33e29cccdddaea282c452b7296e2be6ec3fd06d61b6a8d35c60a98aa86d61bf2"
+      "sha256": "1460066c89ad9a7db9dc62ae0b6766c5e11cc18d8268fb95a4ae8767325569c5"
     },
     {
       "path": "public-docs/index.html",
@@ -5797,7 +5802,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "6e7fcf60af8a8abcc9e1a193c5ecf49fed08c9b410c9e3a1dd031f406bf1dea3"
+      "sha256": "4e7edb74be33ea3e2b126dadb6a51dce083c4df6eb8c0521c0c7f484997edbe4"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -6904,6 +6909,11 @@
       "mode": "0000644",
       "sha256": "7d384cd84cdc93b8e7b57df291a4600a40f43346fd2a52168324ecde219f1388"
     },
+    {
+      "path": "tests/idea_completeness.mjs",
+      "mode": "0000644",
+      "sha256": "e7b6af463185ea77f40d62408026c55c7fb077f18999b972564b3b5bc7656ca5"
+    },
     {
       "path": "tests/idea_grades.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.162",
+  "version": "1.19.163",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.162",
+      "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.162",
+  "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

@@ -751,8 +751,10 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 //         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.162'; // 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);