@bongos/core 1.19.452 → 1.19.453

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.452",
-  "core_contract": "1.19.452",
-  "source_commit": "a59941e00bdc972cede45d82263d6bb9a334d59d",
+  "core_version": "1.19.453",
+  "core_contract": "1.19.453",
+  "source_commit": "d608d7888d16f919cc2775428848dcfff82d333b",
   "source_ref": "HEAD",
-  "built_at": "2026-09-01T19:56:39.788Z",
+  "built_at": "2026-09-01T20:06:17.187Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 371,
     "agent_docs_stubbed": 24,
-    "functional_verbatim": 1788,
+    "functional_verbatim": 1789,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 2183,
-  "tree_sha256": "d6e755d26822b3fbb320367835d28cb2e6e317309a6da4985730541e202fec63",
+  "file_count": 2184,
+  "tree_sha256": "b32b4f4ed373293772fa27594b928449ab80778248125d70b8401f71e0b34ac3",
   "files": [
     {
       "path": ".claude/skills/blocker-review/SKILL.md",
@@ -2092,7 +2092,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "1b44d9a28067aee44f6461a6ec2ff31dcbcd1d92aba9b5e5d53ac97dcb782cbe"
+      "sha256": "9626b5a975e660041681a9d58615224db812a74a705251d12f53cd51bcc88f1f"
     },
     {
       "path": "docs/modules-contract.md",
@@ -6302,12 +6302,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "a24646cf791a4ef41bf5fbca236cf24a27c9d05ba0f4419483054f38b849688e"
+      "sha256": "a9e7b10b99360f563204364b2a444ff18b701669723ef0a9a76a04a0046df317"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "76ba0c0adc1241f0051796e43d8519486163d142b23a57704d60aabd56806cb6"
+      "sha256": "ea1047b8ac17de0376d21a3a07d9f22f2854e20397b72b0626c896e4129bbfdf"
     },
     {
       "path": "public-docs/index.html",
@@ -7957,7 +7957,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "4b7bee96fc2dfb083dcc43f811b46f135c4103cf719e68546ee2b898569cfc65"
+      "sha256": "118d1bcac62c551bf53344abd1b77785f9875d4a6e6c29a86123f4587ac79906"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -9479,6 +9479,11 @@
       "mode": "0000644",
       "sha256": "51e1286235cbde1b56188f29b0e2bd12ac73a9637dbf1c16b325f10147256f27"
     },
+    {
+      "path": "tests/idea_route_attribution.mjs",
+      "mode": "0000644",
+      "sha256": "99a4665c1ddd97bb27238082c0e6e420eb66ab3c18ec92b543c3b35ba607ebda"
+    },
     {
       "path": "tests/idea_routing.mjs",
       "mode": "0000644",

package/docs/module-api-changelog.md

@@ -1341,5 +1341,7 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.19.450 with no explicit bump. run 33549781105. (task 1002620)
   1.19.452 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.19.451 with no explicit bump. run 33552353620. (task 1002620)
+  1.19.453 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.452 with no explicit bump. run 33553290345. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/package-lock.json

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

package/package.json

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

@@ -33,7 +33,7 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.452'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.453'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // 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_route_attribution.mjs

@@ -0,0 +1,330 @@
+// tests/idea_route_attribution.mjs
+//
+// THE PROOF — task 1003072 (BV1.R04, goal 1000071 "Idea routing"). Criterion
+// C3, "no route loses the person who thought of it":
+//
+//   (1) every routed task has an ideas_task_lineage row (origin='route') back to
+//       an idea_inbox row with captured_by;
+//   (3) sourceIdeaForTask on a routed, SHIPPED task returns the filer — the trail
+//       goal 1000067's ideator credit will pay against;
+//   (4) an unlinked Discord author still yields an idea row (captured_by null)
+//       rather than an attribution-free task.
+//
+// WHY THIS FILE EXISTS ALONGSIDE tests/idea_routing.mjs. That file proves the
+// WRITE: a routed capture emits idea + task + lineage in one transaction, in FK
+// order, and rolls all three back together. tests/idea_task_lineage.mjs proves
+// the READ: given a hand-seeded lineage row, sourceIdeaForTask names the idea and
+// its author. Neither proves the two HALVES COMPOSE — that the row routing
+// actually writes is the row the credit hook actually finds. A typo'd origin, a
+// task id written where an idea id was meant, a captured_by dropped on the way
+// in: each passes both existing files and still loses the ideator their credit,
+// silently, months before anyone tries to pay them.
+//
+// So this file runs the write and the read against ONE store. Nothing is
+// hand-seeded: every row the assertions read was put there by captureIdea.
+//
+// THE STORE, not a matcher table. The other two files answer per-statement with
+// canned rows, which is right for asserting statement SEQUENCE. Here the point is
+// end-to-end agreement, so the fake speaks the three tables as maps and the
+// queries genuinely join across them. A canned answer would prove nothing: it
+// would be the test asserting its own fixture.
+//
+// MUTATION-VERIFIED (task 1003072). A proof that has never failed is a rumour, so
+// each of these was applied to modules/ideas/inbox.js and the file was confirmed RED
+// before being reverted:
+//
+//   origin 'route' -> 'promote' in the lineage insert ......... 4 of 9 fail
+//   createdBy: capturedBy -> null on the task ................. 1 of 9 fail
+//   lineage params [task.id, idea.id] swapped ................. 5 of 9 fail
+//   captured_by -> null on the idea insert .................... 3 of 9 fail
+//   the lineage INSERT deleted (the #bugs bypass shape) ....... 5 of 9 fail
+//
+// Re-run that check if this file is ever rewritten: the store fake is expressive
+// enough that a careless edit could make it answer its own questions.
+//
+// Run:  node tests/idea_route_attribution.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import { makeRunner } from './helpers.mjs';
+
+process.env.NODE_ENV = 'test';
+
+const require = createRequire(import.meta.url);
+const api = require('../src/module-api.js');
+
+// ---------------------------------------------------------------------------
+// The store: idea_inbox, tasks, ideas_task_lineage as three maps.
+// ---------------------------------------------------------------------------
+
+const GOAL = {
+  id: 7, status: 'open', version_id: 'BONGOS-V1', version_status: 'building', scope_modules: ['ideas'],
+};
+
+function makeStore() {
+  return {
+    ideas: new Map(),    // id -> row
+    tasks: new Map(),    // id -> row
+    lineage: new Map(),  // task_id -> { idea_id, origin }
+    nextIdeaId: 500,
+    nextTaskId: 9000,
+    goal: { ...GOAL },
+  };
+}
+
+// One SQL handler over the store, shared by the transaction client and the
+// module-level pool — so the write path and the read path cannot disagree about
+// what is in the database.
+function handlerFor(store) {
+  return async (s, params = []) => {
+    // the locked goal read (routeIdeaToGoal step a)
+    if (/FROM goals g JOIN versions v/.test(s)) {
+      return { rows: store.goal ? [store.goal] : [] };
+    }
+    // the idea row (step b)
+    if (/INSERT INTO idea_inbox/.test(s)) {
+      const [title, bodyMd, kind, suggestedVersion, suggestedPriority, capturedBy, suggestedGoalId] = params;
+      const id = store.nextIdeaId++;
+      const row = {
+        id,
+        title,
+        body_md: bodyMd,
+        kind,
+        suggested_version: suggestedVersion ?? null,
+        suggested_priority: suggestedPriority ?? null,
+        // captured_by is THE field under test: it must survive the write
+        // unmodified, including when it is null (the unlinked-Discord case).
+        captured_by: capturedBy ?? null,
+        status: 'promoted',
+        suggested_goal_id: suggestedGoalId ?? null,
+        promoted_to_task_id: null,
+        reviewed_at: 'T0',
+        merged_into_idea_id: null,
+        triage_note: null,
+        captured_at: 'T0',
+      };
+      store.ideas.set(String(id), row);
+      return { rows: [row] };
+    }
+    // the lineage row (step d)
+    if (/INSERT INTO ideas_task_lineage/.test(s)) {
+      const [taskId, ideaId] = params;
+      // origin is a literal in the statement, not a param — read it from the SQL
+      // so a change to that literal is caught here rather than assumed.
+      const origin = (s.match(/VALUES \(\$1, \$2, '(\w+)'\)/) || [])[1] ?? null;
+      store.lineage.set(String(taskId), { idea_id: String(ideaId), origin });
+      return { rowCount: 1, rows: [] };
+    }
+    // closing the FK loop (step e)
+    if (/UPDATE idea_inbox SET promoted_to_task_id/.test(s)) {
+      const [ideaId, taskId] = params;
+      const row = store.ideas.get(String(ideaId));
+      if (row) row.promoted_to_task_id = taskId;
+      return { rows: row ? [row] : [] };
+    }
+    // sourceIdeaForTask — the read the ship hook does
+    if (/l\.idea_id, l\.origin, i\.captured_by/.test(s)) {
+      const link = store.lineage.get(String(params[0]));
+      if (!link) return { rows: [] };
+      const idea = store.ideas.get(String(link.idea_id));
+      if (!idea) return { rows: [] }; // an INNER JOIN finds nothing
+      return { rows: [{ idea_id: link.idea_id, origin: link.origin, captured_by: idea.captured_by }] };
+    }
+    // countShippedTasksForIdea
+    if (/COUNT\(\*\)::int AS n/.test(s)) {
+      const ideaId = String(params[0]);
+      let n = 0;
+      for (const [taskId, link] of store.lineage) {
+        if (link.idea_id === ideaId && (store.tasks.get(taskId) || {}).status === 'shipped') n++;
+      }
+      return { rows: [{ n }] };
+    }
+    return { rows: [] }; // BEGIN / COMMIT / ROLLBACK and anything unmatched
+  };
+}
+
+// A pool whose query() and connect().query() both run the same handler against
+// the same store, and which records every statement for ordering assertions.
+function poolFor(store) {
+  const handler = handlerFor(store);
+  const queries = [];
+  const client = {
+    queries,
+    async query(sql, params) {
+      queries.push({ sql: String(sql).replace(/\s+/g, ' ').trim(), params });
+      return handler(String(sql).replace(/\s+/g, ' ').trim(), params);
+    },
+    release() {},
+  };
+  return {
+    queries,
+    query: client.query,
+    connect: async () => client,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Wiring: the lifecycle port (createTask) writes into the SAME store.
+// ---------------------------------------------------------------------------
+
+const seams = require('../src/module-seams.js');
+seams._reset();
+
+let activeStore = makeStore();
+
+seams.registerProvider('lifecycle', {
+  createTask: async (args) => {
+    const id = activeStore.nextTaskId++;
+    const row = {
+      id,
+      status: args.status,
+      goal_id: args.goalId,
+      version_id: args.versionId,
+      title: args.title,
+      kind: args.kind,
+      source: args.source,
+      source_ref: args.sourceRef,
+      created_by: args.createdBy ?? null,
+    };
+    activeStore.tasks.set(String(id), row);
+    return row;
+  },
+});
+
+const inbox = require('../modules/ideas/inbox.js');
+const { captureIdea, sourceIdeaForTask, countShippedTasksForIdea } = inbox;
+
+// sourceIdeaForTask and countShippedTasksForIdea read the MODULE-LEVEL pool (no
+// deps seam), so point that at the live store too. Same object the module
+// captured at load, so replacing the method is enough.
+api.pool.query = async (sql, params) => handlerFor(activeStore)(String(sql).replace(/\s+/g, ' ').trim(), params);
+
+const { test, summary } = makeRunner();
+
+// Route one bug and hand back everything the assertions need.
+async function routeABug({ capturedBy = 42, filerRank = 'metic', title = 'the thing is broken' } = {}) {
+  activeStore = makeStore();
+  const pool = poolFor(activeStore);
+  const idea = await captureIdea(
+    { title, bodyMd: 'steps to reproduce', kind: 'bug', goalId: GOAL.id, capturedBy, filerRank },
+    { pool }
+  );
+  return { idea, pool, store: activeStore };
+}
+
+const ship = (store, taskId) => { store.tasks.get(String(taskId)).status = 'shipped'; };
+
+// =========================================================================
+// C3 (1) — the routed task HAS a lineage row, and it points at a real idea
+// =========================================================================
+
+await test('a routed bug writes lineage origin=route from the task back to the idea', async () => {
+  const { idea, store } = await routeABug();
+  const taskId = idea.routing.task_id;
+
+  assert.ok(taskId, 'the capture became a task');
+  const link = store.lineage.get(String(taskId));
+  assert.ok(link, 'a lineage row exists for the task that was just created');
+  assert.equal(link.origin, 'route', "origin is 'route' — not 'promote', which would misattribute the lane");
+  assert.equal(link.idea_id, String(idea.id), 'and it points at the idea this very capture wrote');
+  assert.ok(store.ideas.has(String(idea.id)), 'that idea id is a real row, not a dangling reference');
+});
+
+await test('the idea row carries the filer, and the task records them as its creator', async () => {
+  const { idea, store } = await routeABug({ capturedBy: 42 });
+  assert.equal(store.ideas.get(String(idea.id)).captured_by, 42, 'the filer is on the idea row');
+  assert.equal(store.tasks.get(String(idea.routing.task_id)).created_by, 42,
+    'and on the task — routing an idea attributes the work to whoever reported it');
+});
+
+// =========================================================================
+// C3 (3) — THE COMPOSITION. What routing wrote is what the ship hook reads.
+// =========================================================================
+
+await test('sourceIdeaForTask on the routed, SHIPPED task returns the filer', async () => {
+  const { idea, store } = await routeABug({ capturedBy: 42 });
+  const taskId = idea.routing.task_id;
+  ship(store, taskId);
+
+  const src = await sourceIdeaForTask(taskId);
+  assert.ok(src, 'the ship hook finds a source idea — nothing to pay is the failure this goal exists to prevent');
+  assert.equal(String(src.idea_id), String(idea.id), 'it names the idea the filing created');
+  assert.equal(src.origin, 'route', 'and says the route is where it came from');
+  assert.equal(src.captured_by, 42, 'and names the person to pay');
+});
+
+await test('the shipped-task count for that idea is exactly one — the credit lane can meter it', async () => {
+  const { idea, store } = await routeABug();
+  assert.equal(await countShippedTasksForIdea(idea.id), 0, 'nothing is owed before it ships');
+  ship(store, idea.routing.task_id);
+  assert.equal(await countShippedTasksForIdea(idea.id), 1, 'and exactly one afterwards — never double-paid');
+});
+
+await test('the trail survives with NOTHING hand-seeded — every row came from the capture', async () => {
+  const { idea, store } = await routeABug({ capturedBy: 77 });
+  // The point of the whole file, asserted directly: three tables, one act.
+  assert.equal(store.ideas.size, 1, 'one idea');
+  assert.equal(store.tasks.size, 1, 'one task');
+  assert.equal(store.lineage.size, 1, 'one lineage row');
+  ship(store, idea.routing.task_id);
+  const src = await sourceIdeaForTask(idea.routing.task_id);
+  assert.deepEqual(
+    { idea: String(src.idea_id), origin: src.origin, who: src.captured_by },
+    { idea: String(idea.id), origin: 'route', who: 77 }
+  );
+});
+
+// =========================================================================
+// C3 (4) — an unlinked author still leaves a trail
+// =========================================================================
+
+await test('an UNLINKED filer (captured_by null) still yields an idea row, not an attribution-free task', async () => {
+  // A Discord author with no Bongos account. The report must not become a task
+  // that exists with no idea behind it — that is precisely the #bugs bypass this
+  // goal retires. The trail exists and is honestly empty at the person-shaped
+  // end, which is recoverable later; a missing lineage row never is.
+  const { idea, store } = await routeABug({ capturedBy: null, filerRank: 'metic' });
+  const taskId = idea.routing.task_id;
+
+  assert.ok(store.lineage.get(String(taskId)), 'the lineage row exists even with no known author');
+  ship(store, taskId);
+  const src = await sourceIdeaForTask(taskId);
+  assert.ok(src, 'the ship hook still finds the idea');
+  assert.equal(src.origin, 'route');
+  assert.equal(src.captured_by, null, 'unattributed, and honestly so — never guessed');
+  assert.equal(store.tasks.get(String(taskId)).created_by, null, 'the task does not invent a creator either');
+});
+
+// =========================================================================
+// The negative: a task with no route has no trail, so a passing test above
+// cannot be the fake answering itself.
+// =========================================================================
+
+await test('a task that was never routed has no source idea (the read is not vacuously true)', async () => {
+  activeStore = makeStore();
+  activeStore.tasks.set('4242', { id: 4242, status: 'shipped' });
+  assert.equal(await sourceIdeaForTask(4242), null,
+    'no lineage row → null; if this returned a row the store would be answering blind');
+});
+
+await test('lineage pointing at a missing idea reads as no source, never as a half-row', async () => {
+  activeStore = makeStore();
+  activeStore.tasks.set('4243', { id: 4243, status: 'shipped' });
+  activeStore.lineage.set('4243', { idea_id: '999', origin: 'route' }); // idea absent
+  assert.equal(await sourceIdeaForTask(4243), null,
+    "the INNER JOIN drops it — the credit lane must never see an author-less 'source'");
+});
+
+// =========================================================================
+// The provenance pair, so one idea can only ever mint one routed task
+// =========================================================================
+
+await test('the routed task carries the idempotency provenance the create-vector read keys on', async () => {
+  const { idea, store } = await routeABug();
+  const task = store.tasks.get(String(idea.routing.task_id));
+  assert.equal(task.source, 'idea-route', 'source names the vector');
+  assert.equal(task.source_ref, `idea-${idea.id}`,
+    'and source_ref names the idea — db.findTaskBySourceRef is what stops a second task being minted');
+});
+
+summary();