@bongos/core 1.19.381 → 1.19.383

package/migrations/core_228_idea_inbox_captured_by_idx.sql

@@ -0,0 +1,61 @@
+-- core_228_idea_inbox_captured_by_idx.sql — task 1003281 (grader panel finding,
+-- efficiency worker, on the goal-1000072 activity log).
+--
+-- THE ACTIVITY LOG IS THE FIRST SURFACE THAT ASKS "WHAT DID *THIS PERSON* DO".
+-- Every read that came before scoped by version, by status, or by goal, so those
+-- are the columns that got indexed. Three per-person predicates arrived with this
+-- task, each on a route any signed-in builder can hit repeatedly — once per
+-- profile load, again per craft switch, again per pager click — and each paired
+-- with a COUNT(*) that has no LIMIT to escape through. Unindexed, all three
+-- sequentially scan a shared table on every one of those requests.
+--
+-- 1. idea_inbox (captured_by, captured_at DESC) — THE FLAGGED ONE.
+--    Migration 006 indexed `status` and `captured_at`, exactly right for every
+--    idea read that existed until now: all of them are scoped to what is still
+--    OPEN and ordered newest-first. `captured_by` was never a predicate.
+--    GET /inbox/by-builder/:id inverts that — it drops the status filter entirely
+--    (a triaged idea must NOT leave the trail; that IS the criterion) and scopes
+--    on the author instead.
+--
+-- 2. tasks (shipped_by, shipped_at DESC) WHERE status = 'shipped' — the works
+--    half. The only existing index on `shipped_by` is core_193's, partial on
+--    `WHERE needs_rebase`, which cannot serve this at all. PARTIAL on the status
+--    because the predicate is always `status = 'shipped'` and shipped tasks are a
+--    minority of the table: the index stays small and every row in it is a row
+--    the query wants.
+--
+-- 3. tasks (goal_id) — the goals half's rollup CTE derives each goal's craft set
+--    and progress from its tasks, and nothing indexed `goal_id` (migration 160
+--    added the column and an FK, not an index). This one is the broadest win
+--    here: it is the join every per-goal rollup in the codebase makes.
+--
+-- EQUALITY LEADS, SORT TRAILS, in 1 and 2. The btree seeks straight to one
+-- person's rows and then walks them already ordered, so the page window stops at
+-- LIMIT instead of sorting a whole history to return ten rows. A bare
+-- (captured_by) index would serve the COUNT and leave the list with a sort.
+--
+-- DELIBERATELY NOT INDEXED: goals.created_by. The `mine` CTE filters it, but the
+-- goals table holds tens of rows, not thousands — an index there would cost more
+-- to maintain than the scan it replaces. Revisit if a project ever carries
+-- thousands of goals.
+--
+-- NOT THE MODULE'S MIGRATION, deliberately. `idea_inbox` and `tasks` are CORE
+-- tables (both predate the module system), and fitness.js
+-- checkModuleMigrationsAdditive hard-fails a CREATE INDEX against a
+-- non-`ideas_`-prefixed table from modules/ideas/migrations/ (ADR 0083
+-- §Decision #5). Task 1002447 hit the same wall — core_195 began life as
+-- ideas_001 — so this lands in core beside it.
+--
+-- Additive and reversible: an index carries no data and no constraint, so a
+-- rollback is a DROP INDEX and nothing depends on it for correctness, only for
+-- speed. This migration changes no column, no type and no row.
+CREATE INDEX IF NOT EXISTS idx_idea_inbox_captured_by
+  ON idea_inbox (captured_by, captured_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_tasks_shipped_by_shipped_at
+  ON tasks (shipped_by, shipped_at DESC) WHERE status = 'shipped';
+
+CREATE INDEX IF NOT EXISTS idx_tasks_goal ON tasks (goal_id);
+
+INSERT INTO schema_migrations (version) VALUES ('core_228_idea_inbox_captured_by_idx')
+ON CONFLICT (version) DO NOTHING;

package/modules/dev-box/app/src/vendor/bongos-client.cjs

@@ -222,6 +222,8 @@ function createClient(opts = {}) {
     "builders": {
       // GET /builders/{id}/active-claims — rank: metic+archon — GET /builders/:id/active-claims
       getBuildersIdActiveClaims: (args) => request("GET", "/builders/{id}/active-claims", { hasBody: false }, args),
+      // GET /builders/{id}/activity — rank: any-builder — GET /builders/:id/activity
+      getBuildersIdActivity: (args) => request("GET", "/builders/{id}/activity", { hasBody: false }, args),
       // PATCH /builders/{id}/budget — rank: metic+archon — PATCH /builders/:id/budget
       patchBuildersIdBudget: (args) => request("PATCH", "/builders/{id}/budget", { hasBody: true }, args),
       // GET /builders/{id}/onboarding — rank: public — GET /builders/:id/onboarding
@@ -440,6 +442,8 @@ function createClient(opts = {}) {
       postInboxIdSpark: (args) => request("POST", "/inbox/{id}/spark", { hasBody: true }, args),
       // GET /inbox/awaiting-nod — rank: metic+archon — GET /inbox/awaiting-nod
       getInboxAwaitingNod: (args) => request("GET", "/inbox/awaiting-nod", { hasBody: false }, args),
+      // GET /inbox/by-builder/{id} — rank: any-builder — GET /inbox/by-builder/:id
+      getInboxByBuilderId: (args) => request("GET", "/inbox/by-builder/{id}", { hasBody: false }, args),
       // POST /inbox/score — rank: any-builder — POST /inbox/score
       postInboxScore: (args) => request("POST", "/inbox/score", { hasBody: true }, args),
       // GET /inbox/sparks — rank: any-builder — GET /inbox/sparks

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

@@ -115,6 +115,43 @@
     if (sel && sel.value !== String(p.perPage)) sel.value = String(p.perPage);
   }
 
+  // ---- server-offset paging (task 1003281) -----------------------------------
+  //
+  // `paginate()` above slices an array the browser already holds. Some lists
+  // cannot be held: the profile's activity log pages ONE builder's whole record,
+  // and hall-ui/CLAUDE.md's own rule says that when you need a server-offset
+  // pager you add the mode to the kit rather than hand-rolling a second copy
+  // (sessions.js is the one grandfathered hand-roll, audited task 2179).
+  //
+  // The pager object is the SAME object — page, perPage, per-page persistence
+  // and wirePager all work unchanged. Only the slicing moves: the caller asks
+  // the server for `pageOffset(p)`..`+perPage` and then reports back what it got
+  // with `renderServerPage`. That keeps ONE pager contract in the kit instead of
+  // two, which is the whole reason this lives here.
+
+  // Row offset of the pager's current page — what a `?offset=` query takes.
+  function pageOffset(p) {
+    return Math.max(0, (p.page - 1) * p.perPage);
+  }
+
+  // Paint the bar for a server-paged list: `total` is the server's count of the
+  // whole filtered set, `shownCount` the rows this page actually returned.
+  // Clamps `p.page` down when the set shrank under the caller (a re-filter, a
+  // background change) and returns true when it did — the caller re-fetches, so
+  // the bar and the rows can never disagree about which page is showing.
+  function renderServerPage(p, total, shownCount) {
+    const totalPages = Math.max(1, Math.ceil(total / p.perPage));
+    const clamped = p.page > totalPages || p.page < 1;
+    if (clamped) p.page = Math.min(Math.max(1, p.page), totalPages);
+    const offset = pageOffset(p);
+    // "Showing 11–13 of 12" is what an unclamped count reads as when the rows
+    // and the total come from two statements that disagree. The total is the
+    // authority for the range, so the shown count can never run past it.
+    const shown = Math.max(0, Math.min(shownCount, total - offset));
+    renderPagerBar(p, total, totalPages, offset, shown);
+    return clamped;
+  }
+
   // Wire a pager's controls once. `rerender` re-renders that list; a per-page
   // change resets to page 1 and persists. Fills the per-page <select> from the
   // pager's own options so pagerBarHtml stays option-agnostic.
@@ -136,35 +173,57 @@
   }
 
   // ---- ledger ----------------------------------------------------------------
-  // makeLedger({ mount, columns, rowHtml, emptyMsg, emptyAction?, pager? })
+  // makeLedger({ mount, columns, rowHtml, emptyMsg, emptyAction?, pager?, serverPager?, onPage? })
   // Stamps the standard table.ledger (+ pager bar when a pager is given) into
-  // `mount` and returns { el, tbody, render(rows) }. `columns` entries are
+  // `mount` and returns { el, tbody, render(rows, opts) }. `columns` entries are
   // strings or { label, class }. `rowHtml(row, i)` returns a <tr> string —
   // callers keep full control of cells (and must esc() their own data).
-  function makeLedger({ mount, columns = [], rowHtml, emptyMsg = 'Nothing here yet.', emptyAction = null, pager = null }) {
+  //
+  // `pager` slices client-side (the browser holds the whole list). `serverPager`
+  // is the same pager object driving a SERVER-offset list (task 1003281): the
+  // rows handed to render() are already one page, so nothing is sliced, and the
+  // caller passes `{ total }` — the server's count of the whole set — so the bar
+  // can say "of N". Page/per-page clicks call `onPage(pageOffset(p))`; the
+  // caller fetches and calls render() again. Pass one or the other, never both.
+  function makeLedger({
+    mount, columns = [], rowHtml, emptyMsg = 'Nothing here yet.', emptyAction = null,
+    pager = null, serverPager = null, onPage = null,
+  }) {
     if (!mount || typeof rowHtml !== 'function') {
       throw new Error('makeLedger({ mount, columns, rowHtml, … }) requires mount + rowHtml()');
     }
+    if (pager && serverPager) {
+      throw new Error('makeLedger: pass pager (client-sliced) OR serverPager (server-offset), not both');
+    }
     const head = columns.map((c) => {
       const col = typeof c === 'string' ? { label: c } : c;
       return `<th${col.class ? ` class="${esc(col.class)}"` : ''}>${esc(col.label)}</th>`;
     }).join('');
+    const bar = pager || serverPager;
     mount.innerHTML = `
       <table class="ledger">
         <thead><tr>${head}</tr></thead>
         <tbody></tbody>
       </table>
-      ${pager ? pagerBarHtml(pager.prefix, { label: 'rows' }) : ''}`;
+      ${bar ? pagerBarHtml(bar.prefix, { label: 'rows' }) : ''}`;
     const tbody = mount.querySelector('tbody');
     let last = [];
-    function render(rows) {
+    let lastTotal = 0;
+    function render(rows, opts = {}) {
       if (Array.isArray(rows)) last = rows;
-      const slice = pager ? paginate(last, pager) : last;
+      if (typeof opts.total === 'number') lastTotal = opts.total;
+      let slice = last;
+      if (pager) slice = paginate(last, pager);
+      else if (serverPager) renderServerPage(serverPager, lastTotal, last.length);
       tbody.innerHTML = slice.length
         ? slice.map((r, i) => rowHtml(r, i)).join('')
         : `<tr><td class="ledger__empty" colspan="${columns.length || 1}">${emptyStateHtml(emptyMsg, emptyAction)}</td></tr>`;
     }
     if (pager) wirePager(pager, () => render());
+    // A server-paged ledger cannot re-render from what it holds — it has to go
+    // ask. wirePager has already moved p.page by the time onPage runs, so the
+    // offset it hands over is the NEW page's.
+    if (serverPager) wirePager(serverPager, () => { if (onPage) onPage(pageOffset(serverPager)); });
     return { el: mount, tbody, render };
   }
 
@@ -552,6 +611,8 @@
     esc,
     // pager (low-level exports so pages can adopt incrementally)
     makePager, pagerBarHtml, paginate, renderPagerBar, wirePager,
+    // server-offset paging (task 1003281) — same pager object, server slicing
+    pageOffset, renderServerPage,
     // composed primitives
     makeLedger, makeFilterBar, makeTabs, makeSectionRail,
     // states

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

@@ -75,6 +75,38 @@
           </table>
         </section>
 
+        <!-- Activity, by craft — task 1003281, goal 1000072 / criterion
+             legibility-activity-by-role. A view per role over the same record:
+             the tasks this builder completed, the goals they created, and (in
+             the ideator view) every idea they filed with what became of it.
+             All three ledgers page server-side; profile.js fills them. -->
+        <section class="scroll" id="activity-scroll" aria-labelledby="activity-h">
+          <h2 id="activity-h" class="scroll__h">Activity, by craft</h2>
+          <p class="scroll__lede" id="activity-lede">What this builder has done, seen one craft at a time.</p>
+          <div id="activity-tabs"></div>
+          <div id="activity-body">
+            <div class="profile__placeholder" id="activity-placeholder">…</div>
+
+            <div id="activity-tasks-panel" hidden>
+              <h3 class="scroll__h">Works completed</h3>
+              <div id="activity-tasks"></div>
+            </div>
+
+            <div id="activity-goals-panel" hidden>
+              <h3 class="scroll__h">Goals created</h3>
+              <div id="activity-goals"></div>
+            </div>
+
+            <!-- The idea trail. Revealed only in the craft views where filing an
+                 idea is the work being shown (all + ideator) — see profile.js. -->
+            <div id="activity-ideas-panel" hidden>
+              <h3 class="scroll__h">Ideas filed, and what became of them</h3>
+              <p class="scroll__lede">Every idea this builder captured — promoted, discarded, merged, or still open.</p>
+              <div id="activity-ideas"></div>
+            </div>
+          </div>
+        </section>
+
         <!-- Reserved slots — connections, guilds, and actions (profile-page
              spec sections 6–8) mount here in later phases; keeping the order
              fixed now means the page is not re-laid-out twice (Decision 5). -->
@@ -97,7 +129,7 @@
 <script src="/builders/brand-apply.js?v=2026-06-27-r75"></script>
 <!-- hall-kit (window.OTBKit) — profile.js renders ship-time task visuals through
      its shared thumbnail helper (task 1003109), so it must load first. -->
-<script src="/builders/hall-kit.js?v=2026-08-25-visual"></script>
-<script src="/builders/profile.js?v=2026-08-25-visual"></script>
+<script src="/builders/hall-kit.js?v=2026-08-27-activity"></script>
+<script src="/builders/profile.js?v=2026-08-27-activity"></script>
 </body>
 </html>

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}`);