@bongos/core 1.19.660 → 1.19.661

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

@@ -62,15 +62,23 @@
   // forever. Its own function because Creator/Age re-fetch it, same as the
   // claimable feed. Best-effort: on failure the section stays as it was.
   function loadBacklog() {
-    const q = serverFilterQuery().replace(/^\?/, '&');
+    const q = backlogFilterQuery().replace(/^\?/, '&');
     return getJSON(`${API}/tasks?status=backlog&limit=${BACKLOG_LIMIT}${q}`)
-      .then((r) => { taskState.backlog = r.tasks || []; renderBacklog(taskState.backlog); })
+      .then((r) => {
+        taskState.backlog = r.tasks || [];
+        renderBacklog(taskState.backlog);
+        // task 1003828 — the Goal filter draws on this feed too and races it.
+        // Re-offer the options now; populateGoalFilter keeps the selection.
+        populateGoalFilter();
+      })
       .catch(() => { /* backlog stays as it was */ });
   }
 
-  // The last server-facing filter query we actually fetched with. Compared on
-  // every filter change to decide re-fetch vs re-render.
+  // The last server-facing filter queries we actually fetched with — one per
+  // feed, because the two routes answer DIFFERENT questions (see below).
+  // Compared on every filter change to decide re-fetch vs re-render.
   let lastServerFilterQuery = '';
+  let lastBacklogQuery = '';
 
   function serverFilterQuery() {
     const parts = [];
@@ -81,6 +89,24 @@
     return parts.length ? `?${parts.join('&')}` : '';
   }
 
+  // task 1003828 — the BACKLOG's server query, deliberately NOT shared with the
+  // claimable feed's. The routes differ (GET /tasks answers version/kind/
+  // discipline/goal_id; /tasks/claimable answers only version+discipline), and the
+  // backlog read is CAPPED at BACKLOG_LIMIT while the Ready feed is not — so a
+  // client-only narrow here would lie, hiding the artist tasks at row 501.
+  // '__none__' on Goal has no server predicate and is never sent.
+  function backlogFilterQuery() {
+    const f = boardFilterValues();
+    const parts = [];
+    if (f.creator) parts.push(`created_by=${encodeURIComponent(f.creator === '__none__' ? 'none' : f.creator)}`);
+    if (f.stale) parts.push(`stale_days=${encodeURIComponent(f.stale)}`);
+    if (f.version) parts.push(`version=${encodeURIComponent(f.version)}`);
+    if (f.kind) parts.push(`kind=${encodeURIComponent(f.kind)}`);
+    if (f.discipline) parts.push(`discipline=${encodeURIComponent(f.discipline)}`);
+    if (f.goal && f.goal !== '__none__') parts.push(`goal_id=${encodeURIComponent(f.goal)}`);
+    return parts.length ? `?${parts.join('&')}` : '';
+  }
+
   // task 1003278 — the ceiling on the Backlog read. Comfortably above today's
   // ~300 rows so nothing visibly changes now, and low enough that the page can
   // never be asked to hold the whole table as the project grows.
@@ -289,54 +315,76 @@
     return false;
   }
 
+  // task 1003828 — the board's filter lenses, read once from the DOM. ONE reader,
+  // so a control that exists can never be one a tab forgot to consult: before
+  // this, every dropdown was read inside renderClaimable and nowhere else, which
+  // left all six silently inert on the Backlog tab. ('__none__' on Creator
+  // isolates the unattributed — task 1003278.)
+  function boardFilterValues() {
+    const val = (id) => ($(id) ? $(id).value : '');
+    return {
+      search: searchQuery(),
+      version: val('#f-version'),
+      goal: val('#f-goal'),
+      kind: val('#f-kind'),
+      discipline: val('#f-discipline'),
+      newcomer: val('#f-newcomer'),
+      creator: val('#f-creator'),
+      stale: val('#f-stale'),
+    };
+  }
+
+  // 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 (!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.
+    if (f.goal === '__none__' && t.goal_id != null) return false;
+    if (f.goal && f.goal !== '__none__' && String(t.goal_id) !== f.goal) return false;
+    if (f.kind && t.kind !== f.kind) return false;
+    if (f.discipline && (t.discipline || 'unclassified') !== f.discipline) return false;
+    if (f.newcomer === 'yes' && !t.newcomer_friendly) return false;
+    // Creator + Age were applied by the SERVER, so they are re-checked here only
+    // as a belt on a stale render — cheap, and it keeps the view honest if a poll
+    // lands between a control change and its re-fetch.
+    if (f.creator === '__none__' && t.created_by != null) return false;
+    if (f.creator && f.creator !== '__none__' && String(t.created_by) !== f.creator) return false;
+    if (f.stale && !isStale(taskActivityMs(t), f.stale)) return false;
+    return true;
+  }
+
+  // task 1756: run-mode — a task is "parallel-safe" when its touches[] don't
+  // overlap any OTHER task in the visible set. Set-RELATIVE, which is why it runs
+  // after matchesBoardFilters rather than inside it: it answers "of what I'm
+  // looking at, what can run together." O(n²) over touches — fine at board scale.
+  function applyRunMode(list, fitFilter) {
+    if (fitFilter !== 'parallel' && fitFilter !== 'conflict') return list;
+    return list.filter((t) => {
+      const conflicts = list.some((o) => o !== t && touchesConflict(t.touches, o.touches));
+      return fitFilter === 'parallel' ? !conflicts : conflicts;
+    });
+  }
+
+  // task 1003828 — the bar sits above the four panels now, so it must say which it
+  // speaks for. Ready and Backlog are the QUEUE tabs; In Progress (live claims)
+  // and Completed (shipped history) render other objects, so the bar hides there
+  // rather than offering a control that does nothing — this task's whole defect.
+  const FILTERED_TABS = new Set(['ready', 'backlog']);
+  function syncFilterBarVisibility(tabId) {
+    const bar = $('#work-filters');
+    if (bar) bar.hidden = !FILTERED_TABS.has(String(tabId));
+  }
+
   function renderClaimable() {
     const root = $('#task-list');
     if (!root) return;
-    const vFilter = $('#f-version').value;
-    const gFilter = $('#f-goal') ? $('#f-goal').value : '';
-    const kFilter = $('#f-kind').value;
-    const dFilter = $('#f-discipline').value;
-    const nFilter = $('#f-newcomer') ? $('#f-newcomer').value : '';
-    // task 1003278 — creator + staleness. '__none__' on Creator isolates the
-    // unattributed (created before tasks.created_by existed, or by a system path)
-    // — the goals owner filter's 'system / unattributed' convention.
-    const cFilter = $('#f-creator') ? $('#f-creator').value : '';
-    const staleFilter = $('#f-stale') ? $('#f-stale').value : '';
+    const filters = boardFilterValues();
     const sortBy = $('#f-sort').value;
-    const sQuery = searchQuery();
-
-    let list = taskState.all.filter((t) => {
-      if (!matchesSearch(t, sQuery)) return false;
-      if (vFilter && t.version_id !== vFilter) return false;
-      // task 1755: goal filter. '__none__' isolates tasks with no goal.
-      if (gFilter === '__none__' && t.goal_id != null) return false;
-      if (gFilter && gFilter !== '__none__' && String(t.goal_id) !== gFilter) return false;
-      if (kFilter && t.kind !== kFilter) return false;
-      if (dFilter && (t.discipline || 'unclassified') !== dFilter) return false;
-      if (nFilter === 'yes' && !t.newcomer_friendly) return false;
-      // Creator + Age were applied by the SERVER (serverFilterQuery), so they are
-      // re-checked here only as a belt on a stale render — never as the primary
-      // filter. Re-applying them is cheap and keeps the view honest if a poll
-      // lands between a control change and its re-fetch.
-      if (cFilter === '__none__' && t.created_by != null) return false;
-      if (cFilter && cFilter !== '__none__' && String(t.created_by) !== cFilter) return false;
-      if (staleFilter && !isStale(taskActivityMs(t), staleFilter)) return false;
-      return true;
-    });
 
-    // task 1756: run-mode filter — a task is "parallel-safe" when its touches[]
-    // don't overlap any OTHER task in the currently-visible set; "conflict" is the
-    // complement (would collide, so run them sequentially). Computed over the
-    // already-filtered list so it answers "of what I'm looking at, what can run
-    // together." O(n²) over touches — fine at board scale.
-    const fitFilter = $('#f-fit') ? $('#f-fit').value : '';
-    if (fitFilter === 'parallel' || fitFilter === 'conflict') {
-      const base = list;
-      list = base.filter((t) => {
-        const conflicts = base.some((o) => o !== t && touchesConflict(t.touches, o.touches));
-        return fitFilter === 'parallel' ? !conflicts : conflicts;
-      });
-    }
+    let list = taskState.all.filter((t) => matchesBoardFilters(t, filters));
+
+    list = applyRunMode(list, $('#f-fit') ? $('#f-fit').value : '');
 
     if (sortBy === 'cpm') {
       list = list.slice().sort((a, b) => creditsPerMinute(b) - creditsPerMinute(a));
@@ -508,7 +556,10 @@
     if (!sel) return;
     const cur = sel.value;
     const titles = taskState.goalTitles || {};
-    const ids = [...new Set(taskState.all.map((t) => t.goal_id).filter((x) => x != null).map(String))];
+    // task 1003828 — options come from BOTH feeds: built from the claimable one
+    // alone, a goal whose only work sits at backlog was unofferable.
+    const rows = [...taskState.all, ...(taskState.backlog || [])];
+    const ids = [...new Set(rows.map((t) => t.goal_id).filter((x) => x != null).map(String))];
     ids.sort((a, b) => String(titles[a] || `Goal #${a}`).localeCompare(String(titles[b] || `Goal #${b}`)));
     sel.length = 1; // keep the leading "— all goals —" option
     for (const id of ids) {
@@ -517,7 +568,7 @@
       opt.textContent = titles[id] || `Goal #${id}`;
       sel.appendChild(opt);
     }
-    if (taskState.all.some((t) => t.goal_id == null)) {
+    if (rows.some((t) => t.goal_id == null)) {
       const opt = document.createElement('option');
       opt.value = '__none__';
       opt.textContent = 'No goal';
@@ -1055,17 +1106,44 @@
       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;
+    // task 1003828 — the SAME lenses the Ready tab uses. This read used to be
+    // search-only, so six controls silently did nothing on the tab holding the
+    // most rows. The server already narrowed this feed; re-applying the predicate
+    // answers the two client-only lenses (search, Goal's '__none__') and keeps the
+    // view honest between a control change and its re-fetch.
+    const filters = boardFilterValues();
+    let list = backlogRows.filter((t) => matchesBoardFilters(t, filters));
+    list = applyRunMode(list, $('#f-fit') ? $('#f-fit').value : '');
     const countEl = $('#backlog-count');
     if (countEl) countEl.textContent = `${list.length} ${list.length === 1 ? 'task' : 'tasks'}`;
+    if (!list.length) {
+      root.innerHTML = '<div class="profile__placeholder">No backlog tasks match these filters. Try widening them.</div>';
+      pagers.backlog.page = 1;
+      return;
+    }
     const shown = paginate(list, pagers.backlog);
     root.innerHTML = shown.map((t) => {
       const ver = t.version_id ? `<span class="task__tag">${escapeHtml(t.version_id)}</span>` : '';
+      // task 1003828 — the row says WHOSE CRAFT and WHICH GOAL. A Ready card has
+      // carried its discipline tag since 1755; a backlog row carried neither, so a
+      // correctly-goaled task (an auto-filed artist review, say) read as
+      // uncategorised in the one place a person goes looking for it. Same
+      // vocabulary as the card, so the two tabs describe a task alike.
+      const discipline = t.discipline || 'unclassified';
+      const disciplineTag = discipline !== 'unclassified'
+        ? `<span class="task__tag">${escapeHtml(discipline)}</span>`
+        : '';
+      // The goal's TITLE, from the map the Goal filter already loads, falling back
+      // to its id before that resolves. A goal-less row says so rather than
+      // rendering a gap — "no goal" is a real, findable state.
+      const goalTitle = t.goal_id != null
+        ? ((taskState.goalTitles || {})[String(t.goal_id)] || `Goal #${t.goal_id}`)
+        : 'No goal';
+      const goalTag = `<span class="history__goal" title="${escapeHtml(`Goal: ${goalTitle}`)}">${escapeHtml(goalTitle)}</span>`;
       return `
         <div class="history__row" data-task-id="${escapeHtml(String(t.id))}" title="Open task #${escapeHtml(String(t.id))}">
           <span class="history__id">#${escapeHtml(String(t.id))}</span>
-          <span class="history__title">${escapeHtml(t.title || '(untitled)')} ${ver} ${rankTagHtml(t.requires_rank)}</span>
+          <span class="history__title">${escapeHtml(t.title || '(untitled)')} ${ver} ${disciplineTag} ${rankTagHtml(t.requires_rank)}<br>${goalTag}</span>
           <span class="history__when">${escapeHtml(t.kind || '')}</span>
         </div>`;
     }).join('');
@@ -1182,6 +1260,10 @@
         taskState.goalTitles[g.id] = g.title;
         taskState.goalCategories[g.id] = g.category || null;
       });
+      // 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' */ }
 
     // Claimable + active claims in one call. A 403 means the primer gate — show
@@ -1242,7 +1324,10 @@
         { id: 'backlog', label: 'Backlog', panel: 'backlog-scroll' },
         { id: 'completed', label: 'Completed', panel: 'history-scroll' },
       ],
-      onChange: () => { if (selectionTotal()) clearSelection(); },
+      onChange: (id) => {
+        if (selectionTotal()) clearSelection();
+        syncFilterBarVisibility(id);
+      },
     });
 
     // task 2170: filter diet — Search/Sort/Version primary, the rest behind
@@ -1266,6 +1351,16 @@
           ],
         },
         { id: 'f-version', label: 'Version', options: [{ value: '', label: '— any —' }] },
+        // task 1003828 — Discipline is PRIMARY, not overflow. A craft is the axis
+        // this platform organises people by (CLAUDE.md's role packs; a task's work
+        // type IS its discipline), so "show me my craft's work" is a first-class
+        // question, not one to find behind a disclosure. The mixed option form is
+        // kit-supported — pinned by tests/goal_sort_staleness.mjs against this id.
+        {
+          id: 'f-discipline',
+          label: 'Discipline',
+          options: [{ value: '', label: '— any —' }, 'engineer', 'artist', 'ideator', 'ui', 'unclassified'],
+        },
       ],
       overflow: [
         { id: 'f-goal', label: 'Goal', options: [{ value: '', label: '— all goals —' }] },
@@ -1276,11 +1371,6 @@
             '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',
@@ -1310,18 +1400,23 @@
         // changed id (hall-kit.js:269), and comparing the query is the direct
         // question anyway — a control that does not appear in it can never cost
         // a round-trip, which is what keeps the other filters instant.
+        //
+        // task 1003828 — decided SEPARATELY per feed now, because the backlog asks
+        // the server more than claimable can answer. Each side re-fetches (ending
+        // in its own render) or re-renders in place; the old early return left the
+        // other tab's client-side lenses unapplied until the next poll.
         const q = serverFilterQuery();
-        if (q !== lastServerFilterQuery) {
-          lastServerFilterQuery = q;
-          refreshLive();
-          loadBacklog();
-          return;
-        }
-        renderClaimable();
-        renderBacklog();
+        const bq = backlogFilterQuery();
+        if (q !== lastServerFilterQuery) { lastServerFilterQuery = q; refreshLive(); } else { renderClaimable(); }
+        if (bq !== lastBacklogQuery) { lastBacklogQuery = bq; loadBacklog(); } else { renderBacklog(); }
       },
     });
 
+    // 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.
+    syncFilterBarVisibility(workTabs && workTabs.active ? workTabs.active() : 'ready');
+
     $('#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/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.660",
+  "version": "1.19.661",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.660",
+      "version": "1.19.661",
       "license": "AGPL-3.0-or-later",
       "dependencies": {
         "express": "^4.21.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.660",
+  "version": "1.19.661",
   "description": "Cloud Bongos — the AI-first build platform core (GDS + platform surfaces + module system), installed as a versioned dependency (ADR 0108).",
   "license": "AGPL-3.0-or-later",
   "main": "src/platform-server.js",

package/src/module-api.js

@@ -71,7 +71,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.660'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.661'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/goal_sort_staleness.mjs

@@ -202,7 +202,18 @@ await test('a server-side filter change RE-FETCHES; every other filter stays ins
   // direct question anyway, and means a control absent from that query can never
   // cost a round-trip.
   assert.match(WORK_SRC, /let lastServerFilterQuery = '';/);
-  assert.match(WORK_SRC, /if \(q !== lastServerFilterQuery\) \{[\s\S]{0,200}refreshLive\(\);\s*\n\s*loadBacklog\(\);/);
+  // task 1003828 split this into ONE DECISION PER FEED. It used to be a single
+  // comparison that re-fetched both and returned early — which was fine while the
+  // two asked the server the same question, and wrong once the backlog started
+  // asking a narrower one (version/kind/discipline/goal_id, which GET /tasks
+  // answers and GET /tasks/claimable does not). The early return also meant a
+  // change to a CLIENT-side lens skipped the other tab's re-render until the next
+  // poll repainted it. Each side now re-fetches or re-renders on its own; the
+  // property under test is unchanged — a server-facing change costs a round-trip
+  // and nothing else does.
+  assert.match(WORK_SRC, /let lastBacklogQuery = '';/);
+  assert.match(WORK_SRC, /if \(q !== lastServerFilterQuery\) \{ lastServerFilterQuery = q; refreshLive\(\); \} else \{ renderClaimable\(\); \}/);
+  assert.match(WORK_SRC, /if \(bq !== lastBacklogQuery\) \{ lastBacklogQuery = bq; loadBacklog\(\); \} else \{ renderBacklog\(\); \}/);
   const kit = read('modules/hall-ui/public/hall-kit.js');
   assert.match(kit, /if \(onChange\) onChange\(values\(\)\);/,
     'the contract this decision depends on — if it ever hands the changed id instead, revisit');

package/tests/hall_board_world.mjs

@@ -471,3 +471,106 @@ test('the tab strip is left alone — it scrolls in its own row and never moved
   assert.ok(strip, 'the tab strip rule is present');
   assert.match(strip[1], /overflow-x:\s*auto/, 'it scrolls itself, which is why it is not the overflow cause');
 });
+
+// ---- the board's filters drive BOTH queue tabs (task 1003828) ---------------
+//
+// The owner reported an auto-filed artist review as "going into uncategorized
+// BONGOS-V2 backlog tasks" and asked for tasks to be "filterable by role type".
+// The review was never uncategorised — cascade.js inherits its parent's goal —
+// but the Backlog tab it lands on could not say so and could not be narrowed:
+//
+//   * renderBacklog() applied the SEARCH BOX ONLY. Version, Goal, Kind,
+//     Discipline, Newcomer and Run mode were read inside renderClaimable and
+//     nowhere else, so six controls were silently inert over the tab holding the
+//     most rows. Nothing errored; the list simply did not change.
+//   * The filter bar was INSIDE #claim-scroll, which makeTabs hides. So on the
+//     Backlog tab those controls were not merely inert — they were off-screen.
+//   * A backlog row rendered id + title + version + rank + kind. No goal, no
+//     discipline. A correctly-goaled task genuinely read as uncategorised.
+//
+// Each is invisible in a browser the way this file's other entries are: the page
+// renders, it just renders a control that does nothing.
+
+const workJs = read('work.js');
+
+test('the filter bar is above the panels, not inside the Ready one that gets hidden', () => {
+  const filters = workHtml.indexOf('id="work-filters"');
+  const tabs = workHtml.indexOf('id="work-tabs"');
+  const claim = workHtml.indexOf('id="claim-scroll"');
+  assert.ok(filters > 0 && tabs > 0 && claim > 0, 'all three mounts present');
+  assert.ok(filters > tabs, 'the bar follows the tab strip it belongs to');
+  assert.ok(filters < claim,
+    'and precedes the Ready panel — inside it, makeTabs hides the filters with the tab');
+});
+
+test('the bar shows on the two QUEUE tabs and hides on the two that it cannot narrow', () => {
+  assert.match(workJs, /const FILTERED_TABS = new Set\(\['ready', 'backlog'\]\)/,
+    'Ready and Backlog are task feeds; In Progress and Completed render other objects');
+  assert.match(workJs, /function syncFilterBarVisibility/);
+  // Wired BOTH ways: on a tab change, and once at boot — makeTabs restores a
+  // deep-linked tab (/work#completed) before the bar is built, and fires
+  // onChange only on a CHANGE, so opening state has to be set explicitly.
+  assert.match(workJs, /onChange: \(id\) => \{[\s\S]{0,160}syncFilterBarVisibility\(id\)/,
+    'a tab change re-syncs the bar');
+  assert.match(workJs, /syncFilterBarVisibility\(workTabs && workTabs\.active \? workTabs\.active\(\) : 'ready'\)/,
+    'and the opening tab decides the opening state');
+});
+
+test('both queue tabs narrow through ONE predicate, so a filter cannot reach only one', () => {
+  assert.match(workJs, /function matchesBoardFilters\(t, f\)/,
+    'the predicate is shared, not copied per tab');
+  // Both renderers must consult it. This is the whole defect: before, only the
+  // claimable one did.
+  const claimable = workJs.slice(workJs.indexOf('function renderClaimable'), workJs.indexOf('async function populateCreatorFilter'));
+  const backlog = workJs.slice(workJs.indexOf('function renderBacklog'), workJs.indexOf('async function refreshLive'));
+  for (const [name, body] of [['renderClaimable', claimable], ['renderBacklog', backlog]]) {
+    assert.ok(body.length, `${name} body located`);
+    assert.match(body, /matchesBoardFilters\(t, filters\)/, `${name} narrows through the shared predicate`);
+    assert.match(body, /applyRunMode\(list, \$\('#f-fit'\)/, `${name} applies the set-relative run-mode lens too`);
+  }
+});
+
+test('a backlog row names its craft and its goal', () => {
+  const backlog = workJs.slice(workJs.indexOf('function renderBacklog'));
+  // The same vocabulary the Ready card has carried since 1755 — a second spelling
+  // would let the two tabs describe one task differently.
+  assert.match(backlog, /const discipline = t\.discipline \|\| 'unclassified'/);
+  assert.match(backlog, /disciplineTag/, 'the row renders the discipline tag');
+  assert.match(backlog, /taskState\.goalTitles \|\| \{\}/, 'the goal is named by TITLE, not by bare id');
+  assert.match(backlog, /'No goal'/, 'and a goal-less row says so rather than rendering a gap');
+  assert.ok(rule(workCss, '.history__goal'), '.history__goal has a rule — an unstyled sub-line inherits the title size');
+});
+
+test('the backlog asks the SERVER the narrow question, because its read is capped', () => {
+  // A client-side-only narrow of a capped read LIES: filtering the 500 fetched
+  // rows to the artist ones hides the artist tasks that sat at row 501.
+  assert.match(workJs, /function backlogFilterQuery/);
+  const q = workJs.slice(workJs.indexOf('function backlogFilterQuery'), workJs.indexOf('BACKLOG_LIMIT ='));
+  for (const param of ['version=', 'kind=', 'discipline=', 'goal_id=']) {
+    assert.ok(q.includes(param), `the backlog read sends ${param} — GET /tasks answers it`);
+  }
+  // '__none__' (ungoaled) has no server predicate, so it must not be sent.
+  assert.match(q, /f\.goal && f\.goal !== '__none__'/,
+    "the client-only 'No goal' lens is never sent to the route");
+  // It reads through boardFilterValues rather than re-querying the DOM, so the
+  // query and the client predicate can never disagree about a control's value.
+  assert.match(q, /const f = boardFilterValues\(\);/);
+  // And it stays SEPARATE from the claimable query: GET /tasks/claimable answers
+  // only version + discipline, so kind/goal_id there would be a silent no-op.
+  const claimQ = workJs.slice(workJs.indexOf('function serverFilterQuery'), workJs.indexOf('task 1003828 — the BACKLOG'));
+  assert.ok(!claimQ.includes('goal_id='), 'the claimable feed is not sent goal_id');
+  assert.ok(!claimQ.includes('kind='), 'nor kind');
+});
+
+test('each feed decides its own re-fetch, so a server change cannot strand the other tab', () => {
+  // The old shape compared ONE query and returned early, which left the other
+  // tab's client-side lenses unapplied until the next poll happened to repaint.
+  assert.match(workJs, /if \(q !== lastServerFilterQuery\) \{ lastServerFilterQuery = q; refreshLive\(\); \} else \{ renderClaimable\(\); \}/);
+  assert.match(workJs, /if \(bq !== lastBacklogQuery\) \{ lastBacklogQuery = bq; loadBacklog\(\); \} else \{ renderBacklog\(\); \}/);
+});
+
+test('the Goal filter offers goals that only have BACKLOG work', () => {
+  const populate = workJs.slice(workJs.indexOf('function populateGoalFilter'), workJs.indexOf('async function copyPromptForTask'));
+  assert.match(populate, /\[\.\.\.taskState\.all, \.\.\.\(taskState\.backlog \|\| \[\]\)\]/,
+    'built from the claimable feed alone, a backlog-only goal was unofferable');
+});