@bongos/core 1.17.1 → 1.17.3

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

@@ -36,6 +36,8 @@
   // file's exact variants (date-only fmtDate; a 2200ms clearing toast).
   // fmtAgo / toAuth / getJSON / postJSON stay local below.
   const { escapeHtml, $, fmtNum } = window.OTB;
+  // Shared component kit (hall-kit.js, task 2166): tabs, pager, filter bar.
+  const { makePager, paginate, wirePager, pagerBarHtml, makeTabs, makeFilterBar } = window.OTBKit;
   const fmtDate = (iso) => window.OTB.fmtDate(iso);
   const toast = (msg) => window.OTB.toast(msg, { duration: 2200, clear: true });
   const curLabel = (caps) => { const l = (window.__BRANDING__ && window.__BRANDING__.currency && window.__BRANDING__.currency.label) || 'credits'; return caps ? l.charAt(0).toUpperCase() + l.slice(1) : l; };
@@ -102,25 +104,11 @@
     return data;
   }
 
-  // ---- paginated lists: per-page dropdown + Prev/Next (task 1931/1955) -------
-  // All four Work-page lists (In Progress, Ready, Completed, Backlog) paginate
-  // the same way, through one shared helper. Each list owns a `pager` (page +
-  // per-page, persisted to its own localStorage key) and a DOM id `prefix`;
-  // renderPagerBar paints `#<prefix>-{pager,range,page,prev,next,per-page}`.
-  // Page/per-page live in module scope so a background poll / action refresh
-  // re-renders on the SAME page — only an explicit filter/per-page change resets.
-  const PER_PAGE_OPTIONS = [10, 25, 50, 100];
-  const MIN_PER_PAGE = PER_PAGE_OPTIONS[0]; // ≤ this fits one page — hide the bar
-  const DEFAULT_PER_PAGE = 25;
-  function loadPerPage(key, fallback) {
-    try {
-      const v = Number(window.localStorage.getItem(key));
-      return PER_PAGE_OPTIONS.includes(v) ? v : fallback;
-    } catch (_) { return fallback; }
-  }
-  function makePager(prefix, key) {
-    return { prefix, key, page: 1, perPage: loadPerPage(key, DEFAULT_PER_PAGE) };
-  }
+  // ---- paginated lists (task 1931/1955 → kit, task 2170) --------------------
+  // All four Work-page lists paginate through the shared OTBKit pager (the
+  // canonical copy of the helper that used to live here). localStorage keys are
+  // unchanged so builders' per-page prefs survive. The bar markup is stamped
+  // into the #<prefix>-pager-mount divs at boot (wireEvents) via pagerBarHtml.
   const pagers = {
     wip: makePager('wip', 'otb.work.wipPerPage'),
     ready: makePager('ready', 'otb.work.readyPerPage'),
@@ -128,6 +116,11 @@
     backlog: makePager('backlog', 'otb.work.backlogPerPage'),
   };
 
+  // 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;
+  function setTabCount(id, n) { if (workTabs) workTabs.setCount(id, n); }
+
   // A section-header count pill: reveal it and set its number once data lands.
   function setCountPill(sel, n) {
     const el = $(sel);
@@ -136,53 +129,6 @@
     el.textContent = String(n);
   }
 
-  // Slice `list` to the pager's current page (clamped — the filtered list may
-  // have shrunk under a poll), paint the bar, and return the slice to render.
-  // The bar hides when the whole list fits one minimum page.
-  function paginate(list, p) {
-    const total = list.length;
-    const totalPages = Math.max(1, Math.ceil(total / p.perPage));
-    if (p.page > totalPages) p.page = totalPages;
-    if (p.page < 1) p.page = 1;
-    const start = (p.page - 1) * p.perPage;
-    const slice = list.slice(start, start + p.perPage);
-    renderPagerBar(p, total, totalPages, start, slice.length);
-    return slice;
-  }
-
-  function renderPagerBar(p, total, totalPages, start, shownCount) {
-    const pager = $(`#${p.prefix}-pager`);
-    if (!pager) return;
-    if (total <= MIN_PER_PAGE) { pager.hidden = true; return; }
-    pager.hidden = false;
-    const range = $(`#${p.prefix}-range`);
-    if (range) range.textContent = total
-      ? `Showing ${start + 1}–${start + shownCount} of ${total}`
-      : 'Showing 0 of 0';
-    const ind = $(`#${p.prefix}-page`);
-    if (ind) ind.textContent = `Page ${p.page} of ${totalPages}`;
-    const prev = $(`#${p.prefix}-prev`);
-    if (prev) prev.disabled = p.page <= 1;
-    const next = $(`#${p.prefix}-next`);
-    if (next) next.disabled = p.page >= totalPages;
-    const sel = $(`#${p.prefix}-per-page`);
-    if (sel && sel.value !== String(p.perPage)) sel.value = String(p.perPage);
-  }
-
-  // Wire a pager's controls once (per-page dropdown + Prev/Next). `rerender`
-  // re-renders that list; a per-page change resets to page 1 and persists.
-  function wirePager(p, rerender) {
-    $(`#${p.prefix}-per-page`)?.addEventListener('change', (e) => {
-      const v = Number(e.target.value);
-      if (!PER_PAGE_OPTIONS.includes(v)) return;
-      p.perPage = v; p.page = 1;
-      try { window.localStorage.setItem(p.key, String(v)); } catch (_) { /* private mode → in-memory only */ }
-      rerender();
-    });
-    $(`#${p.prefix}-prev`)?.addEventListener('click', () => { if (p.page > 1) { p.page -= 1; rerender(); } });
-    $(`#${p.prefix}-next`)?.addEventListener('click', () => { p.page += 1; rerender(); });
-  }
-
   // ---- 1a. live in-flight list (active claims) -----------------------------
 
   function renderInFlight(active) {
@@ -196,6 +142,7 @@
     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);
+    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>`;
       pagers.wip.page = 1;
@@ -378,8 +325,10 @@
 
     const count = $('#claim-count');
     if (count) count.textContent = `${list.length} ${list.length === 1 ? 'task' : 'tasks'} waiting`;
-    // task 1899: header count pill reflects the filtered-list length.
+    // task 1899: header count pill reflects the filtered-list length; the tab
+    // pill (task 2170) carries the FULL ready count, filters notwithstanding.
     setCountPill('#ready-count', list.length);
+    setTabCount('ready', taskState.all.length);
 
     if (!list.length) {
       root.innerHTML = `<div class="profile__placeholder">No tasks match these filters. Try widening them.</div>`;
@@ -405,9 +354,11 @@
         ? '<span class="task__tag task__tag--newcomer">newcomer</span>'
         : '';
       const rankTag = rankTagHtml(t.requires_rank);
+      // task 2170 density pass: the multi-line path dump becomes a compact
+      // "✎ N files" chip in the meta row; the full list rides the tooltip.
       const touches = Array.isArray(t.touches) ? t.touches : [];
-      const touchesLine = touches.length
-        ? `<div class="task__touches" title="Files this task is responsible for">✎ ${touches.map(escapeHtml).join(', ')}</div>`
+      const touchesChip = touches.length
+        ? `<span class="task__touches" title="${escapeHtml(touches.join('\n'))}">✎ ${touches.length} file${touches.length === 1 ? '' : 's'}</span>`
         : '';
       const selected = selection.claim.has(String(t.id));
       return `
@@ -428,8 +379,8 @@
               ${t.priority ? `<span class="task__tag">${escapeHtml(t.priority)}</span>` : ''}
               <span>${minutesText}</span>
               <span>${cpmText}</span>
+              ${touchesChip}
             </div>
-            ${touchesLine}
           </div>
           <div class="task__credits">
             <span class="task__credits-num">${fmtNum(window.OTBBranding?.taskCreditValue?.(t) ?? t.credits_reward)}</span>
@@ -437,13 +388,26 @@
           </div>
           <div class="task__actions">
             <button class="task__claim" type="button" data-task-id="${t.id}" aria-label="Claim task ${t.id}">Claim</button>
-            <button class="task__copy" type="button" data-task-id="${t.id}" title="Copy the task prompt to your clipboard" aria-label="Copy prompt for task ${t.id}"><span class="task__copy-icon" aria-hidden="true">📋</span><span class="task__copy-label">Copy prompt</span></button>
+            <button class="task__copy" type="button" data-task-id="${t.id}" title="Copy the task prompt to your clipboard" aria-label="Copy prompt for task ${t.id}"><span class="task__copy-icon" aria-hidden="true">📋</span></button>
           </div>
         </div>
       `;
     }).join('');
   }
 
+  // task 2170: the filter bar restores URL-query state at build time, but the
+  // Version/Goal selects fill their options LATER (from /versions and the
+  // claimable feed) — so a shared URL's value has nothing to select against
+  // until now. Returns true when it changed the control.
+  function restoreUrlFilter(id) {
+    const want = new URLSearchParams(window.location.search).get(id);
+    const sel = $(`#${id}`);
+    if (!want || !sel || sel.value === want) return false;
+    if (![...sel.options].some((o) => o.value === want)) return false;
+    sel.value = want;
+    return true;
+  }
+
   function populateVersionFilter(versions) {
     const sel = $('#f-version');
     if (!sel) return;
@@ -990,11 +954,11 @@
     if (Array.isArray(tasks)) historyRows = tasks;
     const root = $('#history-list');
     if (!root) return;
-    // task 1754: reveal the Completed group only when there are shipped tasks.
-    const scroll = $('#history-scroll');
-    if (scroll) scroll.hidden = !historyRows.length;
+    // task 2170: section visibility is tab-owned now — the render only fills
+    // the panel and feeds the counts.
     const rows = historyRows;
     setCountPill('#done-count', rows.length);
+    setTabCount('completed', rows.length);
     if (!rows.length) {
       root.innerHTML = `<div class="profile__placeholder">Nothing shipped yet.</div>`;
       pagers.done.page = 1;
@@ -1029,16 +993,17 @@
 
   function renderBacklog(tasks) {
     if (Array.isArray(tasks)) backlogRows = tasks;
-    const scroll = $('#backlog-scroll');
     const root = $('#backlog-list');
     if (!root) return;
-    // Hide the whole section only when there's genuinely no backlog; when a
-    // search is active but filters everything out, keep the section visible so
-    // the "0 tasks" count explains the empty list (task 1829).
-    if (!backlogRows.length) { if (scroll) scroll.hidden = true; return; }
+    // task 2170: section visibility is tab-owned now. The tab pill carries the
+    // full backlog count; the heading count reflects the search-filtered list.
+    setTabCount('backlog', backlogRows.length);
+    if (!backlogRows.length) {
+      root.innerHTML = '<div class="profile__placeholder">Nothing in the backlog right now.</div>';
+      return;
+    }
     const q = searchQuery();
     const list = q ? backlogRows.filter((t) => matchesSearch(t, q)) : backlogRows;
-    if (scroll) scroll.hidden = false;
     const countEl = $('#backlog-count');
     if (countEl) countEl.textContent = `${list.length} ${list.length === 1 ? 'task' : 'tasks'}`;
     const shown = paginate(list, pagers.backlog);
@@ -1094,10 +1059,17 @@
   // ---- gate notice (signed in, primer not yet read) ------------------------
 
   function showClaimGate() {
+    // task 2170: the primer gate replaces the whole tabbed board (the claimable
+    // feed and active-claims read are both primer-gated server-side, so every
+    // tab would be empty-but-misleading). Gate notice on, tabs + panels off.
     const gate = $('#gate-scroll');
-    const claim = $('#claim-scroll');
     if (gate) gate.hidden = false;
-    if (claim) claim.hidden = true;
+    const tabsMount = $('#work-tabs');
+    if (tabsMount) tabsMount.hidden = true;
+    for (const id of ['claim-scroll', 'wip-scroll', 'backlog-scroll', 'history-scroll']) {
+      const el = document.getElementById(id);
+      if (el) el.hidden = true;
+    }
   }
 
   // ---- bootstrap -----------------------------------------------------------
@@ -1163,10 +1135,14 @@
       ]);
       taskState.versions = versionsResp.versions || [];
       populateVersionFilter(taskState.versions);
+      restoreUrlFilter('f-version');
       renderInFlight(claimResp.active_claims || []);
       taskState.all = claimResp.claimable || [];
       renderClaimable();
       populateGoalFilter(); // task 1755
+      // task 2170: a shared URL's goal filter can only apply once the options
+      // exist — restore it now and re-render if it changed anything.
+      if (restoreUrlFilter('f-goal')) renderClaimable();
       pruneSelection();
       renderBulkToolbar();
     } catch (err) {
@@ -1182,31 +1158,90 @@
   }
 
   function wireEvents() {
-    // task 1931: any filter/sort change re-paginates the Ready list from page 1.
-    const onReadyFilterChange = () => { pagers.ready.page = 1; renderClaimable(); };
-    $('#f-version')?.addEventListener('change', onReadyFilterChange);
-    $('#f-goal')?.addEventListener('change', onReadyFilterChange);
-    $('#f-kind')?.addEventListener('change', onReadyFilterChange);
-    $('#f-discipline')?.addEventListener('change', onReadyFilterChange);
-    $('#f-newcomer')?.addEventListener('change', onReadyFilterChange);
-    $('#f-fit')?.addEventListener('change', onReadyFilterChange);
-    $('#f-sort')?.addEventListener('change', onReadyFilterChange);
-    // task 1829: free-text search — 'input' fires on every keystroke and on the
-    // type=search clear (✕). Re-render BOTH the claimable and backlog lists,
-    // resetting each to page 1 so matches aren't hidden behind pagination.
-    $('#f-search')?.addEventListener('input', () => {
-      pagers.ready.page = 1;
-      pagers.backlog.page = 1;
-      renderClaimable();
-      renderBacklog();
-    });
-
-    // task 1931/1955: pagination controls for all four Work-page lists.
+    // task 2170: stamp the standard pager bars into their mounts, then wire —
+    // the markup that used to be hand-copied four times in work.html.
+    for (const [prefix, label] of [['ready', 'Ready tasks'], ['wip', 'In-progress tasks'], ['done', 'Completed tasks'], ['backlog', 'Backlog tasks']]) {
+      const m = $(`#${prefix}-pager-mount`);
+      if (m) m.innerHTML = pagerBarHtml(prefix, { label });
+    }
     wirePager(pagers.ready, renderClaimable);
     wirePager(pagers.wip, renderInFlight);
     wirePager(pagers.done, renderHistory);
     wirePager(pagers.backlog, renderBacklog);
 
+    // task 2170: the four sections become hash-synced tabs, Ready first. The
+    // kit never claims "#/…" hashes, so the task/idea/blocker overlay deep
+    // links keep working. Selection is scoped per tab — switching clears it.
+    workTabs = makeTabs({
+      mount: $('#work-tabs'),
+      hash: true,
+      initial: 'ready',
+      tabs: [
+        { id: 'ready', label: 'Ready', panel: 'claim-scroll' },
+        { id: 'in-progress', label: 'In Progress', panel: 'wip-scroll' },
+        { id: 'backlog', label: 'Backlog', panel: 'backlog-scroll' },
+        { id: 'completed', label: 'Completed', panel: 'history-scroll' },
+      ],
+      onChange: () => { if (selectionTotal()) clearSelection(); },
+    });
+
+    // task 2170: filter diet — Search/Sort/Version primary, the rest behind
+    // the kit's "Filters" disclosure; state rides the URL query (shareable).
+    // Control ids are unchanged so renderClaimable's reads + the dynamic
+    // version/goal option fills keep working untouched.
+    makeFilterBar({
+      mount: $('#work-filters'),
+      search: { id: 'f-search', label: 'Search', placeholder: 'task #, title, or goal…' },
+      primary: [
+        {
+          id: 'f-sort',
+          label: 'Sort',
+          options: [
+            { value: 'cpm', label: `${curLabel()} / minute (high → low)` },
+            { value: 'credits', label: `${curLabel()} (high → low)` },
+            { value: 'minutes', label: 'minutes (low → high)' },
+            { value: 'priority', label: 'priority (P0 first)' },
+            { value: 'id', label: 'task number (low → high)' },
+          ],
+        },
+        { id: 'f-version', label: 'Version', options: [{ value: '', label: '— any —' }] },
+      ],
+      overflow: [
+        { id: 'f-goal', label: 'Goal', options: [{ value: '', label: '— all goals —' }] },
+        {
+          id: 'f-kind',
+          label: 'Kind',
+          options: [{ value: '', label: '— any —' },
+            'feature', 'bug', 'infra', 'refactor', 'spike', 'learning-capture',
+            'cleanup', 'decision', 'blocker-resolution', 'unclassified'],
+        },
+        {
+          id: 'f-discipline',
+          label: 'Discipline',
+          options: [{ value: '', label: '— any —' }, 'engineer', 'artist', 'ideator', 'ui', 'unclassified'],
+        },
+        {
+          id: 'f-newcomer',
+          label: 'Newcomer',
+          options: [{ value: '', label: '— any —' }, { value: 'yes', label: 'newcomer-friendly only' }],
+        },
+        {
+          id: 'f-fit',
+          label: 'Run mode',
+          options: [{ value: '', label: '— any —' },
+            { value: 'parallel', label: 'parallel-safe only' },
+            { value: 'conflict', label: 'has file conflicts' }],
+        },
+      ],
+      url: true,
+      onChange: () => {
+        pagers.ready.page = 1;
+        pagers.backlog.page = 1;
+        renderClaimable();
+        renderBacklog();
+      },
+    });
+
     $('#task-list')?.addEventListener('click', (e) => {
       // task 1759: the multi-select checkbox. Toggle the Set + the card's
       // highlight class directly (cheaper than a full renderClaimable) and

package/modules/lifecycle/criterion-suggest.js

@@ -0,0 +1,80 @@
+'use strict';
+// criterion-suggest.js — task 2165. A pure, deterministic RECOMMENDER: given a
+// goal's criteria and a candidate task's title + description, rank the criteria
+// by lexical overlap so task-create can SUGGEST the most likely done-when
+// criterion to link. The builder always confirms or overrides — nothing is
+// auto-linked (the "suggest, human picks" contract). No DB, no network, so it's
+// unit-testable in the DB-free suite (tests live in modules/lifecycle/tests/).
+//
+// WHY lexical (not embeddings): the criterion set per goal is tiny (a handful),
+// the signal is strong (criteria prose shares vocabulary with the tasks that
+// fulfil it), and a deterministic ranker needs no model call, no key, and no
+// flakiness — it slots straight into the create path. The scoring is a weighted
+// term overlap: a term from the task TITLE counts double a term from the body,
+// because the title is the denser signal of what the task is about.
+
+// Common words that carry no discriminating signal — dropping them keeps a
+// criterion from scoring on filler like "the work is done when…".
+const STOPWORDS = new Set([
+  'the', 'a', 'an', 'and', 'or', 'but', 'to', 'of', 'in', 'on', 'for', 'with',
+  'without', 'is', 'are', 'be', 'was', 'were', 'it', 'its', 'this', 'that',
+  'these', 'those', 'as', 'at', 'by', 'from', 'into', 'out', 'over', 'so',
+  'then', 'than', 'not', 'no', 'can', 'do', 'does', 'done', 'when', 'which',
+  'who', 'what', 'how', 'their', 'them', 'they', 'you', 'your', 'our', 'via',
+  'per', 'each', 'one', 'all', 'any', 'new', 'use', 'used', 'using', 'make',
+  'made', 'get', 'got', 'set', 'add', 'added', 'work', 'works', 'working',
+]);
+
+// Lowercase, strip punctuation, drop stopwords + tokens shorter than 3 chars,
+// and crudely singularize (trailing 's' on longer words) so "criteria"/"tasks"
+// match "criterion"/"task"-ish stems. Deterministic and allocation-cheap.
+function tokenize(text) {
+  return String(text || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]+/g, ' ')
+    .split(/\s+/)
+    .filter((w) => w.length >= 3 && !STOPWORDS.has(w))
+    .map((w) => (w.length > 4 && w.endsWith('s') ? w.slice(0, -1) : w));
+}
+
+// Rank a goal's UNSATISFIED criteria against a candidate task. Title terms weigh
+// 2, description-only terms weigh 1. Returns a new array sorted best-first, each
+// { id, criterion_id, criterion_md, score, matched_terms }. Ties break by
+// ascending numeric id so the output is stable. Options:
+//   limit       — cap the number of suggestions returned (default 3)
+//   includeZero — keep criteria with no term overlap (default false: drop them,
+//                 so "no confident suggestion" returns [] rather than noise)
+function suggestCriteria(criteria, candidate = {}, opts = {}) {
+  const { title = '', description = '' } = candidate;
+  const { limit = 3, includeZero = false } = opts;
+
+  // Build the weighted term map: description terms at 1, title terms override to
+  // 2 (a term in both is a title term — the stronger signal wins).
+  const weights = new Map();
+  for (const t of tokenize(description)) weights.set(t, 1);
+  for (const t of tokenize(title)) weights.set(t, 2);
+
+  const ranked = (Array.isArray(criteria) ? criteria : [])
+    .filter((c) => c && !c.satisfied)
+    .map((c) => {
+      const critTerms = new Set(tokenize(c.criterion_md));
+      let score = 0;
+      const matched = [];
+      for (const [term, w] of weights) {
+        if (critTerms.has(term)) { score += w; matched.push(term); }
+      }
+      return {
+        id: c.id,
+        criterion_id: c.criterion_id,
+        criterion_md: c.criterion_md,
+        score,
+        matched_terms: matched.sort(),
+      };
+    })
+    .sort((a, b) => (b.score - a.score) || (Number(a.id) - Number(b.id)));
+
+  const kept = includeZero ? ranked : ranked.filter((r) => r.score > 0);
+  return kept.slice(0, Math.max(0, limit));
+}
+
+module.exports = { suggestCriteria, tokenize };

package/modules/lifecycle/db.js

@@ -1665,6 +1665,43 @@ async function listTasks({ versionId, status, kind, discipline, goalId } = {}) {
 // never can. This is a HARD control (a JS post-filter on the fit query), not a
 // soft prompt instruction. Backstops the SKILL.md fencing (layer 1).
 
+// task 2181 (incident, blocker 74): these are the EXACT bodies of the
+// claimable_tasks and tasks_session_fit views (migration
+// core_190_rebuild_claimable_task_views.sql), inlined as subqueries so the
+// claimable feed reads base tables (ACCESS SHARE only) instead of the views.
+// A detached backend queued an ACCESS EXCLUSIVE DDL on the views, which parks
+// every view SELECT behind it in the lock queue — the hall's primary feed hung
+// indefinitely while raw-table reads stayed fast. Postgres inlines simple
+// views into the same plan anyway, so this is semantics- and plan-identical;
+// it just stops the query's LOCKING from referencing the view relations.
+// If the view bodies change in a future migration, change these in lockstep
+// (or fold back to the views once per-view DDL contention is a solved problem).
+const CLAIMABLE_SQL = `
+  SELECT t.*, pms_calibrated_minutes(t.est_minutes, t.kind) AS est_minutes_calibrated
+    FROM tasks t
+   WHERE t.status = 'ready'
+     AND t.title NOT LIKE '\\_\\_smoke\\_\\_%' ESCAPE '\\'
+     AND NOT EXISTS (
+       SELECT 1 FROM task_blockers tb WHERE tb.task_id = t.id
+     )
+     AND NOT EXISTS (
+       SELECT 1 FROM claims c
+         JOIN tasks t2 ON t2.id = c.task_id
+        WHERE c.released_at IS NULL
+          AND t2.touches && t.touches
+     )`;
+const SESSION_FIT_SQL = `
+  SELECT t.id,
+    CASE
+      WHEN t.automation_tag = 'overnight-safe' AND COALESCE(t.manual_degree, 5) <= 2
+           AND NOT EXISTS (SELECT 1 FROM task_blockers tb WHERE tb.task_id = t.id)
+        THEN ARRAY['autonomous','check-in','active']
+      WHEN t.automation_tag = 'live-only' OR COALESCE(t.manual_degree, 5) >= 4
+        THEN ARRAY['active']
+      ELSE ARRAY['check-in','active']
+    END AS fits_session_modes
+    FROM tasks t`;
+
 async function listClaimableTasks({ versionId = null, builderId = null, discipline = null, fit = null } = {}) {
   const params = [];
   const where = [];
@@ -1717,12 +1754,12 @@ async function listClaimableTasks({ versionId = null, builderId = null, discipli
       END
     )`);
   }
-  // Autonomy / parallel-eligibility filter. Joining tasks_session_fit (also a
-  // SELECT t.* view) makes bare column names like priority/created_at ambiguous,
-  // so the ORDER BY below qualifies them with v. unconditionally.
+  // Autonomy / parallel-eligibility filter. Joining the session-fit relation
+  // (also a SELECT t.* shape) makes bare column names like priority/created_at
+  // ambiguous, so the ORDER BY below qualifies them with v. unconditionally.
   let fitJoin = '';
   if (fit === 'autonomous' || fit === 'parallel') {
-    fitJoin = ` JOIN tasks_session_fit sf ON sf.id = v.id`;
+    fitJoin = ` JOIN (${SESSION_FIT_SQL}) sf ON sf.id = v.id`;
     where.push(`'autonomous' = ANY(sf.fits_session_modes)`);
     if (fit === 'parallel') {
       where.push(`v.parallel_safe = true`);
@@ -1733,7 +1770,7 @@ async function listClaimableTasks({ versionId = null, builderId = null, discipli
   // recent actuals; ordering on the raw estimate puts oversized tasks at the
   // bottom even when their actual time-to-ship is short. See migration 015.
   const sql =
-    `SELECT v.* FROM claimable_tasks v` + fitJoin +
+    `SELECT v.* FROM (${CLAIMABLE_SQL}) v` + fitJoin +
     (where.length ? ` WHERE ${where.join(' AND ')}` : '') +
     ` ORDER BY v.priority NULLS LAST,
               COALESCE(v.est_minutes_calibrated, v.est_minutes) NULLS LAST,

package/modules/lifecycle/routes/goals.js

@@ -26,6 +26,7 @@ const api = require('../../../src/module-api');
 const auth = api;
 const db = require('../db');
 const hierarchy = require('../hierarchy');
+const { suggestCriteria } = require('../criterion-suggest');
 const { classifyTaskKind, VALID_KINDS, VALID_DISCIPLINES, TASK_FIELD_BOUNDS } = require('../task-classifier');
 const { validateOrRespond, parseId, LIMITS } = api;
 const { isModuleKey, scopeIncludesProtected, moduleKeys } = api.moduleScopeMap;
@@ -548,6 +549,31 @@ module.exports = function buildGoalsRouter() {
     }
   });
 
+  // GET /goals/:id/suggest-criteria?title=&description=&limit= — task 2165.
+  // Rank THIS goal's unsatisfied criteria by lexical overlap with a candidate
+  // task, so a create flow can SUGGEST which done-when criterion to link (the
+  // author confirms/overrides — nothing is auto-linked). Read-only + advisory;
+  // rank: any-builder (same as GET /goals/:id).
+  router.get('/goals/:id/suggest-criteria', auth.requireBuilder, async (req, res) => {
+    const id = parseId(req, res, { code: 'bad_goal_id' });
+    if (id === null) return;
+    try {
+      const goal = await db.getGoal(id);
+      if (!goal) return res.fail('goal_not_found', 404);
+      const criteria = await db.listCriteriaForGoal(id);
+      const limit = Math.min(10, Math.max(1, Number(req.query.limit) || 3));
+      const suggestions = suggestCriteria(
+        criteria,
+        { title: req.query.title, description: req.query.description },
+        { limit }
+      );
+      return res.json({ goal_id: goal.id, suggestions });
+    } catch (err) {
+      console.error('[gds] GET /goals/:id/suggest-criteria', err);
+      return res.fail('fetch_failed', { status: 500, message: 'internal error' });
+    }
+  });
+
   // POST /goals/:id/join — join an open goal.
   // rank: any-builder — open join for a NORMAL goal. A PROTECTED-scope goal is
   // Archon-mediated: a non-Archon cannot self-join (an Archon admits them via

package/modules/lifecycle/routes/tasks.js

@@ -7,6 +7,7 @@ const api = require('../../../src/module-api');
 const auth = api;
 const db = require('../db');
 const hierarchy = require('../hierarchy');
+const { suggestCriteria } = require('../criterion-suggest');
 // grading carved to modules/grading/ (BV1.R73 / ADR 0091 §4): the lifecycle no
 // longer imports the grader — it resolves the `grade` kernel PORT at grade time
 // (seams.resolveOptional('grade'), in POST /tasks/:id/grade below).
@@ -689,11 +690,31 @@ module.exports = function buildTasksRouter() {
       // task 1957: credits_reward is an ESTIMATE, not a guaranteed payout. The hall
       // renders it as "<Currency> Est." until the task settles (confirmed/shipped),
       // then switches to the real ledger figure (credits_awarded from the task read).
+      // task 2165 — the task landed under a goal but the caller linked no
+      // criterion → SUGGEST the most likely done-when criterion(s) for the author
+      // to confirm (they link via POST /tasks/:id/criteria). Advisory only, never
+      // auto-linked ("suggest, human picks"). Best-effort: a suggestion hiccup
+      // must not fail an otherwise-successful create. The general catch-all goal
+      // usually has no criteria, so this is naturally empty there.
+      let suggested_criteria = [];
+      if (criteria.length === 0 && task.goal_id != null) {
+        try {
+          const goalCriteria = await db.listCriteriaForGoal(task.goal_id);
+          suggested_criteria = suggestCriteria(
+            goalCriteria,
+            { title: body.title, description: body.description },
+            { limit: 3 }
+          );
+        } catch (e) {
+          console.error('[gds] POST /tasks suggest-criteria (non-blocking)', e && e.message);
+        }
+      }
       res.status(201).json({
         task,
         credits_reward: task.credits_reward,
         needs_migration: needsMigration,
         criteria,
+        suggested_criteria,
       });
     } catch (err) {
       console.error('[gds] POST /tasks', err);

package/modules/provisioning/CLAUDE.md

@@ -0,0 +1,15 @@
+# @bongos/core — installed platform dependency (not your project's CLAUDE.md)
+
+This file is a placeholder shipped inside the **@bongos/core** package. The core's own
+internal agent notes are intentionally omitted from the published artifact so they cannot
+load into your instance's context.
+
+**It does not govern this repository.** Your own root `CLAUDE.md`, your `.claude/`
+directory, and the live Bongos database are the source of truth for how work happens here
+and who may do what.
+
+You are seeing this only because an agent opened a file under `node_modules/@bongos/core/`.
+Nothing in here needs to be read to use the platform — run `bongos help` for commands.
+
+_To work ON the platform core itself, use the standalone @bongos/core source repository,
+not this vendored copy._