@bongos/core 1.19.664 → 1.19.666

package/scripts/hall-preview/task-visual.js

@@ -0,0 +1,89 @@
+'use strict';
+// scripts/hall-preview/task-visual.js — a stand-in ship-time visual for the
+// preview harness (task 1003829).
+//
+// WHY THIS EXISTS. Everything else in this harness is answered from a checked-in
+// JSON fixture, but a ship-time visual is an IMAGE: the API stub answers
+// /api/bongos/* with JSON, so a page that renders <img src="/api/bongos/
+// task-visuals/task-1899-….png"> got a 404 body and a broken frame. The Studio's
+// review card (task 1003829) makes that image the subject of the card, and a
+// surface whose subject cannot be rendered cannot be reviewed — the whole point
+// of this harness.
+//
+// It is a GENERATED placeholder, not a checked-in screenshot: a few flat bands
+// at a real screenshot's aspect ratio, so a reviewer can judge the plate's size,
+// fit, caption and crop without a binary in the repo. Deliberately obvious —
+// nobody should mistake it for a real ship's visual.
+//
+// A ~40-line PNG encoder rather than a dependency, matching the kit's own
+// png.js (a ~50-line DEcoder for the same reason). One IDAT, filter type 0.
+const zlib = require('node:zlib');
+
+function chunk(type, data) {
+  const len = Buffer.alloc(4);
+  len.writeUInt32BE(data.length);
+  const body = Buffer.concat([Buffer.from(type, 'ascii'), data]);
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(body) >>> 0);
+  return Buffer.concat([len, body, crc]);
+}
+
+let CRC_TABLE = null;
+function crc32(buf) {
+  if (!CRC_TABLE) {
+    CRC_TABLE = new Int32Array(256);
+    for (let n = 0; n < 256; n++) {
+      let c = n;
+      for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+      CRC_TABLE[n] = c;
+    }
+  }
+  let c = -1;
+  for (let i = 0; i < buf.length; i++) c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
+  return c ^ -1;
+}
+
+// An RGB PNG from a per-pixel colour function. RGB (colour type 2), 8-bit,
+// non-interlaced — the shape the kit's decoder also speaks.
+function encodeRgb(w, h, at) {
+  const stride = w * 3;
+  const raw = Buffer.alloc((stride + 1) * h);
+  for (let y = 0; y < h; y++) {
+    const row = y * (stride + 1);
+    raw[row] = 0;  // filter: none
+    for (let x = 0; x < w; x++) {
+      const [r, g, b] = at(x, y);
+      const p = row + 1 + x * 3;
+      raw[p] = r; raw[p + 1] = g; raw[p + 2] = b;
+    }
+  }
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(w, 0);
+  ihdr.writeUInt32BE(h, 4);
+  ihdr[8] = 8; ihdr[9] = 2; ihdr[10] = 0; ihdr[11] = 0; ihdr[12] = 0;
+  return Buffer.concat([
+    Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+    chunk('IHDR', ihdr),
+    chunk('IDAT', zlib.deflateSync(raw, { level: 9 })),
+    chunk('IEND', Buffer.alloc(0)),
+  ]);
+}
+
+// The stand-in: a wide plate of flat bands with a paler inset, so its edges,
+// aspect ratio and any crop are all visible at a glance. Cached — the harness
+// may serve it on every paint.
+let CACHED = null;
+function placeholderPng() {
+  if (CACHED) return CACHED;
+  const W = 1200, H = 700;
+  const BANDS = [[38, 34, 30], [74, 66, 58], [176, 96, 62], [214, 200, 184], [246, 243, 238]];
+  CACHED = encodeRgb(W, H, (x, y) => {
+    const inset = x > W * 0.08 && x < W * 0.92 && y > H * 0.14 && y < H * 0.86;
+    const band = BANDS[Math.min(BANDS.length - 1, Math.floor((y / H) * BANDS.length))];
+    if (!inset) return band;
+    return band.map((c) => Math.min(255, Math.round(c + (255 - c) * 0.42)));
+  });
+  return CACHED;
+}
+
+module.exports = { placeholderPng, encodeRgb };

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.664'; // 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),