@bongos/core 1.20.46 → 1.20.47

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

@@ -14,7 +14,9 @@
    verification state, which DESIGN.md §Reuse names as the one sanctioned
    exception to the Fifteen Rule.
 
-   goals.html LOADS THIS SHEET TOO — a change here lands on both pages. */
+   goals.html NO LONGER LOADS THIS SHEET (task 1003141): what the goal board's
+   cards borrowed from it — .claim-count-line, .wip__release, .wip__select — now
+   lives in style.css, so this sheet is the board's alone. */
 
 /* `.page-head--board` MOVED to style.css (task 1003305) when the ideas composer
    became its third consumer: a modifier on the shell's own .page-head is shell
@@ -35,17 +37,6 @@
 .wip-builder { color: var(--ink); font-weight: 500; }
 .wip-builder small { color: var(--ink-soft); font-weight: 400; }
 
-/* Filtered-count line under the filter bar — the label voice, with the number
-   itself stepping up to ink so the count reads before the words. */
-.claim-count-line {
-  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-faint);
-}
-
 .backlog-count {
   font-family: var(--font-mono);
   font-size: 11px;
@@ -67,27 +58,6 @@
 
 /* In-flight table: release action on the viewer's own claims. */
 .wip__action { text-align: right; white-space: nowrap; }
-.wip__release {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  min-height: 30px;
-  padding: 0 14px;
-  background: none;
-  border: var(--line) solid var(--rule);
-  color: var(--ink-soft);
-  border-radius: var(--radius-pill);
-  font-size: 13px;
-  text-transform: lowercase;
-  cursor: pointer;
-  transition: background 150ms, color 150ms, border-color 150ms;
-}
-.wip__release:hover:not(:disabled) {
-  background: var(--danger-weak);
-  color: var(--danger);
-  border-color: color-mix(in srgb, var(--danger) 40%, transparent);
-}
-.wip__release:disabled { opacity: 0.55; cursor: default; }
 .wip__mine-none { color: var(--ink-faint); }
 .wip__row--mine { background: var(--accent-tint); }
 
@@ -121,7 +91,7 @@
 .history__when { color: var(--ink-soft); font-size: 12.5px; white-space: nowrap; font-variant-numeric: tabular-nums; }
 
 
-/* ---- task 1759: multi-select checkbox (the toolbar itself is in style.css) ----
+/* ---- task 1759: multi-select (the toolbar AND the checkbox are in style.css) ----
    Re-cut for the 24px floor and the world (task 1003304). The floating dark
    pill is gone: it painted an INVERTED surface (background: var(--ink)) with
    three rgba(255,255,255,…) literals on top, which was correct only for as long
@@ -130,38 +100,6 @@
    content column instead, inset by the rail, so it never has to invert. */
 
 .wip__select-cell { width: 1%; text-align: center; }
-.wip__select {
-  appearance: none;
-  -webkit-appearance: none;
-  position: relative;
-  width: 24px;
-  height: 24px;
-  margin: 0;
-  cursor: pointer;
-}
-.wip__select::before {
-  content: "";
-  position: absolute;
-  left: 5px;
-  top: 5px;
-  width: 14px;
-  height: 14px;
-  border: var(--line) solid var(--rule);
-  border-radius: 3px;
-}
-.wip__select:checked::before { background: var(--accent); border-color: var(--accent); }
-.wip__select:checked::after {
-  content: "";
-  position: absolute;
-  left: 9px;
-  top: 8px;
-  width: 4px;
-  height: 8px;
-  border: solid var(--accent-on);
-  border-width: 0 1.5px 1.5px 0;
-  transform: rotate(42deg);
-}
-
 /* ---- "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

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

@@ -189,7 +189,8 @@
 <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-09-26-claimaction1" defer></script>
+<script src="/builders/bulk-toolbar.js" defer></script>
+<script src="/builders/work.js?v=2026-09-30-bulktoolbar" defer></script>
 <script src="/builders/copy-on-click.js?v=2026-06-01-copy-1" defer></script>
 </body>
 </html>

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

@@ -187,9 +187,9 @@
   // The hall's ONE claim/release action (task 1003458). Everything this board
   // used to hand-roll four times — the POST, the refusal sentence, the
   // stale-view refresh, the all-or-nothing batch report — lives in
-  // claim-action.js now; doClaim/doRelease/doBulkClaim/doBulkRelease below keep
-  // only what is genuinely this page: button text, the re-entrancy guard, the
-  // confirm() wording and the selection. friendlyBatchReason is injected rather
+  // claim-action.js now; doClaim/doRelease below keep only what is
+  // genuinely this page: button text and the re-entrancy guard (the bulk
+  // toolbar is bulk-toolbar.js, built from this same action). friendlyBatchReason is injected rather
   // than imported there, so claim-action.js stays dependency-free.
   // refreshLive is a hoisted declaration; toast and API are already bound above.
   const claimAction = makeClaimAction({
@@ -291,18 +291,6 @@
   // String(claim_id) -> task_id for the viewer's OWN in-flight claims (release
   // is only ever offered on those rows to begin with — see renderInFlight).
   const selection = { claim: new Set(), release: new Map() };
-  // Last server dry-run (POST /claims/batch/validate) result, keyed by the
-  // sorted selected-id set so an unrelated re-render doesn't refire it.
-  const validateCache = { key: '', parallelSafe: null, byId: new Map() };
-  let validateDebounce = null;
-  // Per-task dependency edges for the "can these be sequenced?" cycle check —
-  // fetched lazily via GET /tasks/:id (task-detail.js's call) since the
-  // claimable feed doesn't carry dependencies[] per row. Stable for a ready
-  // task within one page session, so caching by id is safe.
-  const depsCache = new Map(); // task_id -> [dependency task_id, ...]
-  const sequentialCache = { key: '', order: null };
-  let sequentialDebounce = null;
-
   // task 1756: two tasks can't run in parallel if their touches[] overlap — exact
   // path match or a directory-prefix either way (mirrors the server's touchesOverlap
   // / the goals-page conflict estimate). Empty touches never conflict.
@@ -700,207 +688,18 @@
     }
   }
 
-  function selectedClaimIds() { return [...selection.claim].map(Number); }
-  function selectionKey(ids) { return ids.slice().sort((a, b) => a - b).join(','); }
-
-  async function scheduleValidate(key, ids) {
-    if (validateDebounce) clearTimeout(validateDebounce);
-    validateDebounce = setTimeout(async () => {
-      // The dry run lives in claim-action.js with the rest of the claim path; it
-      // is best-effort there, so a failure lands as parallelSafe:false with an
-      // empty map rather than a throw — Parallel stays disabled with a generic
-      // title instead of copying a prompt for tasks nobody verified. The
-      // debounce, the cache key and the re-render stay here: page furniture.
-      const out = await claimAction.validateMany(ids);
-      validateCache.key = key;
-      validateCache.parallelSafe = out.parallelSafe;
-      validateCache.byId = out.byId;
-      renderBulkToolbar();
-    }, 350);
-  }
-
-  async function fetchDeps(taskId) {
-    if (depsCache.has(taskId)) return depsCache.get(taskId);
-    let deps = [];
-    try {
-      const d = await getJSON(`${API}/tasks/${encodeURIComponent(taskId)}`, { softAuth: true });
-      if (d && d.task && Array.isArray(d.task.dependencies)) {
-        deps = d.task.dependencies.map((x) => Number(x.id)).filter((x) => Number.isFinite(x));
-      }
-    } catch (_) { /* treat as no known dependencies */ }
-    depsCache.set(taskId, deps);
-    return deps;
-  }
-
-  // Kahn's algorithm restricted to edges BETWEEN the selected ids (an
-  // out-of-selection dependency doesn't block sequencing the selection
-  // itself). Returns the topological order, or null if the restricted graph
-  // has a cycle (can't be sequenced).
-  function topoOrder(ids, edgesByTask) {
-    const remaining = new Set(ids);
-    const order = [];
-    let progressed = true;
-    while (remaining.size && progressed) {
-      progressed = false;
-      for (const id of Array.from(remaining)) {
-        const deps = (edgesByTask.get(id) || []).filter((d) => remaining.has(d));
-        if (deps.length === 0) {
-          order.push(id);
-          remaining.delete(id);
-          progressed = true;
-        }
-      }
-    }
-    return remaining.size ? null : order;
-  }
-
-  function scheduleSequentialCheck(key, ids) {
-    if (sequentialDebounce) clearTimeout(sequentialDebounce);
-    sequentialDebounce = setTimeout(async () => {
-      const edgesByTask = new Map();
-      await Promise.all(ids.map(async (id) => { edgesByTask.set(id, await fetchDeps(id)); }));
-      sequentialCache.key = key;
-      sequentialCache.order = topoOrder(ids, edgesByTask);
-      renderBulkToolbar();
-    }, 350);
-  }
-
-  function renderBulkToolbar() {
-    const bar = $('#bulk-toolbar');
-    if (!bar) return;
-    if (selectionTotal() === 0) { bar.hidden = true; return; }
-    bar.hidden = false;
-
-    const countEl = $('#bulk-count');
-    if (countEl) {
-      const parts = [];
-      if (selection.claim.size) parts.push(`${selection.claim.size} to claim`);
-      if (selection.release.size) parts.push(`${selection.release.size} to release`);
-      countEl.textContent = parts.join(' · ');
-    }
-
-    const claimBtn = $('#bulk-claim-btn');
-    if (claimBtn) {
-      claimBtn.disabled = selection.claim.size === 0;
-      claimBtn.textContent = selection.claim.size > 1 ? `Bulk claim (${selection.claim.size})` : 'Bulk claim';
-    }
-    const releaseBtn = $('#bulk-release-btn');
-    if (releaseBtn) {
-      releaseBtn.disabled = selection.release.size === 0;
-      releaseBtn.textContent = selection.release.size > 1 ? `Bulk release (${selection.release.size})` : 'Bulk release';
-    }
-
-    const parallelBtn = $('#bulk-parallel-btn');
-    if (parallelBtn) {
-      if (selection.claim.size < 2) {
-        parallelBtn.disabled = true;
-        parallelBtn.title = 'Select at least 2 waiting tasks to copy a parallel-session prompt.';
-      } else {
-        const ids = selectedClaimIds();
-        const key = selectionKey(ids);
-        if (validateCache.key === key && validateCache.parallelSafe != null) {
-          parallelBtn.disabled = !validateCache.parallelSafe;
-          if (!validateCache.parallelSafe) {
-            const bad = [...validateCache.byId.values()].filter((r) => !r.valid);
-            const detail = bad.map((r) => `#${r.task_id}: ${(r.reasons || []).map(friendlyBatchReason).join(', ')}`).join(' · ');
-            parallelBtn.title = detail || 'Selected tasks conflict and cannot run in parallel.';
-          } else {
-            parallelBtn.title = '';
-          }
-        } else {
-          parallelBtn.disabled = true;
-          parallelBtn.title = 'Checking for conflicts…';
-          scheduleValidate(key, ids);
-        }
-      }
-    }
-
-    const sequentialBtn = $('#bulk-sequential-btn');
-    if (sequentialBtn) {
-      if (selection.claim.size < 2) {
-        sequentialBtn.disabled = true;
-        sequentialBtn.title = 'Select at least 2 waiting tasks to copy a sequential prompt.';
-      } else {
-        const ids = selectedClaimIds();
-        const key = selectionKey(ids);
-        if (sequentialCache.key === key) {
-          sequentialBtn.disabled = sequentialCache.order == null;
-          sequentialBtn.title = sequentialCache.order == null
-            ? 'These tasks depend on each other in a cycle and cannot be ordered.'
-            : '';
-        } else {
-          sequentialBtn.disabled = true;
-          sequentialBtn.title = 'Checking dependency order…';
-          scheduleSequentialCheck(key, ids);
-        }
-      }
-    }
-  }
-
-  function clearSelection() {
-    selection.claim.clear();
-    selection.release.clear();
-    renderClaimable();
-    renderInFlight();
-    renderBulkToolbar();
-  }
-
-  function buildBulkParallelPrompt(tasks) {
-    const hallBase = location.hostname.startsWith('builders.') ? location.origin : `${location.origin}/builders`;
-    const lines = [
-      `I want to work on ${tasks.length} Bongos tasks IN PARALLEL — open ${tasks.length} separate Claude Code sessions, each in its own worktree, one per task below, so they can run at the same time without touching each other's files.`,
-      '',
-    ];
-    tasks.forEach((t, i) => {
-      lines.push(`Session ${i + 1} — task ${t.id} (${t.title}) — ${hallBase}#/task/${t.id}`);
-      lines.push(`Claim it with /builder-claim ${t.id}, follow its acceptance criteria, stay within touches[], ship via /builder-ship when done.`);
-      lines.push('');
-    });
-    return lines.join('\n').trim();
-  }
-
-  function buildBulkSequentialPrompt(tasks) {
-    const hallBase = location.hostname.startsWith('builders.') ? location.origin : `${location.origin}/builders`;
-    const lines = [
-      `I want to work on ${tasks.length} Bongos tasks IN ORDER, one after another in this same session — claim, build, and ship each before moving to the next.`,
-      '',
-    ];
-    tasks.forEach((t, i) => {
-      lines.push(`${i + 1}. Task ${t.id} (${t.title}) — ${hallBase}#/task/${t.id}`);
-    });
-    lines.push('');
-    lines.push('For each: /builder-claim <id>, follow its acceptance criteria, stay within touches[], /builder-ship <id> before starting the next.');
-    return lines.join('\n');
-  }
-
-  async function doBulkClaim() {
-    const ids = selectedClaimIds();
-    if (!ids.length) return;
-    const btn = $('#bulk-claim-btn');
-    if (btn) { btn.disabled = true; btn.textContent = 'Claiming…'; }
-    try {
-      const out = await claimAction.claimMany(ids);
-      if (out.ok) selection.claim.clear();
-    } finally {
-      renderBulkToolbar();
-    }
-  }
-
-  async function doBulkRelease() {
-    const entries = [...selection.release.entries()]; // [claimId, taskId]
-    if (!entries.length) return;
-    const label = entries.length === 1 ? `#${entries[0][1]}` : `${entries.length} tasks`;
-    const pronoun = entries.length === 1 ? 'It returns' : 'They return';
-    if (!window.confirm(`Release ${label}? ${pronoun} to the queue and no ${curLabel()} are earned.`)) return;
-    const btn = $('#bulk-release-btn');
-    if (btn) { btn.disabled = true; btn.textContent = 'Releasing…'; }
-    try {
-      const out = await claimAction.releaseMany(entries);
-      if (out.ok) selection.release.clear();
-    } finally {
-      renderBulkToolbar();
-    }
-  }
+  // The toolbar itself (render, bulk claim/release, the two prompts) is the
+  // hall's shared one — bulk-toolbar.js. This page keeps the selection and how
+  // Clear repaints its own cards.
+  const bulk = window.OTBBulkToolbar.makeBulkToolbar({
+    ids: { bar: 'bulk-toolbar', count: 'bulk-count', claim: 'bulk-claim-btn', release: 'bulk-release-btn', parallel: 'bulk-parallel-btn', sequential: 'bulk-sequential-btn', clear: 'bulk-clear-btn' },
+    selection,
+    findTask: (id) => taskState.all.find((t) => Number(t.id) === id),
+    claimAction, getJSON, API, copyText, toast, curLabel, describeReason: friendlyBatchReason,
+    onClear: () => { renderClaimable(); renderInFlight(); },
+  });
+  function renderBulkToolbar() { bulk.render(); }
+  function clearSelection() { bulk.clearSelection(); }
 
   async function doClaim(taskId, btn) {
     const key = `claim:${taskId}`;
@@ -1373,26 +1172,8 @@
       doRelease(rel.dataset.claimId, rel.dataset.taskId, rel);
     });
 
-    // task 1759: the bottom bulk-action toolbar.
-    $('#bulk-claim-btn')?.addEventListener('click', doBulkClaim);
-    $('#bulk-release-btn')?.addEventListener('click', doBulkRelease);
-    $('#bulk-clear-btn')?.addEventListener('click', clearSelection);
-    $('#bulk-parallel-btn')?.addEventListener('click', async () => {
-      const ids = selectedClaimIds();
-      const tasks = ids.map((id) => taskState.all.find((t) => Number(t.id) === id)).filter(Boolean);
-      if (tasks.length < 2) return;
-      const ok = await copyText(buildBulkParallelPrompt(tasks));
-      toast(ok ? `Parallel-session prompt for ${tasks.length} tasks copied.` : 'Could not copy to the clipboard.');
-    });
-    $('#bulk-sequential-btn')?.addEventListener('click', async () => {
-      const ids = selectedClaimIds();
-      const key = selectionKey(ids);
-      if (sequentialCache.key !== key || sequentialCache.order == null) return;
-      const tasks = sequentialCache.order.map((id) => taskState.all.find((t) => Number(t.id) === id)).filter(Boolean);
-      if (tasks.length < 2) return;
-      const ok = await copyText(buildBulkSequentialPrompt(tasks));
-      toast(ok ? `Sequential prompt for ${tasks.length} tasks copied.` : 'Could not copy to the clipboard.');
-    });
+    // task 1759: the bottom bulk-action toolbar (shared: bulk-toolbar.js).
+    bulk.wire();
   }
 
   document.addEventListener('DOMContentLoaded', () => {

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.20.46",
+  "version": "1.20.47",
   "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/release-notes.json

@@ -8389,5 +8389,11 @@
       "id": "1004366",
       "text": "Every store module version now has a readable how-to page in the hall, with a Save as PDF button and an optional link to a Claude page."
     }
+  ],
+  "1.20.47": [
+    {
+      "id": "1003141",
+      "text": "The Goals page now has the same bulk actions as the Tasks board: claim several tasks, release your own, or copy a prompt to work them in parallel or in order. Both pages now share one toolbar, so they stay in step."
+    }
   ]
 }

package/src/module-api.js

@@ -75,7 +75,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // MAJOR (see allowBoxScope below): passes the request through untouched.
 function deprecatedNoopMiddleware(_req, _res, next) { next(); }
 
-const CORE_VERSION = '1.20.46'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.20.47'; // 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('discord'); log.info('mounted');

package/tests/bulk_toolbar.mjs

@@ -0,0 +1,202 @@
+// tests/bulk_toolbar.mjs — the hall's shared bulk toolbar (task 1003141).
+//
+// One toolbar, two boards: /work and the goal board build the SAME one from
+// modules/hall-ui/public/bulk-toolbar.js. This runs the real module (it is
+// node-require-safe) against a stub page, so what it proves is behaviour — a
+// release selection really enables Bulk release, a cycle really disables the
+// sequential prompt — rather than that two files agree on a spelling.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(import.meta.dirname, '..');
+const PUB = path.join(ROOT, 'modules/hall-ui/public');
+const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8');
+const { topoOrder, buildBulkParallelPrompt, buildBulkSequentialPrompt, makeBulkToolbar } = require(path.join(PUB, 'bulk-toolbar.js'));
+
+const loc = { hostname: 'builders.example.com', origin: 'https://builders.example.com' };
+
+test('topoOrder puts a dependency first and ignores edges outside the selection', () => {
+  const edges = new Map([[2, [1]], [1, [99]], [3, []]]);
+  const order = topoOrder([2, 1, 3], edges);
+  assert.ok(order.indexOf(1) < order.indexOf(2), 'a dependency precedes its dependent');
+  assert.equal(order.length, 3);
+});
+
+test('topoOrder answers null for a cycle', () => {
+  assert.equal(topoOrder([1, 2], new Map([[1, [2]], [2, [1]]])), null);
+});
+
+test('the prompts name every task and the hall link', () => {
+  const tasks = [{ id: 5, title: 'Five' }, { id: 6, title: 'Six' }];
+  const par = buildBulkParallelPrompt(tasks, loc);
+  assert.match(par, /2 Bongos tasks IN PARALLEL/);
+  assert.match(par, /Session 2 — task 6 \(Six\) — https:\/\/builders\.example\.com#\/task\/6/);
+  const seq = buildBulkSequentialPrompt(tasks, { hostname: 'example.com', origin: 'https://example.com' });
+  assert.match(seq, /IN ORDER/);
+  assert.match(seq, /1\. Task 5 \(Five\) — https:\/\/example\.com\/builders#\/task\/5/);
+});
+
+// --- the factory, against a stub page --------------------------------------
+
+function stubPage(present) {
+  const els = {};
+  for (const id of present) els[id] = { hidden: true, disabled: false, textContent: '', title: '', listeners: {}, addEventListener(t, fn) { this.listeners[t] = fn; } };
+  globalThis.document = { getElementById: (id) => els[id] || null };
+  globalThis.window = { confirm: () => true };
+  globalThis.location = loc;
+  return els;
+}
+
+function build(els, over = {}) {
+  const calls = { claimMany: [], releaseMany: [], copied: [], toasts: [] };
+  const selection = { claim: new Set(), release: new Map() };
+  const tasks = new Map([[1, { id: 1, title: 'One' }], [2, { id: 2, title: 'Two' }]]);
+  const bar = makeBulkToolbar({
+    ids: { bar: 'bar', count: 'count', claim: 'claim', release: 'release', parallel: 'parallel', sequential: 'sequential', clear: 'clear' },
+    selection,
+    findTask: (id) => tasks.get(id),
+    claimAction: {
+      validateMany: async () => ({ ok: true, parallelSafe: true, byId: new Map() }),
+      claimMany: async (ids) => { calls.claimMany.push(ids); return { ok: true }; },
+      releaseMany: async (e) => { calls.releaseMany.push(e); return { ok: true }; },
+    },
+    getJSON: async () => ({ task: { dependencies: [] } }),
+    API: '/api/bongos',
+    copyText: async (t) => { calls.copied.push(t); return true; },
+    toast: (m) => calls.toasts.push(m),
+    curLabel: () => 'credits',
+    describeReason: (r) => r,
+    onClear: () => { calls.cleared = true; },
+    ...over,
+  });
+  return { bar, selection, calls };
+}
+const settle = () => new Promise((r) => setTimeout(r, 1000));
+
+test('nothing selected hides the bar', () => {
+  const els = stubPage(['bar', 'count', 'claim', 'release', 'parallel', 'sequential', 'clear']);
+  const { bar } = build(els);
+  els.bar.hidden = false;
+  bar.render();
+  assert.equal(els.bar.hidden, true);
+});
+
+test('a release selection alone enables Bulk release and leaves claim off', () => {
+  const els = stubPage(['bar', 'count', 'claim', 'release', 'parallel', 'sequential', 'clear']);
+  const { bar, selection } = build(els);
+  selection.release.set('77', '9');
+  bar.render();
+  assert.equal(els.bar.hidden, false);
+  assert.equal(els.count.textContent, '1 to release');
+  assert.equal(els.release.disabled, false);
+  assert.equal(els.claim.disabled, true);
+});
+
+test('two ready tasks enable both prompts once the checks come back, and the prompts copy', async () => {
+  const els = stubPage(['bar', 'count', 'claim', 'release', 'parallel', 'sequential', 'clear']);
+  const { bar, selection, calls } = build(els);
+  selection.claim.add('1'); selection.claim.add('2');
+  bar.render();
+  assert.equal(els.parallel.disabled, true, 'disabled while the dry run is pending');
+  await settle();
+  assert.equal(els.parallel.disabled, false);
+  assert.equal(els.sequential.disabled, false);
+  assert.equal(els.claim.textContent, 'Bulk claim (2)');
+  bar.wire();
+  await els.parallel.listeners.click();
+  await els.sequential.listeners.click();
+  assert.equal(calls.copied.length, 2);
+  assert.match(calls.copied[0], /IN PARALLEL/);
+  assert.match(calls.copied[1], /IN ORDER/);
+});
+
+test('a dependency cycle disables the sequential prompt with the reason', async () => {
+  const els = stubPage(['bar', 'count', 'claim', 'release', 'parallel', 'sequential', 'clear']);
+  const edges = { 1: [2], 2: [1] };
+  const { bar, selection } = build(els, { getJSON: async (p) => ({ task: { dependencies: edges[Number(p.split('/').pop())].map((id) => ({ id })) } }) });
+  selection.claim.add('1'); selection.claim.add('2');
+  bar.render();
+  await settle();
+  assert.equal(els.sequential.disabled, true);
+  assert.match(els.sequential.title, /cycle/);
+});
+
+test('a page without the optional buttons simply has no such feature', async () => {
+  const els = stubPage(['bar', 'count', 'claim', 'clear']);
+  const { bar, selection } = build(els);
+  selection.claim.add('1'); selection.claim.add('2');
+  assert.doesNotThrow(() => bar.render());
+  assert.doesNotThrow(() => bar.wire());
+  assert.equal(els.claim.textContent, 'Bulk claim (2)');
+});
+
+test('Bulk claim and Bulk release go through the shared action and empty their selection', async () => {
+  const els = stubPage(['bar', 'count', 'claim', 'release', 'parallel', 'sequential', 'clear']);
+  const { bar, selection, calls } = build(els);
+  selection.claim.add('1'); selection.release.set('77', '9');
+  bar.wire();
+  await els.claim.listeners.click();
+  assert.deepEqual(calls.claimMany, [[1]]);
+  assert.equal(selection.claim.size, 0);
+  await els.release.listeners.click();
+  assert.deepEqual(calls.releaseMany, [[['77', '9']]]);
+  assert.equal(selection.release.size, 0);
+});
+
+test('Clear empties both selections and lets the page repaint its cards', () => {
+  const els = stubPage(['bar', 'count', 'claim', 'release', 'parallel', 'sequential', 'clear']);
+  const { bar, selection, calls } = build(els);
+  selection.claim.add('1'); selection.release.set('77', '9');
+  bar.clearSelection();
+  assert.equal(selection.claim.size + selection.release.size, 0);
+  assert.equal(calls.cleared, true);
+  assert.equal(els.bar.hidden, true);
+});
+
+// --- the two boards use it, and neither keeps a private copy -----------------
+
+test('both boards build the shared toolbar and carry all five buttons', () => {
+  const work = read('work.html');
+  const goals = read('goals.html');
+  for (const k of ['claim', 'release', 'parallel', 'sequential', 'clear']) {
+    assert.match(work, new RegExp(`id="bulk-${k}-btn"`), `work.html has bulk-${k}-btn`);
+    assert.match(goals, new RegExp(`id="goal-bulk-${k}-btn"`), `goals.html has goal-bulk-${k}-btn`);
+  }
+  assert.match(read('work.js'), /OTBBulkToolbar\.makeBulkToolbar\(/);
+  assert.match(read('goals-render.js'), /OTBBulkToolbar\.makeBulkToolbar\(/);
+  for (const [page, scripts] of [['work.html', ['bulk-toolbar.js', 'work.js']], ['goals.html', ['bulk-toolbar.js', 'goals-render.js']]]) {
+    const html = read(page);
+    const at = (n) => html.indexOf(`src="/builders/${n}`);
+    assert.ok(at(scripts[0]) > -1 && at(scripts[0]) < at(scripts[1]), `${page}: bulk-toolbar.js loads before ${scripts[1]}`);
+  }
+});
+
+test('no board keeps a private copy of the toolbar logic', () => {
+  for (const f of ['work.js', 'goals-page.js', 'goals-render.js']) {
+    const src = read(f);
+    assert.doesNotMatch(src, /function topoOrder|function buildBulk(Parallel|Sequential)Prompt|function scheduleValidate|function doBulk(Claim|Release)|function doGoalBulkClaim/, `${f} re-grew toolbar logic`);
+  }
+});
+
+test('the goal board offers a release checkbox on the viewer\'s own cards, and it styles', () => {
+  const render = read('goals-render.js');
+  assert.match(render, /class="wip__select" data-claim-id=/, 'a mine-active card carries the release checkbox');
+  assert.match(read('goals-page.js'), /closest\('\.task__select, \.wip__select'\)/, 'the card list listens for it');
+  assert.match(read('style.css'), /\n\.wip__select \{/, '.wip__select is in the shared sheet the goal board loads');
+});
+
+test('goals.html no longer borrows work.css, and work.css no longer holds what it lent', () => {
+  assert.doesNotMatch(read('goals.html'), /work\.css/, 'the goal board is off the board-only sheet');
+  const work = read('work.css');
+  for (const sel of ['.claim-count-line', '.wip__release', '.wip__select']) {
+    assert.ok(!new RegExp(`^${sel.replace('.', '\\.')}(\\s|:|,|\\{)`, 'm').test(work), `work.css must not restate ${sel}`);
+  }
+  const style = read('style.css');
+  for (const sel of ['.claim-count-line', '.wip__release', '.wip__select']) {
+    assert.ok(new RegExp(`^${sel.replace('.', '\\.')} \\{`, 'm').test(style), `style.css carries ${sel}`);
+  }
+});