@bongos/core 1.19.381 → 1.19.383

package/modules/ideas/inbox.js

@@ -554,6 +554,97 @@ async function countOpenIdeas({ viewerRank = null } = {}) {
   return rows[0].n;
 }
 
+// -------------------------------------------------------------------------
+// The idea TRAIL — every idea one builder filed, and what became of it
+// (task 1003281, goal 1000072, criterion legibility-activity-by-role).
+//
+// THE READ THAT EXISTS NOWHERE ELSE, and the reason the criterion was written:
+// the owner could file an idea and then never find out what happened to it.
+// Every other idea read is scoped to what is STILL OPEN — listOpenIdeas, the
+// spark queue, the nod queue — so a promoted, discarded or merged idea drops
+// out of every surface the moment it is triaged, which is exactly when its
+// outcome becomes interesting. This read is scoped to a PERSON instead of to a
+// status, so nothing they filed ever leaves it.
+//
+// NO NEW STORAGE. The four outcomes are already on the row: `status` says which
+// one, `promoted_to_task_id` + ideas_task_lineage say which task a promotion
+// produced, `merged_into_idea_id` says which idea absorbed a merge, and
+// `triage_note` carries the triager's sentence (core_195, task 1002447). The
+// joins below turn those ids into names so a reader gets "became task #1003281
+// — See what you did, by role" rather than a number they must go look up.
+//
+// AN OPEN IDEA IS AN OUTCOME. It reads as "still open", never as an absence —
+// one of the four the criterion names. That is why status is returned verbatim
+// and the surface renders it, rather than the read filtering open rows out.
+//
+// LINEAGE, NOT JUST THE LEGACY COLUMN. One idea can become MANY tasks
+// (ideas_task_lineage, task 1002997), while `promoted_to_task_id` holds only the
+// first. Both are returned: the lineage array is the complete answer, the legacy
+// column is the only answer for promotions that predate the lineage table. The
+// LATERAL is bounded by the page window, so this stays one query, not an N+1.
+const IDEA_TRAIL_DEFAULT_LIMIT = 20;
+const IDEA_TRAIL_MAX_LIMIT = 100;
+
+// The WHERE this list and its count share, so the pager can never claim rows the
+// list will not show. viewerRank applies the SAME skill-friction gate as every
+// other idea read (V3.R70 / #289) — including on a builder reading their OWN
+// trail: the gate is about what a rank may see, not about authorship.
+function ideaTrailWhere(builderId, viewerRank, params) {
+  params.push(builderId);
+  const where = [`i.captured_by = $${params.length}`];
+  if (!rankCanSeeSkillFriction(viewerRank)) {
+    params.push(`${SKILL_FRICTION_TAG}%`);
+    where.push(`i.title NOT LIKE $${params.length}`);
+  }
+  return where.join(' AND ');
+}
+
+async function listIdeaTrailForBuilder(builderId, { limit = IDEA_TRAIL_DEFAULT_LIMIT, offset = 0, viewerRank = null } = {}, deps = {}) {
+  const activePool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : pool;
+  const lim = Math.min(Math.max(Number.isInteger(Number(limit)) ? Number(limit) : IDEA_TRAIL_DEFAULT_LIMIT, 1), IDEA_TRAIL_MAX_LIMIT);
+  const off = Number.isInteger(Number(offset)) && Number(offset) > 0 ? Number(offset) : 0;
+  const params = [];
+  const where = ideaTrailWhere(builderId, viewerRank, params);
+  params.push(lim, off);
+  const { rows } = await activePool.query(
+    `SELECT ${IDEA_COLS_Q}, ${GRADE_COLS_Q},
+            pt.title  AS promoted_task_title,
+            pt.status AS promoted_task_status,
+            mi.title  AS merged_into_idea_title,
+            mi.status AS merged_into_idea_status,
+            COALESCE(lin.tasks, '[]'::json) AS lineage_tasks
+       FROM idea_inbox i
+       ${IDEA_JOIN_GRADE}
+       LEFT JOIN tasks pt ON pt.id = i.promoted_to_task_id
+       LEFT JOIN idea_inbox mi ON mi.id = i.merged_into_idea_id
+       LEFT JOIN LATERAL (
+         SELECT json_agg(json_build_object(
+                  'task_id', l.task_id, 'origin', l.origin,
+                  'title', lt.title, 'status', lt.status
+                ) ORDER BY l.task_id) AS tasks
+           FROM ideas_task_lineage l
+           JOIN tasks lt ON lt.id = l.task_id
+          WHERE l.idea_id = i.id
+       ) lin ON true
+      WHERE ${where}
+      ORDER BY i.captured_at DESC, i.id DESC
+      LIMIT $${params.length - 1} OFFSET $${params.length}`,
+    params
+  );
+  return rows;
+}
+
+async function countIdeaTrailForBuilder(builderId, { viewerRank = null } = {}, deps = {}) {
+  const activePool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : pool;
+  const params = [];
+  const where = ideaTrailWhere(builderId, viewerRank, params);
+  const { rows } = await activePool.query(
+    `SELECT count(*)::int AS n FROM idea_inbox i WHERE ${where}`,
+    params
+  );
+  return rows[0].n;
+}
+
 // -------------------------------------------------------------------------
 // Update / merge
 // -------------------------------------------------------------------------
@@ -1298,6 +1389,13 @@ module.exports = {
   // the spark queue (task 1002921, BV1.R145) — sparks awaiting development
   listSparkQueue,
   countSparkQueue,
+  // the idea TRAIL (task 1003281) — every idea one builder filed, with what
+  // became of it. Scoped to a person, not to a status, so a triaged idea never
+  // drops out of the one surface that answers "what happened to my idea".
+  listIdeaTrailForBuilder,
+  countIdeaTrailForBuilder,
+  IDEA_TRAIL_DEFAULT_LIMIT,
+  IDEA_TRAIL_MAX_LIMIT,
   // criterion-proposal ratification (V3.R31 / #252)
   ratifyCriterionProposal,
   parseProposalBody,

package/modules/ideas/routes/inbox.js

@@ -470,6 +470,45 @@ module.exports = function buildInboxRouter() {
     ]);
     return res.json({ sparks, count });
   }, { errorCode: 'spark_queue_failed' }));
+  // rank: any-builder — THE IDEA TRAIL: every idea one builder filed, newest
+  // first, with what became of each (task 1003281, goal 1000072, criterion
+  // legibility-activity-by-role). Backs the ideator view of the profile's
+  // activity log; the tasks and goals halves of that log are served by the core
+  // GET /builders/:id/activity, because they are lifecycle rows, not ideas.
+  //
+  // WHY IT IS A LIST ROUTE AND NOT A FIELD ON THE PROFILE: the trail is paged.
+  // A prolific filer's trail is long, and the criterion asks for "every idea you
+  // submitted", so it cannot be a top-N attached to another response.
+  //
+  // Gated to any signed-in builder, matching GET /inbox/:id directly below: idea
+  // TITLES and triage notes are builder-visible, not world-visible, and the
+  // public profile route deliberately carries none of them. The viewer's rank
+  // rides into the read so the skill-friction gate holds here as it does on
+  // every other idea list.
+  //
+  // DECLARED BEFORE `GET /inbox/:id` DELIBERATELY — the fourth route in this file
+  // to need that. `/inbox/by-builder/41` would otherwise bind `:id='by-builder'`
+  // and parseId would 400 the whole trail. tests/profile_activity.mjs pins the
+  // relative order.
+  router.get('/inbox/by-builder/:id', api.requireBuilder, api.asyncHandler('GET /inbox/by-builder/:id', async (req, res) => {
+    const builderId = parseId(req, res, { code: 'bad_builder_id', positiveInt: true });
+    if (builderId === null) return;
+    const limitRaw = Number(req.query.limit);
+    const limit = Number.isInteger(limitRaw) && limitRaw > 0 && limitRaw <= inbox.IDEA_TRAIL_MAX_LIMIT
+      ? limitRaw
+      : inbox.IDEA_TRAIL_DEFAULT_LIMIT;
+    const offsetRaw = Number(req.query.offset);
+    const offset = Number.isInteger(offsetRaw) && offsetRaw > 0 ? offsetRaw : 0;
+    // Both halves take the viewer's rank so the count above the list can never
+    // claim rows the list will not show (the /inbox/sparks precedent).
+    const viewerRank = req.builder && req.builder.rank;
+    const [ideas, total] = await Promise.all([
+      inbox.listIdeaTrailForBuilder(builderId, { limit, offset, viewerRank }),
+      inbox.countIdeaTrailForBuilder(builderId, { viewerRank }),
+    ]);
+    return res.json({ builder_id: builderId, ideas, total, limit, offset });
+  }, { errorCode: 'idea_trail_failed' }));
+
   // rank: any-builder — single idea read for the "#NNN" deep-link resolver
   // (#1047). Mirrors GET /blockers/:id. The hall resolves /#/idea/N by id, but
   // the /inbox LIST returns only the open-first-50, so a closed/older idea ref

package/modules/lifecycle/activity.js

@@ -0,0 +1,205 @@
+'use strict';
+
+// modules/lifecycle/activity.js — a builder's OWN track record, sliced by craft
+// (task 1003281, goal 1000072, criterion legibility-activity-by-role).
+//
+// WHY IT EXISTS. The profile already answers "how much has this person shipped"
+// (a count and the last five works). It could not answer "what did I do AS an
+// artist", which is a different question from the engineer one and the reason
+// the criterion asks for a view per role. These two reads are that axis: the
+// tasks a builder completed and the goals they created, both filterable by
+// craft and both PAGED — a prolific builder's record is long, and the goal's
+// own scale check ("~1,357 tasks on BONGOS-V1 alone") applies to one person's
+// slice of it too.
+//
+// "ROLE" HERE MEANS CRAFT — tasks.discipline (engineer | artist | ideator | ui |
+// unclassified), the axis ADR 0086 already has and ADR 0174 reserves the word
+// "role" for. A goal has no discipline column and deliberately must not get one
+// (the same call task 1003278 made for the Goals page): a goal's craft set is
+// what its tasks carry, derived here, never stored.
+//
+// UNCLASSIFIED IS NOT HIDDEN. Most tasks in the corpus carry
+// discipline='unclassified', so a surface that only ever showed the four named
+// crafts would silently drop the majority of a person's record and read as
+// "you did less than you did". Passing no craft returns everything — that is
+// the profile's default view, and the per-craft tabs narrow from it.
+//
+// PRIVATE GOALS STAY PRIVATE (ADR 0112's leak rule). A goal's prose — its title
+// and subtitle — is the secret a non-member must not learn, so a private goal
+// appears in this read ONLY for a member of it or an Archon. That makes the
+// goals half viewer-dependent, which is why the route that serves it is
+// signed-in rather than public.
+//
+// THE BOUNDARY (ADR 0093 §1): this file reaches core ONLY through the published
+// doorway ../../src/module-api.js — never a core internal, never a sibling module.
+
+const api = require('../../src/module-api');
+const { pool } = api;
+const { SMOKE_NOT_LIKE } = require('./db-shared.js');
+const { CREDITS_AWARDED_SUBQUERY } = require('./db-tasks.js');
+
+// The craft vocabulary this read accepts. Mirrors tasks_discipline_check
+// (migrations 086 + 176). Anything else is treated as "no filter" rather than
+// 400ing the read: a caller naming a craft that does not exist gets the honest
+// full list, not an error card in the middle of a profile.
+const CRAFTS = ['engineer', 'artist', 'ideator', 'ui', 'unclassified'];
+
+// One page of an activity list. Clamped here as well as at the route, because
+// these are the functions a CLI or a later surface will call directly.
+const DEFAULT_LIMIT = 20;
+const MAX_LIMIT = 100;
+
+function normalizeCraft(role) {
+  return CRAFTS.includes(role) ? role : null;
+}
+
+function clampLimit(limit) {
+  const n = Number(limit);
+  if (!Number.isInteger(n) || n < 1) return DEFAULT_LIMIT;
+  return Math.min(n, MAX_LIMIT);
+}
+
+function clampOffset(offset) {
+  const n = Number(offset);
+  return Number.isInteger(n) && n > 0 ? n : 0;
+}
+
+// activityTasksByBuilder — the tasks this builder COMPLETED, newest first.
+//
+// "Completed" is `shipped_by = me AND status = 'shipped'` — the same definition
+// the profile's Recent works already uses (recentShippedTasksByBuilder), so the
+// ledger and the count above it cannot disagree. Smoke tasks are excluded for
+// the same reason they are excluded there: they are the ship pipeline testing
+// itself, not something a person did.
+//
+// Returns { rows, total } — the total counts the whole filtered set, not the
+// page, so the pager can say "of N" without a second call site inventing it.
+async function activityTasksByBuilder(builderId, { role = null, limit = DEFAULT_LIMIT, offset = 0 } = {}, deps = {}) {
+  const activePool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : pool;
+  const craft = normalizeCraft(role);
+  const lim = clampLimit(limit);
+  const off = clampOffset(offset);
+
+  const params = [builderId];
+  let where = `t.shipped_by = $1 AND t.status = 'shipped' AND t.${SMOKE_NOT_LIKE}`;
+  if (craft) {
+    params.push(craft);
+    where += ` AND COALESCE(t.discipline, 'unclassified') = $${params.length}`;
+  }
+
+  const { rows: countRows } = await activePool.query(
+    `SELECT count(*)::int AS total FROM tasks t WHERE ${where}`,
+    params
+  );
+
+  const pageParams = [...params, lim, off];
+  const { rows } = await activePool.query(
+    `SELECT t.id, t.title, t.value_summary, t.visual_url, t.visual_alt,
+            t.version_id, t.goal_id, t.kind, t.status, t.shipped_at,
+            COALESCE(t.discipline, 'unclassified') AS discipline,
+            t.credits_reward, ${CREDITS_AWARDED_SUBQUERY} AS credits_awarded
+       FROM tasks t
+      WHERE ${where}
+      ORDER BY t.shipped_at DESC NULLS LAST, t.id DESC
+      LIMIT $${pageParams.length - 1} OFFSET $${pageParams.length}`,
+    pageParams
+  );
+  return { rows, total: countRows[0]?.total ?? 0 };
+}
+
+// activityGoalsByBuilder — the goals this builder CREATED, newest first, with
+// the craft set their tasks carry and a readiness line.
+//
+// created_by is the goal's owner (task 1735), which is what "what did I create"
+// means on this tier — holding a membership in someone else's goal is a
+// different claim and is deliberately not folded in here.
+//
+// THE CRAFT FILTER APPLIES TO THE GOAL'S TASKS, not to the goal: a goal counts
+// as artist work when at least one of its tasks is artist work. A goal with no
+// tasks at all therefore matches NO craft filter and appears only in the
+// unfiltered view — which is honest, because nothing has been done in it yet.
+//
+// VISIBILITY. `visibility='private'` goals are returned only to a member or an
+// Archon (ADR 0112: a non-member must not learn a private goal's title). The
+// filter is in SQL rather than a JS post-pass so the count and the page window
+// agree — thinning rows after a LIMIT would make the pager lie.
+async function activityGoalsByBuilder(
+  builderId,
+  { role = null, viewerId = null, viewerIsArchon = false, limit = DEFAULT_LIMIT, offset = 0 } = {},
+  deps = {}
+) {
+  const activePool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : pool;
+  const craft = normalizeCraft(role);
+  const lim = clampLimit(limit);
+  const off = clampOffset(offset);
+
+  // $1 creator · $2 viewer · $3 archon flag, then an optional craft.
+  const params = [builderId, viewerId ?? null, !!viewerIsArchon];
+  let craftClause = '';
+  if (craft) {
+    params.push(craft);
+    craftClause = `AND $${params.length} = ANY(c.disciplines)`;
+  }
+
+  // The rollup CTE is scoped to this builder's goals only, so it never walks the
+  // whole tasks table — the reason this is a join over `mine` rather than a call
+  // into the version-wide goalRollups() read.
+  const base = `
+    WITH mine AS (
+      SELECT g.id, g.version_id, g.title, g.subtitle, g.status, g.visibility,
+             g.created_at, g.updated_at
+        FROM goals g
+       WHERE g.created_by = $1
+         AND (g.visibility = 'public'
+              OR $3::boolean
+              OR EXISTS (SELECT 1 FROM goal_members gm
+                          WHERE gm.goal_id = g.id AND gm.builder_id = $2::bigint))
+    ), c AS (
+      SELECT t.goal_id,
+             array_agg(DISTINCT COALESCE(t.discipline, 'unclassified')) AS disciplines,
+             count(*)::int AS task_total,
+             count(*) FILTER (WHERE t.status = 'shipped')::int AS task_shipped,
+             max(GREATEST(COALESCE(t.updated_at, 'epoch'::timestamptz),
+                          COALESCE(t.shipped_at, 'epoch'::timestamptz))) AS last_activity_at
+        FROM tasks t
+       WHERE t.goal_id IN (SELECT id FROM mine)
+         AND t.${SMOKE_NOT_LIKE}
+       GROUP BY t.goal_id
+    )`;
+
+  const { rows: countRows } = await activePool.query(
+    `${base}
+     SELECT count(*)::int AS total
+       FROM mine m LEFT JOIN c ON c.goal_id = m.id
+      WHERE true ${craftClause}`,
+    params
+  );
+
+  const pageParams = [...params, lim, off];
+  const { rows } = await activePool.query(
+    `${base}
+     SELECT m.id, m.version_id, m.title, m.subtitle, m.status, m.visibility,
+            m.created_at, m.updated_at,
+            COALESCE(c.disciplines, ARRAY[]::text[]) AS disciplines,
+            COALESCE(c.task_total, 0) AS task_total,
+            COALESCE(c.task_shipped, 0) AS task_shipped,
+            c.last_activity_at
+       FROM mine m LEFT JOIN c ON c.goal_id = m.id
+      WHERE true ${craftClause}
+      ORDER BY m.created_at DESC, m.id DESC
+      LIMIT $${pageParams.length - 1} OFFSET $${pageParams.length}`,
+    pageParams
+  );
+  return { rows, total: countRows[0]?.total ?? 0 };
+}
+
+module.exports = {
+  CRAFTS,
+  DEFAULT_LIMIT,
+  MAX_LIMIT,
+  activityGoalsByBuilder,
+  activityTasksByBuilder,
+  clampLimit,
+  clampOffset,
+  normalizeCraft,
+};

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.381",
+  "version": "1.19.383",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.381",
+      "version": "1.19.383",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

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

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