@bongos/core 1.19.379 → 1.19.381

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.379",
+  "version": "1.19.381",
   "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/ship-memory-sync.js

@@ -56,21 +56,78 @@ function encodeProjectPath(absProjectPath) {
   return String(absProjectPath).replace(/[^a-zA-Z0-9]/g, '-');
 }
 
+// listProjectDirs — the default directory lister for the scan fallback below.
+// Returns the immediate subdirectory NAMES of ~/.claude/projects, sorted so a
+// scan is deterministic. Injectable (opts.readdirFn) so the fallback is unit
+// testable without a real home dir.
+function listProjectDirs(projectsRoot) {
+  return fs
+    .readdirSync(projectsRoot, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name)
+    .sort();
+}
+
 // resolveTranscriptPath — find this session's transcript .jsonl. Claude Code
 // keys the transcript to the project dir of the CWD where the session RUNS, so
 // a session in a git worktree stores it under the WORKTREE-encoded dir, not the
 // main checkout. (6D.1 #540 shipped resolving only REPO_ROOT, which silently
 // missed every worktree session — #551.) We try the session-local dir
-// (process.cwd()) first, then REPO_ROOT as a fallback. Pure (exists + base
-// injectable for tests). Returns the first existing path, or null.
+// (process.cwd()) first, then REPO_ROOT.
+//
+// task 1002505: those two fast paths NARROW the miss, they do not seal it. The
+// session driving a ship need not be rooted in EITHER dir — a session rooted in
+// another repo can file a task here and ship it (proven on task 1002475, whose
+// orchestrating session lived under a different project's encoded dir, so both
+// probed paths missed, no session_record was written, and the cost-plus reward
+// — the only stream this instance pays, ADR 0146 — never booked). So after the
+// fast paths we SCAN every dir under ~/.claude/projects for <sessionId>.jsonl.
+// A session id is a UUID, so a filename hit is unambiguous and cannot
+// mis-attribute; the scan is one stat per project dir, so it stays cheap.
+//
+// Pure-ish (exists + readdir + base injectable for tests). Pass opts.tried an
+// array and every probed path is appended to it — the caller reports that in a
+// transcript_not_found skip, so a genuine miss still names where it looked. The
+// scan contributes ONE summary line, not one line per dir, so the reason stays
+// readable. Returns the first existing path, or null.
 function resolveTranscriptPath(sessionId, projectDirs, opts = {}) {
   const exists = opts.existsFn || fs.existsSync;
+  const readdir = opts.readdirFn || listProjectDirs;
   const base = opts.base || claudeConfigBase();
-  for (const dir of projectDirs) {
+  const tried = Array.isArray(opts.tried) ? opts.tried : null;
+  const projectsRoot = path.join(base, 'projects');
+  const seen = new Set();
+
+  const probe = (p, { record = true } = {}) => {
+    if (seen.has(p)) return false;
+    seen.add(p);
+    if (tried && record) tried.push(p);
+    return exists(p);
+  };
+
+  for (const dir of projectDirs || []) {
     if (!dir) continue;
-    const p = path.join(base, 'projects', encodeProjectPath(path.resolve(dir)), `${sessionId}.jsonl`);
-    if (exists(p)) return p;
+    const p = path.join(projectsRoot, encodeProjectPath(path.resolve(dir)), `${sessionId}.jsonl`);
+    if (probe(p)) return p;
+  }
+
+  // Fallback scan. Best-effort: an unreadable/absent projects root is not an
+  // error here — it just means the scan finds nothing, same as the fast paths.
+  let names;
+  try {
+    names = readdir(projectsRoot);
+  } catch (_) {
+    names = null;
+  }
+  if (!Array.isArray(names)) {
+    if (tried) tried.push(`${path.join(projectsRoot, '*')} (could not read the projects dir)`);
+    return null;
+  }
+  for (const name of names) {
+    const p = path.join(projectsRoot, name, `${sessionId}.jsonl`);
+    if (probe(p, { record: false })) return p;
   }
+  if (tried) tried.push(`${path.join(projectsRoot, '*', `${sessionId}.jsonl`)} (scanned ${names.length} project dirs)`);
   return null;
 }
 

package/scripts/gds/ship-session-upload.js

@@ -11,7 +11,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { cliClient, loadSession } = require('./cli-lib');
-const { claudeConfigBase, encodeProjectPath, resolveTranscriptPath } = require('./ship-memory-sync.js');
+const { resolveTranscriptPath } = require('./ship-memory-sync.js');
 const { apiErrorLine } = require('./ship-io.js');
 const { REPO_ROOT } = require('./ship-state.js');
 
@@ -117,16 +117,18 @@ async function uploadSessionOnShip(taskId) {
     // hostile env value with `../` could otherwise point the read elsewhere.
     const sessionIdSafe = !!sessionId && /^[A-Za-z0-9_-]+$/.test(sessionId);
     // The transcript is keyed to the session's CWD (the worktree when shipping
-    // from one), so try that before REPO_ROOT (#551). Reconstruct the exact
-    // paths resolveTranscriptPath checks so a transcript-not-found skip can name
-    // precisely where it looked (actionable, not a bare "not found").
+    // from one), so try that before REPO_ROOT (#551), then let the resolver scan
+    // every ~/.claude/projects dir — a session rooted in ANOTHER repo can drive a
+    // ship here, and before task 1002505 that missed both fast paths and silently
+    // wrote no session_record at all. resolveTranscriptPath fills pathsTried with
+    // exactly what it probed, so a transcript-not-found skip names precisely where
+    // it looked (actionable, not a bare "not found") without this file having to
+    // re-derive the encoding and drift from it.
     const dirsTried = [process.cwd(), REPO_ROOT].filter(Boolean);
-    const pathsTried = sessionIdSafe
-      ? dirsTried.map((d) =>
-          path.join(claudeConfigBase(), 'projects', encodeProjectPath(path.resolve(d)), `${sessionId}.jsonl`)
-        )
-      : [];
-    const transcriptPath = sessionIdSafe ? resolveTranscriptPath(sessionId, dirsTried) : null;
+    const pathsTried = [];
+    const transcriptPath = sessionIdSafe
+      ? resolveTranscriptPath(sessionId, dirsTried, { tried: pathsTried })
+      : null;
 
     const decision = classifyUploadSkip({ sessionId, sessionIdSafe, transcriptPath, pathsTried });
     if (decision.skip) {

package/src/module-api.js

@@ -1198,8 +1198,12 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 //         landed since 1.19.377 with no explicit bump. run 33025512093. (task 1002620)
 //   1.19.379 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
 //         landed since 1.19.378 with no explicit bump. run 33026467245. (task 1002620)
+//   1.19.380 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.379 with no explicit bump. run 33085516721. (task 1002620)
+//   1.19.381 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.380 with no explicit bump. run 33088290961. (task 1002620)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.379'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.381'; // 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/session_records.mjs

@@ -112,27 +112,144 @@ test('snippetOf flattens whitespace, caps length, and scrubs', () => {
 });
 
 // ---------- resolveTranscriptPath (#551: worktree sessions) ----------
+//
+// FIXTURE NOTE: the expected transcript path is DERIVED via encodeProjectPath(
+// path.resolve(dir)) rather than hard-coded as its POSIX encoding. path.resolve
+// is platform-dependent — on win32 '/proj' resolves to 'C:\\\\proj', which encodes
+// to 'C--proj', not '-proj' — so hard-coded encodings made these two tests fail
+// on Windows while passing in Linux CI. Deriving them asserts the same behaviour
+// on both. (POSIX encoding itself is pinned separately below.)
+const sidPath = (base, dir, sid) =>
+  path.join(base, 'projects', encodeProjectPath(path.resolve(dir)), `${sid}.jsonl`);
 
 test('resolveTranscriptPath prefers the session CWD (worktree) over REPO_ROOT', () => {
   const sid = 'abc-123';
   const base = '/fake/.claude';
   const worktree = '/proj/.claude/worktrees/wt1';
   const mainRepo = '/proj';
-  const wtPath = path.join(base, 'projects', '-proj--claude-worktrees-wt1', `${sid}.jsonl`);
+  const wtPath = sidPath(base, worktree, sid);
   // Only the worktree-encoded path exists — the bug looked at REPO_ROOT first.
-  const got = resolveTranscriptPath(sid, [worktree, mainRepo], { base, existsFn: (p) => p === wtPath });
+  const got = resolveTranscriptPath(sid, [worktree, mainRepo], {
+    base,
+    existsFn: (p) => p === wtPath,
+    readdirFn: () => [],
+  });
   assert.equal(got, wtPath);
 });
 
 test('resolveTranscriptPath falls back to REPO_ROOT, else null', () => {
   const sid = 'abc-123';
   const base = '/fake/.claude';
-  const mainPath = path.join(base, 'projects', '-proj', `${sid}.jsonl`);
+  const mainPath = sidPath(base, '/proj', sid);
   assert.equal(
-    resolveTranscriptPath(sid, ['/proj/.claude/worktrees/wt1', '/proj'], { base, existsFn: (p) => p === mainPath }),
+    resolveTranscriptPath(sid, ['/proj/.claude/worktrees/wt1', '/proj'], {
+      base,
+      existsFn: (p) => p === mainPath,
+      readdirFn: () => [],
+    }),
     mainPath
   );
-  assert.equal(resolveTranscriptPath(sid, ['/a', '/b'], { base, existsFn: () => false }), null);
+  assert.equal(
+    resolveTranscriptPath(sid, ['/a', '/b'], { base, existsFn: () => false, readdirFn: () => [] }),
+    null
+  );
+});
+
+// ---------- resolveTranscriptPath scan fallback (task 1002505) ----------
+//
+// The two fast paths above NARROW the miss, they do not seal it: the session
+// driving a ship need not be rooted in process.cwd() OR REPO_ROOT. A session
+// rooted in ANOTHER repo can file a task here and ship it (proven on task
+// 1002475), and before this fallback both probes missed, classifyUploadSkip
+// returned transcript_not_found, no session_record was written, and the
+// cost-plus reward — the only stream this instance pays (ADR 0146) — never
+// booked. The fallback scans every dir under <base>/projects for
+// <sessionId>.jsonl; a session id is a UUID, so a filename hit is unambiguous.
+
+test('resolveTranscriptPath finds a transcript rooted in a DIFFERENT project dir (the 1002475 shape)', () => {
+  const sid = 'e53f445b-308a-454e-9ac1-9c22d0188a37';
+  const base = '/fake/.claude';
+  // The orchestrating session lived under an unrelated repo's encoded dir, so
+  // neither the claim worktree nor REPO_ROOT could ever match it.
+  const foreign = path.join(base, 'projects', 'C--Users-x-Git-repos-other-project', `${sid}.jsonl`);
+  const got = resolveTranscriptPath(sid, ['/proj/.claude/worktrees/wt1', '/proj'], {
+    base,
+    existsFn: (p) => p === foreign,
+    readdirFn: () => ['C--Users-x-Git-repos-other-project', '-proj', '-proj--claude-worktrees-wt1'],
+  });
+  assert.equal(got, foreign);
+});
+
+test('resolveTranscriptPath scan only matches the exact session id — no mis-attribution', () => {
+  const sid = 'abc-123';
+  const base = '/fake/.claude';
+  const other = path.join(base, 'projects', '-somewhere-else', 'def-456.jsonl');
+  assert.equal(
+    resolveTranscriptPath(sid, ['/proj'], {
+      base,
+      existsFn: (p) => p === other,
+      readdirFn: () => ['-somewhere-else'],
+    }),
+    null
+  );
+});
+
+test('resolveTranscriptPath does not scan when a fast path hits (precedence unchanged)', () => {
+  const sid = 'abc-123';
+  const base = '/fake/.claude';
+  const wtPath = sidPath(base, '/proj/.claude/worktrees/wt1', sid);
+  let scanned = 0;
+  const got = resolveTranscriptPath(sid, ['/proj/.claude/worktrees/wt1', '/proj'], {
+    base,
+    existsFn: (p) => p === wtPath,
+    readdirFn: () => { scanned++; return []; },
+  });
+  assert.equal(got, wtPath);
+  assert.equal(scanned, 0, 'the scan must not run once a fast path has matched');
+});
+
+test('resolveTranscriptPath fills opts.tried: the fast paths, plus ONE scan summary', () => {
+  const sid = 'abc-123';
+  const base = '/fake/.claude';
+  const tried = [];
+  const got = resolveTranscriptPath(sid, ['/proj/.claude/worktrees/wt1', '/proj'], {
+    base,
+    existsFn: () => false,
+    readdirFn: () => ['-a', '-b', '-c'],
+    tried,
+  });
+  assert.equal(got, null);
+  // Two exact fast paths...
+  assert.equal(tried[0], sidPath(base, '/proj/.claude/worktrees/wt1', sid));
+  assert.equal(tried[1], sidPath(base, '/proj', sid));
+  // ...then a single bounded summary, not one line per scanned dir, so the
+  // transcript_not_found reason stays readable however many projects exist.
+  assert.equal(tried.length, 3);
+  assert.ok(tried[2].includes('scanned 3 project dirs'), tried[2]);
+});
+
+test('resolveTranscriptPath survives an unreadable projects dir and says so', () => {
+  const sid = 'abc-123';
+  const base = '/fake/.claude';
+  const tried = [];
+  const got = resolveTranscriptPath(sid, ['/proj'], {
+    base,
+    existsFn: () => false,
+    readdirFn: () => { throw new Error('ENOENT'); },
+    tried,
+  });
+  assert.equal(got, null, 'a missing/unreadable projects dir must not throw into the ship path');
+  assert.ok(tried[tried.length - 1].includes('could not read the projects dir'), tried.join(' ; '));
+});
+
+test('resolveTranscriptPath tolerates a null/absent projectDirs list', () => {
+  const sid = 'abc-123';
+  const base = '/fake/.claude';
+  const hit = path.join(base, 'projects', '-only-dir', `${sid}.jsonl`);
+  assert.equal(
+    resolveTranscriptPath(sid, null, { base, existsFn: (p) => p === hit, readdirFn: () => ['-only-dir'] }),
+    hit
+  );
 });
 
 // ---------- encodeProjectPath (task 1002471: win32 separators) ----------