@bongos/core 1.19.971 → 1.19.972

package/docs/module-api-changelog.md

@@ -2416,5 +2416,7 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.19.969 with no explicit bump. run 35804568036. (task 1002620)
   1.19.971 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.19.970 with no explicit bump. run 35805746484. (task 1002620)
+  1.19.972 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.971 with no explicit bump. run 35806478158. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/modules/hall-ui/public/goals-page.js

@@ -1052,6 +1052,12 @@
       // ADR 0174: the craft axis again, scoped to the tasks inside one goal.
       { id: 'f-goal-discipline', label: `Task ${window.OTB.roleAxisLabel().toLowerCase()}`, options: window.OTB.roleOptions({ unset: true }) }, // ADR 0174
       { id: 'f-goal-newcomer', label: 'Newcomer', options: [{ value: '', label: '— any —' }, { value: 'yes', label: 'newcomer-friendly only' }] },
+      // The board's "Only mine" lens, scoped to one goal. Inside a goal the
+      // membership half of that question is already answered (you are looking at
+      // one goal, and the page says whether you are on it), so what is left is the
+      // claim half: of the work queued here, what am I holding? Answered from
+      // state.claimsByTask, which the detail already loads for the Release button.
+      { id: 'f-goal-claimed', label: 'Mine', options: [{ value: '', label: '— anyone\'s —' }, { value: 'mine', label: 'claimed by me' }] },
       { id: 'f-goal-fit', label: 'Run mode', options: [{ value: '', label: '— any —' },
         { value: 'parallel', label: 'parallel-safe only' },
         { value: 'conflict', label: 'has file conflicts' }] },

package/modules/hall-ui/public/goals-render.js

@@ -111,7 +111,14 @@
       || !!(state.disciplines && state.disciplines.get(String(g.id))?.has(role));
     const matchesStale = (g) => !staleDays || isStale(goalActivityMs(g), staleDays);
     const myId = selfId();
+    // GET /goals now answers this on the row itself (`viewer_is_member`, an EXISTS
+    // over goal_members for the AUTHENTICATED reader), which is what this lens
+    // reads first. The per-goal detail is kept as the fallback, and the order
+    // matters: the detail prefetch is a best-effort fan-out, so on a slow or
+    // partly-failed boot the lens used to return NOTHING and say, in effect, "you
+    // are on no goals" — a claim about the reader, made out of a failed fetch.
     const iAmMember = (g) => {
+      if (typeof g.viewer_is_member === 'boolean') return g.viewer_is_member;
       const d = state.details.get(String(g.id));
       return d ? (d.members || []).some((m) => sameId(m.builder_id, myId)) : false;
     };
@@ -505,12 +512,21 @@
     const kFilter = $('#f-goal-kind')?.value || '';
     const dFilter = $('#f-goal-discipline')?.value || '';
     const nFilter = $('#f-goal-newcomer')?.value || '';
+    // "Mine" inside a goal = the claims this builder is holding here. Signed out
+    // there is no answer, so the lens is inert rather than emptying the list.
+    const myId = selfId();
+    const mineFilter = (myId != null && $('#f-goal-claimed')?.value === 'mine');
+    const claimedByMe = (t) => {
+      const c = state.claimsByTask.get(String(t.id));
+      return !!(c && sameId(c.builder_id, myId));
+    };
     const sortBy = $('#f-goal-sort')?.value || 'cpm';
     let list = state.work.todo.filter((t) => {
       if (!matchesTodoSearch(t, sQuery)) return false;
       if (kFilter && (t.kind || window.OTB.KIND_UNSET) !== kFilter) return false;
       if (dFilter && (t.discipline || window.OTB.ROLE_UNSET) !== dFilter) return false;
       if (nFilter === 'yes' && !t.newcomer_friendly) return false;
+      if (mineFilter && !claimedByMe(t)) return false;
       return true;
     });
     // Run-mode filter: parallel-safe (touches[] disjoint from the rest of the

package/modules/hall-ui/public/mine-lens.js

@@ -0,0 +1,172 @@
+'use strict';
+
+// modules/hall-ui/public/mine-lens.js — the hall's ONE definition of "mine":
+// the goals you are added on, and the tasks you have claimed.
+//
+// WHY IT IS A FILE AND NOT A BLOCK IN work.js. Two reasons, and the second is
+// the load-bearing one.
+//
+//   1. Two boards ask the same question. The Tasks board asks it of four tabs;
+//      the goal board asks it of its own list and of one goal's To-do queue. A
+//      second copy of "what counts as mine" is a copy that drifts — the exact
+//      failure task 1002463 carved task-lib.js to end, after the two boards had
+//      already disagreed about a refusal message.
+//   2. work.js sits at the fitness size ceiling (OVERSIZE_LINES = 1500 in
+//      scripts/gds/fitness-ratchets.js, baseline 0 oversized files). It had
+//      exactly zero lines of headroom, so the lens could not live there and the
+//      baseline is not the thing that gives — the same reason claim-feed.js and
+//      goals-render.js are their own files.
+//
+// THE WORD MEANS A DIFFERENT THING ON EACH SURFACE, and that is deliberate
+// rather than sloppy:
+//
+//   a queue of unclaimed work  → tasks sitting in a goal you are a member of
+//   a list of live claims      → the ones you are holding
+//   shipped history            → the ones you shipped
+//
+// Nothing here is claimable-feed-shaped or goal-board-shaped; each helper takes
+// the rows and the identity and returns the narrowed rows. Pure except for
+// `attach`, which owns the checkbox.
+//
+// Node-require-safe (the goals-lib.js / task-lib.js precedent) so a unit test
+// runs the real predicates instead of agreeing with a copy of them.
+(function (root, factory) {
+  var mod = factory();
+  if (typeof module !== 'undefined' && module.exports) module.exports = mod;
+  else root.OTBMineLens = mod;
+}(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+
+  // Ids compare as strings throughout: a claim row's builder_id arrives as a
+  // number from one feed and a bigint-as-string from another, and `===` on the
+  // raw values is how a viewer silently stops recognising their own work.
+  function sameId(a, b) {
+    return a != null && b != null && String(a) === String(b);
+  }
+
+  // The per-surface hint. The control is one checkbox, so the sentence beside it
+  // is what keeps it honest about which question this tab is answering.
+  var HINTS = {
+    ready: 'tasks in goals you are on',
+    backlog: 'tasks in goals you are on',
+    'in-progress': 'claims you are holding',
+    completed: 'tasks you shipped',
+  };
+  function hintFor(tabId) { return HINTS[String(tabId)] || ''; }
+
+  // ---- the three narrowings -------------------------------------------------
+
+  // Goal membership. `goalIds` is a Set of STRING goal ids the viewer is on.
+  // A task with NO goal is excluded: it belongs to nobody by membership, and
+  // letting it through would make the lens read as "mine, plus the orphans".
+  function inMyGoals(task, goalIds) {
+    return !!(task && goalIds && goalIds.has(String(task.goal_id)));
+  }
+  function narrowByGoal(rows, goalIds) {
+    return (rows || []).filter(function (t) { return inMyGoals(t, goalIds); });
+  }
+
+  // Live claims — the literal claim question.
+  function isMyClaim(claim, viewerId) {
+    return !!(claim && sameId(claim.builder_id, viewerId));
+  }
+  function narrowByClaim(rows, viewerId) {
+    return (rows || []).filter(function (c) { return isMyClaim(c, viewerId); });
+  }
+
+  // Shipped history. The feed behind it is the PUBLIC recent-shipped read, which
+  // names its shipper by github_login and carries no builder id — so this one
+  // matches on the login, and a caller without one must not narrow at all rather
+  // than narrow to nothing.
+  function narrowByShipper(rows, login) {
+    if (!login) return rows || [];
+    return (rows || []).filter(function (t) { return t && t.github_login === login; });
+  }
+
+  // Goal rows → the Set of ids the viewer is on. `viewer_is_member` is the flag
+  // GET /goals carries for the authenticated reader.
+  function myGoalIds(goals) {
+    var set = new Set();
+    (goals || []).forEach(function (g) {
+      if (g && g.viewer_is_member === true) set.add(String(g.id));
+    });
+    return set;
+  }
+
+  // ---- the control ----------------------------------------------------------
+
+  // attach({ box, wrap, hint, onChange }) — owns one checkbox and the sentence
+  // beside it. Elements are passed in (already resolved), so this file never
+  // learns a page's ids.
+  //
+  // The lens starts HIDDEN and identity-less. It is revealed by setViewer once
+  // an identity resolves, and `unavailable()` takes it away again when the
+  // evidence it depends on could not be read. Both matter for the same reason:
+  // a checkbox that silently empties every list is worse than one that plainly
+  // is not on offer.
+  function attach(opts) {
+    var o = opts || {};
+    var box = o.box || null;
+    var wrap = o.wrap || null;
+    var hint = o.hint || null;
+    var viewerId = null;
+    var goalIds = new Set();
+
+    if (box && o.onChange) box.addEventListener('change', o.onChange);
+
+    function known() { return viewerId != null && box != null && !box.disabled; }
+
+    return {
+      // Is the lens currently narrowing? False whenever there is no identity, so
+      // every caller can read it without repeating the guard.
+      on: function () { return !!(box && box.checked && known()); },
+      viewerId: function () { return viewerId; },
+
+      setTab: function (tabId) { if (hint) hint.textContent = hintFor(tabId); },
+      hide: function () { if (wrap) wrap.hidden = true; },
+
+      setViewer: function (id, whenUnknown) {
+        viewerId = id == null ? null : id;
+        if (wrap) wrap.hidden = false;
+        if (!box) return;
+        box.disabled = viewerId == null;
+        if (viewerId == null) {
+          box.checked = false;
+          box.title = whenUnknown || 'Sign in to filter to your own work';
+        }
+      },
+
+      setGoals: function (goals) { goalIds = myGoalIds(goals); },
+
+      // The membership read failed, so the lens has no evidence. Turning it off
+      // and SAYING SO is the honest failure: left live over an empty set it
+      // would narrow the queues to nothing and read as "you are on no goals",
+      // which is a different claim from "the board could not find out".
+      unavailable: function (why) {
+        if (!box) return;
+        box.checked = false;
+        box.disabled = true;
+        box.title = why || 'That could not be loaded — reload to filter to your own work';
+      },
+
+      // The three narrowings, with the lens's own state folded in so a caller
+      // never has to ask twice.
+      goals: function (rows) { return this.on() ? narrowByGoal(rows, goalIds) : (rows || []); },
+      claims: function (rows) { return this.on() ? narrowByClaim(rows, viewerId) : (rows || []); },
+      ships: function (rows, login) { return this.on() ? narrowByShipper(rows, login) : (rows || []); },
+      inMyGoals: function (task) { return inMyGoals(task, goalIds); },
+    };
+  }
+
+  return {
+    attach: attach,
+    hintFor: hintFor,
+    myGoalIds: myGoalIds,
+    inMyGoals: inMyGoals,
+    isMyClaim: isMyClaim,
+    narrowByGoal: narrowByGoal,
+    narrowByClaim: narrowByClaim,
+    narrowByShipper: narrowByShipper,
+    sameId: sameId,
+  };
+}));

package/modules/hall-ui/public/work-summary.js

@@ -0,0 +1,90 @@
+'use strict';
+
+// modules/hall-ui/public/work-summary.js — the Tasks board's "works completed"
+// momentum card (task 1469), lifted out of work.js.
+//
+// WHY IT MOVED. Two reasons, and neither is tidiness for its own sake.
+//
+//   1. It is not board machinery. Everything else in work.js is about claiming,
+//      releasing, filtering and selecting TASKS; this is three PROJECT-WIDE
+//      public statistics — total works shipped, total <currency> awarded, and
+//      the most recent ship — rendered as stat tiles above the Completed list.
+//      It shares no state with the claim path and reads no per-builder data.
+//   2. work.js sits ON the fitness size ceiling (OVERSIZE_LINES = 1500 in
+//      scripts/gds/fitness-ratchets.js, with the repo's baseline at zero
+//      oversized files). It had no headroom at all, so the Only-mine lens could
+//      not be added without something leaving, and the ratchet's own rule is to
+//      fix the regression rather than raise the baseline. This block is what
+//      leaves, because it is the piece with the fewest ties to the rest.
+//
+// NOT the viewer's own output — that lives on the profile page. All three
+// figures come from public reads (/public/progress, /public/cost-summary, and
+// the head of the recent-shipped feed the Completed list already loaded), which
+// is also why the "Only mine" lens does not touch this card: narrowing the list
+// below it must not restate the project's totals as one builder's.
+//
+// Node-require-safe (the goals-lib.js / mine-lens.js precedent) so a unit test
+// can exercise the real tile logic.
+(function (root, factory) {
+  var mod = factory();
+  if (typeof module !== 'undefined' && module.exports) module.exports = mod;
+  else root.OTBWorkSummary = mod;
+}(typeof self !== 'undefined' ? self : this, function () {
+  'use strict';
+
+  // create(deps) — deps are work.js's own helper variants (a date-only fmtDate,
+  // a relative fmtAgo, the branded currency label), passed in rather than
+  // re-derived so the card cannot drift from the page around it. `latestShip`
+  // is a getter, not a value: the head of the history feed changes as that feed
+  // lands and re-renders.
+  function create(deps) {
+    var d = deps || {};
+    var $ = d.$;
+    var esc = d.escapeHtml;
+    var fmtNum = d.fmtNum;
+    var fmtAgo = d.fmtAgo;
+    var curLabel = d.curLabel;
+    var latestShip = d.latestShip || function () { return null; };
+    var state = { progress: null, cost: null };
+
+    function tile(label, num, sub, subTitle) {
+      var subHtml = sub
+        ? '<span class="stat-tile__sub" ' + (subTitle ? 'title="' + esc(subTitle) + '" ' : '')
+          + 'style="white-space:nowrap;overflow:hidden;text-overflow:ellipsis">' + esc(sub) + '</span>'
+        : '';
+      return '<div class="stat-tile"><span class="stat-tile__label">' + esc(label) + '</span>'
+        + '<span class="stat-tile__num">' + esc(String(num)) + '</span>' + subHtml + '</div>';
+    }
+
+    function render() {
+      var host = $('#works-summary');
+      if (!host) return;
+      var versions = state.progress && Array.isArray(state.progress.progress) ? state.progress.progress : null;
+      // Wait for the shipped-count feed; the card stays hidden until then (and
+      // on a project that has shipped nothing).
+      if (!versions) { host.hidden = true; return; }
+      var shipped = versions.reduce(function (n, v) { return n + (Number(v.lifecycle_shipped_count) || 0); }, 0);
+      if (!shipped) { host.hidden = true; return; }
+      var awarded = state.cost ? Number(state.cost.total_value_credits) || 0 : null;
+      var latest = latestShip();
+
+      var tiles = [tile('Works shipped', fmtNum(shipped))];
+      if (awarded != null) tiles.push(tile(curLabel(true) + ' awarded', fmtNum(awarded)));
+      if (latest) {
+        tiles.push(tile('Latest ship', latest.shipped_at ? fmtAgo(latest.shipped_at) : '—',
+          latest.title || ('#' + latest.id), latest.title || ''));
+      }
+      host.innerHTML = tiles.join('');
+      host.hidden = false;
+    }
+
+    return {
+      // set() records a feed and repaints; either half may land first, and the
+      // card stays hidden until the shipped counts do.
+      set: function (progress, cost) { state.progress = progress; state.cost = cost; render(); },
+      render: render,
+    };
+  }
+
+  return { create: create };
+}));

package/modules/hall-ui/public/work.css

@@ -328,3 +328,53 @@
   .bulk-toolbar__actions { margin-left: 0; width: 100%; }
   body[data-page="work"] .app-content { padding-bottom: 200px; }
 }
+
+/* ---- "Only mine" lens (the board's tab-wide filter; goal board's To-do bar
+   borrows the same class) --------------------------------------------------
+   Deliberately QUIETER than the filter bar below it: a checkbox in the label
+   voice, not a fifth <select>. It is one binary question standing next to a bar
+   of dropdowns, and dressing it as one of them would have read as a sixth lens
+   with the same reach — which it does not have (each tab answers "mine"
+   differently; see the comment on #work-mine in work.html). */
+.mine-lens {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 4px 10px;
+  margin: 0 0 12px;
+  font-family: var(--label-face);
+  font-size: var(--label-size);
+  letter-spacing: var(--label-space);
+  text-transform: var(--label-case);
+  color: var(--ink-soft);
+}
+.mine-lens__lab {
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+  /* The board's 24px hit floor (task 1003304). The drawn box is 16px; the label
+     is the target, so the floor is bought here rather than by inflating the
+     control — the same trade the claimable card's checkbox makes. */
+  min-height: 24px;
+  cursor: pointer;
+}
+/* The checkbox is the hit target, so it gets a real one — 16px plus the label
+   text beside it clears the 24px touch floor without a bespoke control. */
+.mine-lens__lab input[type="checkbox"] {
+  width: 16px;
+  height: 16px;
+  margin: 0;
+  accent-color: var(--accent);
+  cursor: pointer;
+}
+.mine-lens__lab:has(input:disabled) { cursor: not-allowed; color: var(--ink-faint); }
+.mine-lens__lab input:disabled { cursor: not-allowed; }
+/* The hint carries the per-tab MEANING, so it reads as prose rather than as a
+   second label — the label case above would make it shout. */
+.mine-lens__hint {
+  text-transform: none;
+  letter-spacing: normal;
+  font-family: var(--font-body);
+  font-size: 12.5px;
+  color: var(--ink-faint);
+}

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

@@ -52,6 +52,26 @@
              Deep links: /work#in-progress etc. -->
         <nav id="work-tabs" aria-label="Task sections"></nav>
 
+        <!-- "Only mine" — ONE lens, and the only control on this page that is
+             live on all four tabs. It sits OUTSIDE #work-filters on purpose: that
+             bar drives the two queue tabs and hides on the other two (task
+             1003828 — a filter over a list it cannot narrow is a bug), whereas
+             this question has a true answer on every tab. What "mine" MEANS is
+             read from the tab, which is why the hint beside it is rewritten on
+             every switch rather than left as a generic word:
+               Ready / Backlog  → tasks sitting in a goal you are a member of
+               In Progress      → the claims you are holding right now
+               Completed        → what you shipped
+             Signed out, or an identity the page could not resolve, disables it
+             rather than offering a lens that would silently empty every list. -->
+        <div class="mine-lens" id="work-mine" hidden>
+          <label class="mine-lens__lab">
+            <input type="checkbox" id="f-mine">
+            <span>Only mine</span>
+          </label>
+          <span class="mine-lens__hint" id="work-mine-hint"></span>
+        </div>
+
         <!-- task 2170: the filter bar is built by OTBKit.makeFilterBar —
              Search / Sort / Version / Discipline primary (task 1003828 promoted
              Discipline out of the overflow: a craft is the axis this platform
@@ -160,6 +180,10 @@
 <script src="/builders/hall-kit.js" defer></script>
 <!-- shared TASK-DOMAIN helpers (window.OTBTaskLib) — priority/touches/prompt/refusal-copy, one copy for both boards (task 1002463). -->
 <script src="/builders/task-lib.js" defer></script>
+<!-- the hall's one definition of "mine" (window.OTBMineLens) — goals you are on, claims you hold, ships you made; shared with the goal board. -->
+<script src="/builders/mine-lens.js" defer></script>
+<!-- the Completed tab's project-wide momentum card (window.OTBWorkSummary), carved out of work.js. -->
+<script src="/builders/work-summary.js" defer></script>
 <script src="/builders/task-detail.js?v=2026-07-03-taskdetail" defer></script>
 <script src="/builders/brand-apply.js?v=2026-06-19-r56" defer></script>
 <script src="/builders/work.js?v=2026-07-03-workboard3" defer></script>

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

@@ -194,7 +194,7 @@
 
   // task 2170: the four sections are hash-synced tabs (Ready default). Built in
   // wireEvents; renders feed the tab count pills via setTabCount.
-  let workTabs = null;
+  let workTabs = null, mine = null;   // mine: the Only-mine lens (mine-lens.js)
   function setTabCount(id, n) { if (workTabs) workTabs.setCount(id, n); }
 
   // A section-header count pill: reveal it and set its number once data lands.
@@ -216,11 +216,11 @@
     // reflects the TOTAL active-claim count, even on the empty path below.
     const all = liveState.active;
     const isMine = (c) => viewer.id != null && Number(c.builder_id) === Number(viewer.id);
-    const rows = all.slice().sort((a, b) => (isMine(b) ? 1 : 0) - (isMine(a) ? 1 : 0));
-    setCountPill('#wip-count', all.length);
+    const rows = mine.claims(all).slice().sort((a, b) => (isMine(b) ? 1 : 0) - (isMine(a) ? 1 : 0));
+    setCountPill('#wip-count', rows.length);
     setTabCount('in-progress', all.length);
     if (!rows.length) {
-      tbody.innerHTML = `<tr><td colspan="6" class="ledger__empty">No tasks are in progress right now.</td></tr>`;
+      tbody.innerHTML = `<tr><td colspan="6" class="ledger__empty">${mine.on() ? 'You are not holding any claims right now.' : 'No tasks are in progress right now.'}</td></tr>`;
       pagers.wip.page = 1;
       const wp = $('#wip-pager');
       if (wp) wp.hidden = true;
@@ -265,7 +265,7 @@
   // Live view context. viewerId lets renderInFlight decide which active claims
   // are the viewer's own (→ a Release action). active holds the last in-flight
   // payload so a poll can re-render claim ages without another round-trip.
-  const viewer = { id: null };
+  const viewer = { id: null, login: null };
   const liveState = { active: [] };
   // Guards against double-firing an action while its request is in flight.
   const pending = new Set();
@@ -323,6 +323,7 @@
   function boardFilterValues() {
     const val = (id) => ($(id) ? $(id).value : '');
     return {
+      mine: !!(mine && mine.on()),
       search: searchQuery(),
       version: val('#f-version'),
       goal: val('#f-goal'),
@@ -337,6 +338,7 @@
   // Does one task survive the current lenses? Pure over (task, values) so both
   // feeds narrow alike and a new filter cannot reach one tab alone.
   function matchesBoardFilters(t, f) {
+    if (f.mine && !mine.inMyGoals(t)) return false;   // "mine" on a QUEUE tab = a goal I am on
     if (!matchesSearch(t, f.search)) return false;
     if (f.version && t.version_id !== f.version) return false;
     // task 1755: goal filter. '__none__' isolates tasks with no goal.
@@ -374,6 +376,7 @@
   function syncFilterBarVisibility(tabId) {
     const bar = $('#work-filters');
     if (bar) bar.hidden = !FILTERED_TABS.has(String(tabId));
+    if (mine) mine.setTab(tabId);
   }
 
   function renderClaimable() {
@@ -1015,45 +1018,14 @@
   let historyRows = [];
 
   // ---- task 1469: project-wide "works completed" momentum summary ----------
-  //
-  // A compact card above the Completed list summarizing the WHOLE project's
-  // shipped output (NOT the viewer's own — that lives on the profile page): total
-  // works shipped (all-time, summed from /public/progress lifecycle_shipped_count),
-  // total <currency> awarded (/public/cost-summary total_value_credits), and the
-  // most recent ship (the head of the recent-shipped feed already loaded for the
-  // history list). All three are public reads; no per-builder data.
-  let worksSummary = { progress: null, cost: null };
-
-  function summaryTile(label, num, sub, subTitle) {
-    const subHtml = sub
-      ? `<span class="stat-tile__sub" ${subTitle ? `title="${escapeHtml(subTitle)}" ` : ''}style="white-space:nowrap;overflow:hidden;text-overflow:ellipsis">${escapeHtml(sub)}</span>`
-      : '';
-    return `<div class="stat-tile"><span class="stat-tile__label">${escapeHtml(label)}</span>` +
-      `<span class="stat-tile__num">${escapeHtml(String(num))}</span>${subHtml}</div>`;
-  }
-
-  function renderWorksSummary() {
-    const root = $('#works-summary');
-    if (!root) return;
-    const versions = worksSummary.progress && Array.isArray(worksSummary.progress.progress)
-      ? worksSummary.progress.progress : null;
-    // Wait for the shipped-count feed; the card stays hidden until then (and on a
-    // project that has shipped nothing).
-    if (!versions) { root.hidden = true; return; }
-    const shipped = versions.reduce((n, v) => n + (Number(v.lifecycle_shipped_count) || 0), 0);
-    if (!shipped) { root.hidden = true; return; }
-    const awarded = worksSummary.cost ? Number(worksSummary.cost.total_value_credits) || 0 : null;
-    const latest = Array.isArray(historyRows) && historyRows.length ? historyRows[0] : null;
-
-    const tiles = [summaryTile('Works shipped', fmtNum(shipped))];
-    if (awarded != null) tiles.push(summaryTile(`${curLabel(true)} awarded`, fmtNum(awarded)));
-    if (latest) {
-      tiles.push(summaryTile('Latest ship', latest.shipped_at ? fmtAgo(latest.shipped_at) : '—',
-        latest.title || `#${latest.id}`, latest.title || ''));
-    }
-    root.innerHTML = tiles.join('');
-    root.hidden = false;
-  }
+  // The card itself is work-summary.js — three PUBLIC project figures, not board
+  // machinery, and the piece that left when the Only-mine lens arrived and this
+  // file had no room under the fitness size ceiling. It reads the head of the
+  // history feed, so `latestShip` is a getter rather than a value.
+  const worksSummary = window.OTBWorkSummary.create({
+    $, escapeHtml, fmtNum, fmtAgo, curLabel,
+    latestShip: () => (Array.isArray(historyRows) && historyRows.length ? historyRows[0] : null),
+  });
 
   function renderHistory(tasks) {
     if (Array.isArray(tasks)) historyRows = tasks;
@@ -1061,11 +1033,11 @@
     if (!root) return;
     // task 2170: section visibility is tab-owned now — the render only fills
     // the panel and feeds the counts.
-    const rows = historyRows;
+    const rows = mine.ships(historyRows, viewer.login);
     setCountPill('#done-count', rows.length);
-    setTabCount('completed', rows.length);
+    setTabCount('completed', historyRows.length);
     if (!rows.length) {
-      root.innerHTML = `<div class="profile__placeholder">Nothing shipped yet.</div>`;
+      root.innerHTML = `<div class="profile__placeholder">${mine.on() ? 'None of the recently shipped tasks are yours.' : 'Nothing shipped yet.'}</div>`;
       pagers.done.page = 1;
       const dp = $('#done-pager');
       if (dp) dp.hidden = true;
@@ -1085,7 +1057,7 @@
     }).join('');
     // task 1469: now that historyRows is populated, (re)render the momentum card so
     // its "Latest ship" tile reflects the newest shipped task.
-    renderWorksSummary();
+    worksSummary.render();
   }
 
   // ---- backlog (not-yet-ready tasks) ---------------------------------------
@@ -1197,6 +1169,7 @@
     if (gate) gate.hidden = false;
     const tabsMount = $('#work-tabs');
     if (tabsMount) tabsMount.hidden = true;
+    if (mine) mine.hide();
     for (const id of ['claim-scroll', 'wip-scroll', 'backlog-scroll', 'history-scroll']) {
       const el = document.getElementById(id);
       if (el) el.hidden = true;
@@ -1217,6 +1190,8 @@
       throw err;
     }
     viewer.id = me?.builder?.id ?? null;
+    viewer.login = me?.builder?.github_login ?? null;
+    mine.setViewer(viewer.id, 'Sign in to filter to your own goals and claims');
     // task 1003453 — the Kind lens, from the served vocabulary. Optional-called so an
     // older cached dom-utils.js costs one lens, not the board; see OTB.fillKindFilter.
     window.OTB.fillKindFilter?.($('#f-kind'), me?.task_kinds);
@@ -1243,8 +1218,7 @@
       getJSON(`${API}/public/progress`).catch(() => null),
       getJSON(`${API}/public/cost-summary`).catch(() => null),
     ]).then(([progress, cost]) => {
-      worksSummary = { progress, cost };
-      renderWorksSummary();
+      worksSummary.set(progress, cost);
     });
 
     // task 1754: the Backlog group — not-yet-ready tasks. Best-effort + independent
@@ -1264,11 +1238,15 @@
         taskState.goalTitles[g.id] = g.title;
         taskState.goalCategories[g.id] = g.category || null;
       });
+      mine.setGoals(gr.goals || []);
       // task 1003828 — loadBacklog() fires ABOVE this await, so its first paint
       // has no titles and every row would read "Goal #1000089" until something
       // else repainted it. Harmless if the feed has not landed yet.
       renderBacklog();
-    } catch (_) { /* filter labels fall back to 'Goal #id' */ }
+    } catch (_) {
+      /* filter labels fall back to 'Goal #id' */
+      mine.unavailable('Goal membership could not be loaded — reload to filter to your own goals');
+    }
 
     // Claimable + active claims in one call. A 403 means the primer gate — show
     // the friendly notice and hide the claim queue, but keep the in-flight list
@@ -1412,6 +1390,15 @@
       },
     });
 
+    mine = window.OTBMineLens.attach({
+      box: $('#f-mine'), wrap: $('#work-mine'), hint: $('#work-mine-hint'),
+      onChange: () => {
+        if (selectionTotal()) clearSelection();
+        for (const p of Object.values(pagers)) p.page = 1;
+        renderClaimable(); renderBacklog(); renderInFlight(); renderHistory();
+      },
+    });
+
     // task 1003828 — makeTabs fires onChange only on a CHANGE and restores a
     // deep-linked tab before this point, so the opening state is set explicitly:
     // without it, a reload onto #completed shows a filter bar over ship history.

package/modules/lifecycle/db-goals.js

@@ -395,18 +395,35 @@ async function getGoalDependencies(goalId, deps = {}) {
 // table to `g` would have been tidier and would have rewritten four lines whose
 // literal text tests/goal_tier.mjs pins ("priority-first, then stable
 // ordering"). An additive change should read as additive in the diff.
-async function listGoals({ versionId = null, status = null, limit = null } = {}, deps = {}) {
+//
+// `viewerId` adds `viewer_is_member` — is the READER of this list one of this
+// goal's members? The "My goals" lens on the goal board used to answer that from
+// the per-goal DETAIL prefetch, which meant the lens silently returned NOTHING
+// whenever that best-effort fan-out had not landed (or had failed), and the Tasks
+// board could not ask the question at all without N extra requests. One EXISTS on
+// a list the client already fetches answers it for both.
+//
+// `null` viewerId yields `false` everywhere, never NULL: an unauthenticated or
+// identity-less read gets a well-formed row whose answer is "not yours", which is
+// the truthful answer and keeps the wire shape one type. EXISTS (not a LEFT JOIN)
+// for the `admitted` reason directly above — goal_members is keyed
+// (goal_id, builder_id) so a join could not duplicate today, but the shape of the
+// query should not depend on that.
+async function listGoals({ versionId = null, status = null, limit = null, viewerId = null } = {}, deps = {}) {
   const activePool = (deps.pool && process.env.NODE_ENV === 'test') ? deps.pool : pool;
   const { rows } = await activePool.query(
     `SELECT ${GOAL_COLS},
             EXISTS (SELECT 1 FROM lifecycle_goal_version_admissions a
-                     WHERE a.goal_id = goals.id) AS admitted
+                     WHERE a.goal_id = goals.id) AS admitted,
+            ($4::bigint IS NOT NULL
+              AND EXISTS (SELECT 1 FROM goal_members gm
+                           WHERE gm.goal_id = goals.id AND gm.builder_id = $4::bigint)) AS viewer_is_member
        FROM goals
       WHERE ($1::text IS NULL OR version_id = $1)
         AND ($2::text IS NULL OR status = $2)
       ORDER BY version_id, sort_order, created_at, id
       LIMIT $3::int`,
-    [versionId, status, limit]
+    [versionId, status, limit, viewerId]
   );
   return rows;
 }