@bongos/core 1.19.665 → 1.19.666

package/.bongos-core.json

@@ -2,11 +2,11 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.665",
-  "core_contract": "1.19.665",
-  "source_commit": "7ef8d5c24fb694791fdccc5ab53fbbe21170e2e6",
+  "core_version": "1.19.666",
+  "core_contract": "1.19.666",
+  "source_commit": "3fc1c7e12b4d5fa3451f618fb8a971a5da710db7",
   "source_ref": "HEAD",
-  "built_at": "2026-09-11T04:01:09.165Z",
+  "built_at": "2026-09-11T05:45:20.037Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 473,
@@ -17,7 +17,7 @@
     "gate": "passed"
   },
   "file_count": 2613,
-  "tree_sha256": "33ab4d76429a4eba4c8f7a55777178c652db9850d94a2109f4a58f01755924f5",
+  "tree_sha256": "18d8514d20465a8efc1d55968fb7382c7fef86fac6d286475bb414b792238821",
   "files": [
     {
       "path": ".claude/skills/ask-for-help/SKILL.md",
@@ -2787,7 +2787,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "e07ed4ccaa848d6fa841e3d105924622871be090dfcad28cbb579252a680df6d"
+      "sha256": "1a4f6805f1c7cc669b21c253e57d753e5e37c8a4d0b84ea27ad959be2b63c4dc"
     },
     {
       "path": "docs/modules-contract.md",
@@ -7757,12 +7757,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "08926fcd473def51f7cd29c03e7d74c7788fb975e5468308a94af5acf3330b29"
+      "sha256": "67316339ae447a8943fa26ed89e3974debbd19f41ca5d7082a35a7960632ca75"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "37fc9987d0f0eba09543411a2a907929f308364c917675e3c5c10693b2af8c9f"
+      "sha256": "b54f7ae81efd2b4d6c154240adce30ba2a0e4b4356050680704276d4fd8f9f8a"
     },
     {
       "path": "public-docs/index.html",
@@ -8052,7 +8052,7 @@
     {
       "path": "scripts/gds/conductor-dispatch.js",
       "mode": "0000644",
-      "sha256": "679d126ed6a23d98692bd60ecd1ae64abf93e6a25a4f3a2113c8b8cf74a070fa"
+      "sha256": "6f25380a8b715dad1ce9dd17c0f0a2d7fa7573db6e2434029f0ba1d3c1cdc730"
     },
     {
       "path": "scripts/gds/context-pack.js",
@@ -9522,7 +9522,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "f92f0a7021eeb76eb23f36de073120ada6b44c6882db7defe5125453d32e4d8e"
+      "sha256": "ae4d5ac8a868e23e7f9a456173658719bdbd44e4ed231d60fcd3fe9646c81d47"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -10182,7 +10182,7 @@
     {
       "path": "tests/conductor.mjs",
       "mode": "0000644",
-      "sha256": "27d1c2654d9d0bbd970b088d7aae674c624b70e112a70de63f87fe7a1e99ae7a"
+      "sha256": "e2c338b765a7fccedd1730bb56e9338e022c41a40ed60406a94c1bb5b7b1599a"
     },
     {
       "path": "tests/confirm_attribution.mjs",

package/docs/module-api-changelog.md

@@ -1789,5 +1789,7 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.19.663 with no explicit bump. run 34558906002. (task 1002620)
   1.19.665 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.19.664 with no explicit bump. run 34560552542. (task 1002620)
+  1.19.666 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.665 with no explicit bump. run 34567142386. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.665",
+  "version": "1.19.666",
   "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/conductor-dispatch.js

@@ -44,6 +44,9 @@
 // 0 when a task was selected (a directive was emitted), 1 on a NO-GO / no work.
 
 const { execFileSync } = require('node:child_process');
+// basename(cwd) is the worktree name a claim is bound to (task 1003834) — the
+// same value claim.js records via --worktree.
+const path = require('node:path');
 const { cliClient } = require('./cli-lib');
 const grader = require('../../modules/grading/grader');
 // Phase 4.5: reuse the $0 deterministic autonomy precheck (the same gate the
@@ -195,11 +198,58 @@ function diffStatsSince(base, untracked) {
   };
 }
 
+// THE WORKTREE IS THE ANSWER, when there is one (task 1003834).
+//
+// A claim BINDS to a dedicated worktree — one claim per session, one worktree
+// per claim (task 1642, ADR 0097) — and `claim.js --worktree` records that
+// worktree's leaf-folder name on the claim row, which is exactly
+// `path.basename(process.cwd())`. So when this dispatch runs inside a claimed
+// worktree there is no inference to do: that worktree's claim IS the task being
+// worked on. Everything below it is a heuristic; this is a fact.
+//
+// Claims from before the column existed carry a null worktree_name and are
+// simply not matched here — the heuristic still covers them.
+function claimForWorktree(claims, worktreeName) {
+  if (!Array.isArray(claims) || !worktreeName) return null;
+  return claims.find((c) => c && c.worktree_name && c.worktree_name === worktreeName) || null;
+}
+
 // Pick the active claim whose touches[] best overlap the changed files — the
 // claim the current diff most plausibly belongs to. With multiple (possibly
 // stale) claims, blindly taking claims[0] grades the diff against the wrong
 // task: the Phase 4 dogfood's Narc FAILed because it graded Conductor code
 // against an unrelated stale offsite-backup claim. Best-overlap fixes that.
+//
+// SPECIFICITY, NOT VOLUME (task 1003834). A raw count of matched files rewards
+// BREADTH, so the more honestly a claim declares its touches[] the more likely
+// it loses. Observed 2026-09-10: reviewing task 1003829's diff, its own claim
+// declared three exact files (`modules/hall-ui/public/studio.{js,html,css}`) and
+// could therefore score at most 3, while a concurrent rename claim declaring
+// `scripts/gds/`, `src/bongos/`, `modules/`, `clients/` matched most of the
+// same diff and won — so the reviewer was briefed on an unrelated task. A
+// pattern like `modules/` covers almost any diff in this repo and must not
+// out-vote an exact path.
+//
+// So each matched file is worth the SPECIFICITY of the pattern that matched it:
+// its path-segment depth, plus a bonus when the pattern is the file itself.
+// Volume still counts — a genuinely broad claim matching fifty files beats a
+// narrow one sharing a single file — but depth breaks the tie the right way.
+function patternWeight(pattern, file) {
+  const p = String(pattern || '');
+  const depth = p.replace(/\/+$/, '').split('/').filter(Boolean).length;
+  return depth + (p === file ? EXACT_MATCH_BONUS : 0);
+}
+const EXACT_MATCH_BONUS = 1;
+
+function claimOverlapScore(claim, files) {
+  let score = 0;
+  for (const f of files) {
+    const hit = matchOne(f, (claim && claim.touches) || []);
+    if (hit !== null) score += patternWeight(hit, f);
+  }
+  return score;
+}
+
 function bestMatchingClaim(claims, changedFiles) {
   if (!Array.isArray(claims) || claims.length === 0) return null;
   const files = Array.isArray(changedFiles) ? changedFiles : [];
@@ -207,12 +257,29 @@ function bestMatchingClaim(claims, changedFiles) {
   let bestScore = -1;
   for (const c of claims) {
     // Use the canonical matcher; ties keep the earlier claim (strict >).
-    const score = files.filter((f) => matchOne(f, c.touches || []) !== null).length;
+    const score = claimOverlapScore(c, files);
     if (score > bestScore) { bestScore = score; best = c; }
   }
   return best;
 }
 
+// The claim this diff belongs to, and HOW that was decided — because the two
+// answers deserve very different trust. 'worktree' is a fact; 'overlap' is a
+// guess, and a guess that must be visible so a reader can discount a review
+// that argues from the brief rather than from the diff.
+//
+// A claim with an EMPTY touches[] scores zero against any diff, which is most
+// tasks in this repo — another reason the worktree signal leads rather than
+// merely breaking ties.
+function attributeClaim(claims, changedFiles, worktreeName) {
+  const byWorktree = claimForWorktree(claims, worktreeName);
+  if (byWorktree) return { claim: byWorktree, signal: 'worktree', worktree: worktreeName };
+  const byOverlap = bestMatchingClaim(claims, changedFiles);
+  if (!byOverlap) return { claim: null, signal: 'none', worktree: worktreeName || null };
+  const score = claimOverlapScore(byOverlap, Array.isArray(changedFiles) ? changedFiles : []);
+  return { claim: byOverlap, signal: score > 0 ? 'overlap' : 'fallback', worktree: worktreeName || null };
+}
+
 // --- task context (best-effort) ---
 // Workers grade a diff against a task. For a mid-flight review we use the
 // best-matching active claim's task; otherwise we synthesize a minimal
@@ -224,7 +291,12 @@ async function resolveTaskContext(changedFiles) {
     if (me.ok) {
       const claims = me.data.active_claims || (me.data.active_claim ? [me.data.active_claim] : []);
       if (claims.length > 0) {
-        const c = bestMatchingClaim(claims, changedFiles);
+        // The worktree this dispatch was invoked in decides it when it can
+        // (task 1003834); the touches[] heuristic is the fallback, and which
+        // one answered is reported to the reader rather than hidden.
+        const attribution = attributeClaim(claims, changedFiles, path.basename(process.cwd()));
+        const c = attribution.claim;
+        if (!c) throw new Error('no claim attributed');
         // Pull the full description for richer context (best-effort). Coerce
         // task_id to an integer before interpolating it into the URL path —
         // it's a trusted internal value, but a guard costs nothing and closes
@@ -243,6 +315,11 @@ async function resolveTaskContext(changedFiles) {
           description: description || '(no description fetched — mid-flight review; judge the diff on its own merits)',
           kind: 'unclassified',
           version_id: c.version_id,
+          // How this task was attributed to this diff, carried so the header can
+          // say it (task 1003834). 'worktree' is a fact; anything else is a
+          // guess the reader should weigh.
+          attribution: attribution.signal,
+          claim_count: claims.length,
         };
       }
     }
@@ -257,6 +334,22 @@ async function resolveTaskContext(changedFiles) {
 
 // --- rendering ---
 
+// Say how the task context was chosen, but only when saying it changes what a
+// reader should do (task 1003834). Attribution by WORKTREE is certain, and a
+// single claim leaves nothing to confuse, so both stay silent. A guess made
+// while several claims were open is the case that misled a reader before, and
+// it says so out loud.
+function attributionNote(task) {
+  if (!task || !task.id) return '';
+  const n = Number(task.claim_count) || 0;
+  if (task.attribution === 'worktree' || n < 2) return '';
+  const how = task.attribution === 'overlap'
+    ? 'guessed from touches[] overlap'
+    : 'no signal at all — first claim taken';
+  return `\n   ⚠ attribution: ${how}, across ${n} open claims. This worktree is bound to no claim, so the brief`
+    + '\n     may belong to different work: weigh findings about the FILES, discount findings about intent.';
+}
+
 function renderWorker(w) {
   const lines = [];
   const status = w.error ? `ERROR (${w.error})` : w.verdict.toUpperCase();
@@ -382,7 +475,7 @@ async function main() {
   const routeRank = grader.routeRankPrePass(files);
 
   console.log(`🎼 Conductor dispatch → ${kinds.join(', ')}  (model=${model}, ${files.length} changed file(s), base=${base.slice(0, 8)})`);
-  console.log(`   task context: ${task.id ? '#' + task.id + ' ' + task.title : task.title}`);
+  console.log(`   task context: ${task.id ? '#' + task.id + ' ' + task.title : task.title}${attributionNote(task)}`);
   if (routeRank) console.log('   + deterministic route-rank check (route file in diff)');
   console.log('');
 
@@ -423,4 +516,9 @@ if (require.main === module) {
   });
 }
 
-module.exports = { pickSpecialists, bestMatchingClaim, selectAutonomousDispatch, autoDispatch };
+module.exports = {
+  pickSpecialists, bestMatchingClaim, selectAutonomousDispatch, autoDispatch,
+  // task 1003834 — the attribution layer, exported so its decisions are pinned
+  // rather than only observed through a dispatch run.
+  claimForWorktree, claimOverlapScore, attributeClaim, attributionNote,
+};

package/src/module-api.js

@@ -71,7 +71,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // 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.665'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.666'; // 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/conductor.mjs

@@ -372,6 +372,112 @@ test('bestMatchingClaim: single claim returned; empty/null → null', () => {
   assert.equal(dispatch.bestMatchingClaim(null, ['x']), null);
 });
 
+// ---------------------------------------------------------------------------
+// Attribution: which claim does this diff belong to? (task 1003834)
+//
+// The regression these pin is not hypothetical — it happened, and the fixture
+// below is the real data from 2026-09-10.
+// ---------------------------------------------------------------------------
+
+// The observed failure, verbatim. Reviewing task 1003829's diff from its own
+// worktree, the dispatch announced task 1003704 — a concurrent rename claim
+// whose touches[] are four coarse directory prefixes. The reviewer was briefed
+// on unrelated work and had to reason its way out.
+const CLAIM_1003704 = {
+  task_id: '1003704',
+  title: 'C3b: rename gds-session.json and the gds_session cookie',
+  worktree_name: 'task-1003704',
+  touches: ['scripts/gds/', 'src/bongos/', 'modules/', 'clients/'],
+};
+const CLAIM_1003829 = {
+  task_id: '1003829',
+  title: 'The Studio shows an artist no visuals',
+  worktree_name: 'task-1003829',
+  touches: ['modules/hall-ui/public/studio.js', 'modules/hall-ui/public/studio.html', 'modules/hall-ui/public/studio.css'],
+};
+// The diff as it actually was: three studio files plus the wider blast radius a
+// real change carries. Under a RAW COUNT, 1003704 matches 8 of these and
+// 1003829 only 3 — which is how the wrong task won.
+const DIFF_1003829 = [
+  'modules/hall-ui/public/studio.js',
+  'modules/hall-ui/public/studio.html',
+  'modules/hall-ui/public/studio.css',
+  'modules/hall-ui/public/hall-kit.js',
+  'modules/hall-ui/public/studio.states.json',
+  'scripts/hall-preview/server.js',
+  'scripts/hall-preview/task-visual.js',
+  'scripts/hall-preview/fixtures/tasks__detail.json',
+  'docs/copy-inventory.md',
+  'docs/copy-registry.json',
+  'tests/hall_studio_world.mjs',
+  'tests/task_visuals.mjs',
+];
+
+test('attribution: the worktree decides, even when another claim out-matches the diff', () => {
+  const claims = [CLAIM_1003704, CLAIM_1003829];
+  const got = dispatch.attributeClaim(claims, DIFF_1003829, 'task-1003829');
+  assert.equal(got.claim.task_id, '1003829', 'the claim BOUND to this worktree wins');
+  assert.equal(got.signal, 'worktree');
+  // And it wins regardless of claim order, so this cannot pass by accident.
+  assert.equal(dispatch.attributeClaim([CLAIM_1003829, CLAIM_1003704], DIFF_1003829, 'task-1003704').claim.task_id, '1003704');
+});
+
+test('attribution: specificity beats breadth, so the honest touches[] no longer loses', () => {
+  // The same fixture with NO worktree signal — running from the main checkout,
+  // or a pre-worktree_name claim. The heuristic alone must now get it right.
+  const got = dispatch.attributeClaim([CLAIM_1003704, CLAIM_1003829], DIFF_1003829, null);
+  assert.equal(got.claim.task_id, '1003829', 'three exact paths outweigh four directory prefixes');
+  assert.equal(got.signal, 'overlap');
+  // Proof the OLD scoring is what was wrong: by raw count, 1003704 matches more.
+  const rawCount = (c) => DIFF_1003829.filter((f) => (c.touches || []).some((t) => f === t || f.startsWith(t.endsWith('/') ? t : t + '/'))).length;
+  assert.ok(rawCount(CLAIM_1003704) > rawCount(CLAIM_1003829), 'the broad claim really does match more files');
+  assert.ok(dispatch.claimOverlapScore(CLAIM_1003829, DIFF_1003829) > dispatch.claimOverlapScore(CLAIM_1003704, DIFF_1003829), 'and still scores lower');
+});
+
+test('attribution: volume still counts — a genuinely broad claim keeps its diff', () => {
+  // Specificity must not invert the heuristic: a rename touching fifty files
+  // under scripts/gds/ should not lose to a claim sharing one exact file.
+  const broad = { task_id: 'broad', touches: ['scripts/gds/'] };
+  const narrow = { task_id: 'narrow', touches: ['scripts/gds/one.js'] };
+  const files = Array.from({ length: 50 }, (_, i) => `scripts/gds/f${i}.js`).concat('scripts/gds/one.js');
+  assert.equal(dispatch.attributeClaim([narrow, broad], files, null).claim.task_id, 'broad');
+});
+
+test('attribution: an empty touches[] is unreachable by overlap — the worktree saves it', () => {
+  // Most tasks in this repo declare no touches at all, so they score zero
+  // against every diff. That is the other half of why the worktree leads.
+  const bare = { task_id: 'bare', worktree_name: 'task-bare', touches: [] };
+  assert.equal(dispatch.claimOverlapScore(bare, ['a.js', 'b.js']), 0);
+  assert.equal(dispatch.attributeClaim([CLAIM_1003704, bare], ['a.js'], 'task-bare').claim.task_id, 'bare');
+  // With no worktree match it cannot win, and the signal says the answer is weak.
+  const guess = dispatch.attributeClaim([bare, CLAIM_1003704], ['docs/x.md'], 'somewhere-else');
+  assert.equal(guess.signal, 'fallback', 'zero overlap everywhere is reported as no signal, not as a match');
+});
+
+test('attribution: a worktree bound to no claim does not borrow one silently', () => {
+  const claims = [CLAIM_1003704, CLAIM_1003829];
+  const got = dispatch.attributeClaim(claims, DIFF_1003829, 'baseline-main-2');
+  assert.equal(got.signal, 'overlap', 'it falls back rather than refusing');
+  // …and the header SAYS so, which is the part that would have saved the reader.
+  const note = dispatch.attributionNote({ id: got.claim.task_id, attribution: got.signal, claim_count: claims.length });
+  assert.match(note, /attribution: guessed from touches\[\] overlap, across 2 open claims/);
+  assert.match(note, /discount findings about intent/);
+});
+
+test('attribution: the note stays quiet when it would only add noise', () => {
+  // Certain attribution, and the single-claim case, have nothing to warn about.
+  assert.equal(dispatch.attributionNote({ id: '1', attribution: 'worktree', claim_count: 4 }), '');
+  assert.equal(dispatch.attributionNote({ id: '1', attribution: 'overlap', claim_count: 1 }), '');
+  assert.equal(dispatch.attributionNote({ id: null, attribution: 'overlap', claim_count: 9 }), '');
+});
+
+test('attribution: claimForWorktree ignores claims with no recorded worktree', () => {
+  // Pre-column claims carry null; they must not match an absent cwd name.
+  assert.equal(dispatch.claimForWorktree([{ task_id: 'x', worktree_name: null }], 'task-x'), null);
+  assert.equal(dispatch.claimForWorktree([{ task_id: 'x', worktree_name: 'task-x' }], null), null);
+  assert.equal(dispatch.claimForWorktree(null, 'task-x'), null);
+});
+
 test('isCovered now delegates to the canonical matcher (still correct)', () => {
   // Regression guard for the dedup: isCovered is a thin wrapper over
   // path-match.matchOne (relocated from the deleted touches-scan in task 879),