@bongos/core 1.19.380 → 1.19.382

package/modules/hall-ui/public/profile.js

@@ -242,6 +242,278 @@
     section.hidden = false;
   }
 
+  // ---- render: activity, by craft -----------------------------------------
+  //
+  // Task 1003281, goal 1000072 / criterion legibility-activity-by-role. The
+  // sections above answer "how much has this person shipped"; this one answers
+  // "what did they do, AS an engineer / an artist / an ideator" — a different
+  // question per craft, which is why it is a view per craft and not a filter.
+  //
+  // THE IDEA TRAIL is the part that exists nowhere else, and the reason the
+  // criterion was written: every other idea surface is scoped to what is still
+  // OPEN, so an idea drops out of the system the moment it is triaged — exactly
+  // when its outcome becomes interesting. Here nothing you filed ever leaves the
+  // list, and each row carries its verdict: became a task (linked), discarded
+  // (with the triager's note), merged into another idea (linked), or STILL OPEN.
+  // Open reads as open, never as an absence.
+  //
+  // WHY IT NEEDS A SIGN-IN when the rest of the page does not: idea titles and
+  // triage notes are builder-visible, not world-visible, and a private goal's
+  // title is what ADR 0112 says a non-member must not learn. Signed out, this
+  // one section says so and the public portfolio above it is untouched.
+  //
+  // PAGING IS SERVER-SIDE. A prolific builder's record is long and the criterion
+  // asks for *every* idea, so each ledger asks for one page at a time through
+  // OTBKit's server-offset pager mode — the kit's own mode, added by this task,
+  // rather than an eleventh hand-rolled pager (hall-ui/CLAUDE.md's hard rule).
+
+  // The craft tabs. 'all' leads because most tasks in the corpus carry
+  // discipline='unclassified': a page that only offered the four named crafts
+  // would hide the majority of a person's record and read as "you did less than
+  // you did". The four named crafts match the Goals page's Craft filter
+  // (goals-page.js f-goal-role) so the two surfaces speak one vocabulary.
+  const CRAFT_TABS = [
+    { id: 'all', label: 'All', role: null },
+    { id: 'engineer', label: 'Engineer', role: 'engineer' },
+    { id: 'artist', label: 'Artist', role: 'artist' },
+    { id: 'ideator', label: 'Ideator', role: 'ideator' },
+    { id: 'ui', label: 'UI', role: 'ui' },
+  ];
+  // Filing an idea is ideator work whatever craft the resulting task turned out
+  // to be, so the trail belongs to the ideator view — and to 'all', which is the
+  // whole record by definition. It is not a per-craft slice of the ideas.
+  const TRAIL_TABS = new Set(['all', 'ideator']);
+
+  // Every href below goes through BOTH encodings, and it needs both: the ids are
+  // DB integers today, but encodeURIComponent leaves a literal `'` alone, so on
+  // its own it is a URL encoder standing in for an HTML-attribute escape. escape
+  // the URL for the path, escape the result for the attribute (grader nit).
+  const hallBase = () => (location.hostname.startsWith('builders.') ? '' : '/builders');
+  const href = (pathStr) => escapeHtml(pathStr);
+  const taskHref = (id) => href(`${hallBase()}/task/${encodeURIComponent(id)}`);
+  const ideaHref = (id) => href(`${hallBase()}/idea/${encodeURIComponent(id)}`);
+  const goalHref = (id) => href(`${hallBase()}/goals#/goal/${encodeURIComponent(id)}`);
+
+  // What became of one idea, in a sentence a person can read. The four outcomes
+  // the criterion names, each linked through to the thing it became.
+  function ideaOutcomeHtml(idea) {
+    const note = idea.triage_note
+      ? `<span style="display:block;margin-top:2px;font-size:12px;color:var(--ink-faint)">${escapeHtml(idea.triage_note)}</span>`
+      : '';
+    if (idea.status === 'promoted') {
+      // ideas_task_lineage is the complete answer (one idea can become many
+      // tasks, task 1002997); promoted_to_task_id is the only answer for
+      // promotions that predate that table, so fall back to it.
+      const lineage = Array.isArray(idea.lineage_tasks) ? idea.lineage_tasks : [];
+      const links = lineage.length
+        ? lineage.map((t) => `<a href="${taskHref(t.task_id)}">#${escapeHtml(String(t.task_id))} ${escapeHtml(t.title || '')}</a>`)
+        : (idea.promoted_to_task_id
+          ? [`<a href="${taskHref(idea.promoted_to_task_id)}">#${escapeHtml(String(idea.promoted_to_task_id))} ${escapeHtml(idea.promoted_task_title || '')}</a>`]
+          : []);
+      // 'promoted' with nothing to point at is a real (old) state, not a bug to
+      // paper over — say what is known rather than inventing a link.
+      if (!links.length) return `<span class="task__tag">Promoted</span>${note}`;
+      return `<span class="task__tag">Became ${links.length === 1 ? 'a task' : `${links.length} tasks`}</span> ${links.join(' · ')}${note}`;
+    }
+    if (idea.status === 'merged') {
+      const target = idea.merged_into_idea_id
+        ? ` <a href="${ideaHref(idea.merged_into_idea_id)}">#${escapeHtml(String(idea.merged_into_idea_id))} ${escapeHtml(idea.merged_into_idea_title || '')}</a>`
+        : '';
+      return `<span class="task__tag">Merged into</span>${target}${note}`;
+    }
+    if (idea.status === 'discarded') {
+      return `<span class="task__tag">Discarded</span>${note}`;
+    }
+    return `<span class="task__tag">Still open</span>${note}`;
+  }
+
+  // One ledger driven by one server-paged endpoint. `fetchPage(offset, perPage)`
+  // resolves to { rows, total }; everything else — the pager wiring, the empty
+  // state, the reload-on-craft-change — is the same for all three lists, so it
+  // is written once here rather than three times below.
+  function makeActivityList({ mountId, storageKey, columns, rowHtml, emptyMsg, fetchPage }) {
+    const mount = $(`#${mountId}`);
+    if (!mount || !window.OTBKit) return null;
+    const pager = window.OTBKit.makePager(mountId, storageKey, { defaultPerPage: 10, minPerPage: 10 });
+    let inFlight = 0;
+    const ledger = window.OTBKit.makeLedger({
+      mount, columns, rowHtml, emptyMsg,
+      serverPager: pager,
+      onPage: () => load(),
+    });
+    async function load() {
+      const seq = ++inFlight;
+      try {
+        const out = await fetchPage(window.OTBKit.pageOffset(pager), pager.perPage);
+        // A craft switch or a fast pager click can land two loads at once; only
+        // the newest may paint, or the ledger shows a page nobody asked for.
+        if (seq !== inFlight) return;
+        ledger.render(out.rows, { total: out.total });
+        return out.total;
+      } catch (err) {
+        if (seq !== inFlight) return;
+        console.error(`[profile] activity list ${mountId} failed`, err);
+        ledger.render([], { total: 0 });
+      }
+      return null;
+    }
+    return { reset() { pager.page = 1; }, load, ledger };
+  }
+
+  // Built once, on first render, and kept — switching craft re-fetches, it does
+  // not rebuild the DOM (which would drop the reader's per-page preference).
+  let activity = null;
+
+  function buildActivity(builderId) {
+    const kit = window.OTBKit;
+    if (!kit) return null;
+    let role = null;
+
+    const tasks = makeActivityList({
+      mountId: 'activity-tasks',
+      storageKey: 'otb.profile.activityTasksPerPage',
+      columns: [
+        { label: '#', class: 'ledger__num' },
+        'Work',
+        { label: 'Craft' },
+        { label: 'Shipped', class: 'ledger__date' },
+      ],
+      emptyMsg: 'No completed works in this craft.',
+      fetchPage: async (offset, limit) => {
+        const res = await api.request('GET', `${API}/builders/${encodeURIComponent(builderId)}/activity`
+          + `?section=tasks&limit=${limit}&offset=${offset}${role ? `&role=${encodeURIComponent(role)}` : ''}`);
+        if (!res.ok) throw new Error(`activity tasks → ${res.status}`);
+        return { rows: res.data.rows || [], total: Number(res.data.total) || 0 };
+      },
+      rowHtml: (t) => {
+        const summary = t.value_summary
+          ? `<span style="display:block;margin-top:2px;font-size:12px;color:var(--ink-faint)">${escapeHtml(t.value_summary)}</span>`
+          : '';
+        const visual = kit.shipVisualThumbHtml ? kit.shipVisualThumbHtml(t) : '';
+        return `<tr>
+          <td class="ledger__num">#${escapeHtml(String(t.id))}</td>
+          <td><a href="${taskHref(t.id)}">${escapeHtml(t.title || `Task ${t.id}`)}</a>${summary}${visual ? `<span style="display:block;margin-top:6px">${visual}</span>` : ''}</td>
+          <td><span class="task__tag">${escapeHtml(t.discipline || 'unclassified')}</span></td>
+          <td class="ledger__date">${fmtDate(t.shipped_at)}</td>
+        </tr>`;
+      },
+    });
+
+    const goals = makeActivityList({
+      mountId: 'activity-goals',
+      storageKey: 'otb.profile.activityGoalsPerPage',
+      columns: [
+        { label: '#', class: 'ledger__num' },
+        'Goal',
+        'Crafts',
+        'Progress',
+      ],
+      emptyMsg: 'No goals created in this craft.',
+      fetchPage: async (offset, limit) => {
+        const res = await api.request('GET', `${API}/builders/${encodeURIComponent(builderId)}/activity`
+          + `?section=goals&limit=${limit}&offset=${offset}${role ? `&role=${encodeURIComponent(role)}` : ''}`);
+        if (!res.ok) throw new Error(`activity goals → ${res.status}`);
+        return { rows: res.data.rows || [], total: Number(res.data.total) || 0 };
+      },
+      rowHtml: (g) => {
+        const sub = g.subtitle
+          ? `<span style="display:block;margin-top:2px;font-size:12px;color:var(--ink-faint)">${escapeHtml(g.subtitle)}</span>`
+          : '';
+        const crafts = (Array.isArray(g.disciplines) ? g.disciplines : [])
+          .map((d) => `<span class="task__tag">${escapeHtml(d)}</span>`).join(' ') || '—';
+        const shipped = Number(g.task_shipped) || 0;
+        const total = Number(g.task_total) || 0;
+        return `<tr>
+          <td class="ledger__num">#${escapeHtml(String(g.id))}</td>
+          <td><a href="${goalHref(g.id)}">${escapeHtml(g.title || `Goal ${g.id}`)}</a>${sub}</td>
+          <td>${crafts}</td>
+          <td>${fmtNum(shipped)} of ${fmtNum(total)} shipped</td>
+        </tr>`;
+      },
+    });
+
+    const ideas = makeActivityList({
+      mountId: 'activity-ideas',
+      storageKey: 'otb.profile.activityIdeasPerPage',
+      columns: [
+        { label: '#', class: 'ledger__num' },
+        'Idea',
+        'What became of it',
+        { label: 'Filed', class: 'ledger__date' },
+      ],
+      emptyMsg: 'No ideas filed yet.',
+      fetchPage: async (offset, limit) => {
+        const res = await api.request('GET', `${API}/inbox/by-builder/${encodeURIComponent(builderId)}`
+          + `?limit=${limit}&offset=${offset}`);
+        if (!res.ok) throw new Error(`idea trail → ${res.status}`);
+        return { rows: res.data.ideas || [], total: Number(res.data.total) || 0 };
+      },
+      rowHtml: (i) => `<tr>
+          <td class="ledger__num">#${escapeHtml(String(i.id))}</td>
+          <td><a href="${ideaHref(i.id)}">${escapeHtml(i.title || `Idea ${i.id}`)}</a></td>
+          <td>${ideaOutcomeHtml(i)}</td>
+          <td class="ledger__date">${fmtDate(i.captured_at)}</td>
+        </tr>`,
+    });
+
+    // NO `panel` PER TAB, and that is deliberate. makeTabs toggles [hidden] on
+    // one panel PER TAB; here every craft shows the same three ledgers with
+    // different rows, so pointing all five tabs at one element would make the
+    // last tab's `hidden = (id !== 'ui')` win and blank the section. Omitting
+    // `panel` makes the toggle a no-op ($id(undefined) is null) and leaves this
+    // file owning what a craft change means: a re-fetch, not a panel swap.
+    const tabs = kit.makeTabs({
+      mount: $('#activity-tabs'),
+      tabs: CRAFT_TABS.map((t) => ({ id: t.id, label: t.label })),
+      onChange: (id) => {
+        const tab = CRAFT_TABS.find((t) => t.id === id) || CRAFT_TABS[0];
+        role = tab.role;
+        show(id);
+      },
+    });
+
+    function show(tabId) {
+      const trail = TRAIL_TABS.has(tabId);
+      const ideasPanel = $('#activity-ideas-panel');
+      if (ideasPanel) ideasPanel.hidden = !trail;
+      [tasks, goals].forEach((l) => { if (l) { l.reset(); l.load(); } });
+      if (trail && ideas) { ideas.reset(); ideas.load(); }
+    }
+
+    // makeTabs activates its initial tab during construction, which already ran
+    // onChange → show(). So the caller must NOT kick it again on first build.
+    return { show, active: () => tabs.active() || 'all' };
+  }
+
+  function renderActivity(builderId, signedIn) {
+    const section = $('#activity-scroll');
+    const placeholder = $('#activity-placeholder');
+    if (!section) return;
+    if (!signedIn) {
+      // The public portfolio above stays public; this one section says plainly
+      // why it is not, rather than rendering an empty log that reads as "this
+      // person did nothing".
+      if (placeholder) {
+        placeholder.hidden = false;
+        placeholder.innerHTML = `Idea trails and goals are visible to signed-in builders — `
+          + `<a href="${API}/auth/web/start">sign in</a> to see this builder's activity.`;
+      }
+      ['activity-tasks-panel', 'activity-goals-panel', 'activity-ideas-panel']
+        .forEach((id) => { const el = $(`#${id}`); if (el) el.hidden = true; });
+      const tabsMount = $('#activity-tabs');
+      if (tabsMount) tabsMount.innerHTML = '';
+      return;
+    }
+    if (placeholder) { placeholder.hidden = true; placeholder.innerHTML = ''; }
+    ['activity-tasks-panel', 'activity-goals-panel']
+      .forEach((id) => { const el = $(`#${id}`); if (el) el.hidden = false; });
+    if (!activity) {
+      activity = buildActivity(builderId);   // its makeTabs already loaded page 1
+      return;
+    }
+    activity.show(activity.active());
+  }
+
   // ---- states -------------------------------------------------------------
 
   function showMessage(text) {
@@ -259,6 +531,9 @@
     renderCrossProject(data, selfId);
     renderAchievements(data.achievements);
     renderWorks(data.recent_ships);
+    // The activity log needs a session (private goals + the idea trail), so it
+    // keys off whether /me resolved — the same signal the self-detect uses.
+    renderActivity(builder.id, selfId != null);
   }
 
   // Render the friendly "no builder chosen" empty state for a signed-out visitor
@@ -281,12 +556,16 @@
     const works = $('#works-table tbody'); if (works) works.innerHTML = '';
     const worksLede = $('#works-lede'); if (worksLede) worksLede.hidden = true;
     const xp = $('#xp-scroll'); if (xp) xp.hidden = true;
+    const act = $('#activity-scroll'); if (act) act.hidden = true;
   }
 
   async function fetchProfile(id, selfId) {
     const res = await api.request('GET', `${API}/builders/${encodeURIComponent(id)}/profile`);
     if (res.status === 404) {
       showMessage('No builder found with that id.');
+      // There is no builder, so there is no activity to log — hide the section
+      // rather than leaving its loading dots on a page about nobody.
+      const act = $('#activity-scroll'); if (act) act.hidden = true;
       return;
     }
     if (!res.ok) throw new Error(`profile → ${res.status}`);

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,
+};