@bongos/core 1.19.380 → 1.19.382

package/modules/lifecycle/lifecycle.js

@@ -20,6 +20,7 @@ const db = require('./db');
 const classifier = require('./task-classifier');
 const helpRequests = require('./help-requests');
 const taskRecommendations = require('./task-recommendations');
+const activity = require('./activity');
 
 module.exports = {
   // --- retired doorway leaks (ADR 0093 §3) ---------------------------------
@@ -58,6 +59,12 @@ module.exports = {
   recentGradesForBuilder: (...a) => db.recentGradesForBuilder(...a),
   countShippedTasksForBuilder: (...a) => db.countShippedTasksForBuilder(...a),
   recentShippedTasksByBuilder: (...a) => db.recentShippedTasksByBuilder(...a),
+  // builders.js (the profile's per-craft activity log, task 1003281): the paged
+  // "what did I do as an engineer / an artist" reads. Separate from the two
+  // above because those answer "how much, in total" and these answer "what,
+  // by craft" — the axis criterion legibility-activity-by-role asks for.
+  activityTasksByBuilder: (...a) => activity.activityTasksByBuilder(...a),
+  activityGoalsByBuilder: (...a) => activity.activityGoalsByBuilder(...a),
   // ADR 0120 part 5: the confirmed tasks a builder owes a rebase on — the same
   // read the part-3 claim gate uses, surfaced to me.js so the CLI + hall can
   // show the owed-rebase warning that gates new claims (reward lands on ship).

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.380",
+  "version": "1.19.382",
   "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/scripts/hall-preview/server.js

@@ -82,6 +82,11 @@ const FIXTURE_FALLBACKS = [
   [/^analytics\/builder\/\d+$/, 'analytics__builder'],
   [/^builders\/\d+\/active-claims$/, 'builders__active-claims'],
   [/^builders\/\d+\/profile$/, 'builders__profile'],
+  // the profile's per-craft activity log (task 1003281). One fixture per SECTION
+  // rather than per id, because the section is what changes the row shape; the
+  // craft and the page window are query string, which fixture matching ignores.
+  [/^builders\/\d+\/activity$/, (q) => (q.section === 'goals' ? 'builders__activity-goals' : 'builders__activity-tasks')],
+  [/^inbox\/by-builder\/\d+$/, 'inbox__by-builder'],
 ];
 
 function loadFixture(name) {
@@ -102,12 +107,17 @@ function emptied(v) {
   return v;
 }
 
-function fixtureFor(apiPath) {
+// A fallback name may be a plain string or a function of the query — the one
+// case that needs it (task 1003281) is the profile activity log, where the ROW
+// SHAPE is chosen by ?section=, not by the path, so one fixture per path would
+// render goal rows into the tasks ledger.
+function fixtureFor(apiPath, query = {}) {
   const exact = loadFixture(apiPath.replace(/\//g, '__'));
   if (exact !== undefined) return exact;
   for (const [re, name] of FIXTURE_FALLBACKS) {
     if (re.test(apiPath)) {
-      const hit = loadFixture(name);
+      const resolved = typeof name === 'function' ? name(query) : name;
+      const hit = resolved && loadFixture(resolved);
       if (hit !== undefined) return hit;
     }
   }
@@ -141,7 +151,7 @@ app.use((req, res, next) => {
   if (req.method !== 'GET') {
     return res.status(501).json({ error: { code: 'preview_readonly', message: 'the preview harness serves fixtures; writes are not wired' } });
   }
-  const fix = fixtureFor(apiPath);
+  const fix = fixtureFor(apiPath, req.query || {});
   if (fix === undefined) {
     console.log(`  no fixture: ${apiPath}  (add scripts/hall-preview/fixtures/${apiPath.replace(/\//g, '__')}.json)`);
     return res.status(404).json({ error: { code: 'no_fixture', message: apiPath } });

package/src/bongos/routes/builders.js

@@ -545,6 +545,73 @@ module.exports = function buildBuildersRouter() {
     }
   });
 
+  // GET /builders/:id/activity — the profile's PER-CRAFT activity log (task
+  // 1003281, goal 1000072, criterion legibility-activity-by-role).
+  //
+  // WHAT IT ADDS OVER /profile. The profile answers "how much has this person
+  // shipped" — one count and the last five works, craft-blind. A person's artist
+  // track record is a different question from their engineer one, so this route
+  // serves ONE section (`tasks` or `goals`) for ONE craft, paged. It EXTENDS the
+  // profile surface rather than forking it: the page is the same page, the
+  // identity band and the achievement shelf are unchanged, and this fills the
+  // ledger below them. The third section of that log — the IDEA TRAIL — is
+  // served by the ideas module's GET /inbox/by-builder/:id, because an idea is
+  // its domain's row, not a lifecycle one.
+  //
+  // ONE SECTION PER CALL, not all three in one payload: each ledger pages
+  // independently, and a single response carrying three page windows would need
+  // three limit/offset pairs on one query string to say anything at all.
+  //
+  // rank: any-builder, NOT owner-only — a track record is a thing other people
+  // read; that is what makes the profile a portfolio rather than a dashboard, and
+  // it is the same posture /profile, /builders/roster and the leaderboard already
+  // take toward the same rows. The per-viewer filtering that DOES matter is the
+  // private-goal wall below, and it is applied to the DATA, not to the caller.
+  //
+  // But, unlike /profile directly above, this read IS gated to a sign-in.
+  // The goals half is viewer-dependent: a private goal's title is exactly what
+  // ADR 0112 says a non-member must not learn, so the read needs to know who is
+  // asking. Serving it publicly would mean either leaking private goals or
+  // silently omitting the viewer's own — both worse than a sign-in. The tasks
+  // half is the same already-public shipped-work data /profile returns.
+  router.get('/builders/:id/activity', auth.requireBuilder, async (req, res) => {
+    const targetId = parseId(req, res, { code: 'bad_builder_id', positiveInt: true });
+    if (targetId === null) return;
+    const section = req.query.section === 'goals' ? 'goals' : 'tasks';
+    // An unknown craft is normalized to "no filter" inside the module read
+    // rather than 400ing here — a stale bookmark should show the whole record,
+    // not an error card in the middle of a profile.
+    const role = typeof req.query.role === 'string' && req.query.role ? req.query.role : null;
+    const limit = Number(req.query.limit);
+    const offset = Number(req.query.offset);
+    try {
+      const b = await db.getBuilderById(targetId);
+      if (!b) return res.fail('builder_not_found', 404);
+      const viewer = req.builder || {};
+      const out = section === 'goals'
+        ? await lc().activityGoalsByBuilder(targetId, {
+          role,
+          viewerId: viewer.id ?? null,
+          viewerIsArchon: viewer.rank === 'archon',
+          limit,
+          offset,
+        })
+        : await lc().activityTasksByBuilder(targetId, { role, limit, offset });
+      // Viewer-dependent (the goals half) and cheap to recompute — never cached.
+      res.set('Cache-Control', 'no-store');
+      res.json({
+        builder_id: targetId,
+        section,
+        role: role || null,
+        rows: out.rows,
+        total: out.total,
+      });
+    } catch (err) {
+      log.error('[gds] GET /builders/:id/activity', err);
+      res.fail('activity_read_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
   // GET /builders/me/pending-rank-change — V3.R28 / #249 ceremony signal #3.
   //
   // Returns the calling builder's most recent rank-change credit_log row, or

package/src/module-api.js

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