@bongos/core 1.20.46 → 1.20.47

package/modules/hall-ui/public/bulk-toolbar.js

@@ -0,0 +1,291 @@
+// modules/hall-ui/public/bulk-toolbar.js — the hall's ONE bulk-action toolbar
+// (task 1003141, carved from idea 1000568).
+//
+// WHAT IT IS. The bar that floats over a board once one or more task cards are
+// ticked: Bulk claim, Bulk release, Copy parallel prompt, Copy sequential prompt,
+// Clear. It lived inside work.js (task 1759), and the Goals page carried a
+// claim-only subset copied from it. Now both pages build it from here, so the
+// toolbar a builder meets on /work and on /goals is the same toolbar.
+//
+// FLAGS ARE ELEMENTS. A page asks for a button by putting it in its markup: no
+// release button in the HTML means no bulk release on that surface, and the
+// parallel / sequential prompts the same. The factory never assumes one exists.
+//
+// WHAT STAYS WITH THE PAGE. The selection itself (a Set of ready task ids and a
+// Map of claim id → task id, both mutated by the page's own checkboxes), how
+// "Clear" repaints the page's cards, and the claim call itself — which is
+// OTBClaimAction's, never this file's (tests/claim_action.mjs fails if a hall
+// script POSTs to /claims). This file only decides what the bar shows and
+// what each button does with the selection.
+//
+// Pure helpers (topoOrder, the two prompt builders) are exported for a test to
+// run directly; the factory is browser-only. Dependency-free, like task-lib.js.
+(() => {
+  'use strict';
+
+  // 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 hallBase(loc) {
+    return loc.hostname.startsWith('builders.') ? loc.origin : `${loc.origin}/builders`;
+  }
+
+  // The paste-into-your-agent prompt for several tasks at once, one session each.
+  function buildBulkParallelPrompt(tasks, loc = location) {
+    const base = hallBase(loc);
+    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}) — ${base}#/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();
+  }
+
+  // The same, for one session working the tasks in dependency order.
+  function buildBulkSequentialPrompt(tasks, loc = location) {
+    const base = hallBase(loc);
+    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}) — ${base}#/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');
+  }
+
+  // Build one page's toolbar.
+  //   ids          element ids: bar, count, claim, clear (required) and release,
+  //                parallel, sequential (each optional — absent = feature off)
+  //   selection    { claim: Set<String task_id>, release: Map<String claim_id, task_id> }
+  //                — the page's live object; release may be omitted
+  //   findTask     (numeric id) → the task row the prompts name, or undefined
+  //   claimAction  OTBClaimAction (claimMany, releaseMany, validateMany)
+  //   getJSON      (path, opts) → body, for the dependency lookups
+  //   copyText     (text) → Promise<boolean>
+  //   onClear      repaint the page's cards after the selection is emptied
+  function makeBulkToolbar({ ids, selection, findTask, claimAction, getJSON, API, copyText, toast, curLabel, describeReason, onClear }) {
+    const el = (key) => (ids[key] ? document.getElementById(ids[key]) : null);
+    const releaseSel = () => selection.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 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;
+
+    const selectionTotal = () => selection.claim.size + releaseSel().size;
+    const selectedClaimIds = () => [...selection.claim].map(Number);
+    const selectionKey = (list) => list.slice().sort((a, b) => a - b).join(',');
+
+    function scheduleValidate(key, list) {
+      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(list);
+        validateCache.key = key;
+        validateCache.parallelSafe = out.parallelSafe;
+        validateCache.byId = out.byId;
+        render();
+      }, 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;
+    }
+
+    function scheduleSequentialCheck(key, list) {
+      if (sequentialDebounce) clearTimeout(sequentialDebounce);
+      sequentialDebounce = setTimeout(async () => {
+        const edgesByTask = new Map();
+        await Promise.all(list.map(async (id) => { edgesByTask.set(id, await fetchDeps(id)); }));
+        sequentialCache.key = key;
+        sequentialCache.order = topoOrder(list, edgesByTask);
+        render();
+      }, 350);
+    }
+
+    function render() {
+      const bar = el('bar');
+      if (!bar) return;
+      if (selectionTotal() === 0) { bar.hidden = true; return; }
+      bar.hidden = false;
+
+      const countEl = el('count');
+      if (countEl) {
+        const parts = [];
+        if (selection.claim.size) parts.push(`${selection.claim.size} to claim`);
+        if (releaseSel().size) parts.push(`${releaseSel().size} to release`);
+        countEl.textContent = parts.join(' · ');
+      }
+
+      const claimBtn = el('claim');
+      if (claimBtn) {
+        claimBtn.disabled = selection.claim.size === 0;
+        claimBtn.textContent = selection.claim.size > 1 ? `Bulk claim (${selection.claim.size})` : 'Bulk claim';
+      }
+      const releaseBtn = el('release');
+      if (releaseBtn) {
+        releaseBtn.disabled = releaseSel().size === 0;
+        releaseBtn.textContent = releaseSel().size > 1 ? `Bulk release (${releaseSel().size})` : 'Bulk release';
+      }
+
+      const parallelBtn = el('parallel');
+      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 list = selectedClaimIds();
+          const key = selectionKey(list);
+          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(describeReason).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, list);
+          }
+        }
+      }
+
+      const sequentialBtn = el('sequential');
+      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 list = selectedClaimIds();
+          const key = selectionKey(list);
+          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, list);
+          }
+        }
+      }
+    }
+
+    function clearSelection() {
+      selection.claim.clear();
+      releaseSel().clear();
+      if (onClear) onClear();
+      render();
+    }
+
+    async function doBulkClaim() {
+      const list = selectedClaimIds();
+      if (!list.length) return;
+      const btn = el('claim');
+      if (btn) { btn.disabled = true; btn.textContent = 'Claiming…'; }
+      try {
+        const out = await claimAction.claimMany(list);
+        if (out.ok) selection.claim.clear();
+      } finally {
+        render();
+      }
+    }
+
+    async function doBulkRelease() {
+      const entries = [...releaseSel().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 = el('release');
+      if (btn) { btn.disabled = true; btn.textContent = 'Releasing…'; }
+      try {
+        const out = await claimAction.releaseMany(entries);
+        if (out.ok) releaseSel().clear();
+      } finally {
+        render();
+      }
+    }
+
+    async function copyParallel() {
+      const tasks = selectedClaimIds().map(findTask).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.');
+    }
+
+    async function copySequential() {
+      const key = selectionKey(selectedClaimIds());
+      if (sequentialCache.key !== key || sequentialCache.order == null) return;
+      const tasks = sequentialCache.order.map(findTask).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.');
+    }
+
+    // Bind each button that exists in this page's markup.
+    function wire() {
+      el('claim')?.addEventListener('click', doBulkClaim);
+      el('release')?.addEventListener('click', doBulkRelease);
+      el('clear')?.addEventListener('click', clearSelection);
+      el('parallel')?.addEventListener('click', copyParallel);
+      el('sequential')?.addEventListener('click', copySequential);
+    }
+
+    return { render, wire, clearSelection, selectionTotal };
+  }
+
+  const api = { topoOrder, buildBulkParallelPrompt, buildBulkSequentialPrompt, makeBulkToolbar };
+  if (typeof window !== 'undefined') window.OTBBulkToolbar = api;
+  if (typeof module !== 'undefined' && module.exports) module.exports = api;
+})();

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

@@ -375,6 +375,20 @@
   // goal-title match — a single goal makes that redundant).
   // Copy-prompt (work.js:454-503). deHashRefs stops a bare #NNN autolinking to
   // GitHub in a pasted session; the prompt points the builder at the hall task URL.
+  // Clipboard write that says whether it worked (the bulk prompts report it).
+  async function copyText(text) {
+    try { await navigator.clipboard.writeText(text); return true; }
+    catch (_) {
+      try {
+        const ta = document.createElement('textarea');
+        ta.value = text; ta.style.position = 'fixed'; ta.style.opacity = '0';
+        document.body.appendChild(ta); ta.select();
+        const ok = document.execCommand('copy');
+        ta.remove();
+        return ok;
+      } catch (_e) { return false; }
+    }
+  }
   async function copyPromptForTask(taskId, btn) {
     const t = state.work.todo.find((x) => String(x.id) === String(taskId));
     if (!t) return;
@@ -399,53 +413,25 @@
   // Uses the SAME .task markup + classes as the board, so work.css (linked from
   // goals.html) styles it identically. The lead cell + actions adapt to status.
 
-  // ---- multi-select + bulk claim (work.js:583-828, claim-only subset) --------
-  // Selection holds String(task_id) of READY cards the viewer ticked. Bulk
-  // release + copy parallel/sequential prompts stay board-only for now (a goal is
-  // a narrow slice where the headline value is "grab several of this goal's ready
-  // tasks at once"); see the goals.html toolbar comment.
+  // ---- multi-select ------------------------------------------------------------
+  // Selection holds the READY cards the viewer ticked (to claim) and their own
+  // ACTIVE cards (to release). The toolbar over it — bulk claim / release, the
+  // parallel and sequential prompts — is the hall's shared one, bulk-toolbar.js,
+  // built in goals-render.js beside the selection.
   function toggleGoalCardSelect(card, forceChecked) {
-    const cb = card.querySelector('.task__select');
+    const cb = card.querySelector('.task__select, .wip__select');
     if (!cb) return;
     const next = forceChecked != null ? forceChecked : !cb.checked;
     cb.checked = next;
     const id = String(cb.dataset.taskId);
-    if (next) goalSel.claim.add(id); else goalSel.claim.delete(id);
+    const claimId = cb.dataset.claimId;
+    if (claimId) {
+      if (next) goalSel.release.set(claimId, id); else goalSel.release.delete(claimId);
+    } else if (next) goalSel.claim.add(id); else goalSel.claim.delete(id);
     card.classList.toggle('task--selected', next);
     renderGoalBulkToolbar();
   }
-  function clearGoalSelection() {
-    goalSel.claim.clear();
-    document.querySelectorAll('#goal-todo-list .task--selected').forEach((c) => c.classList.remove('task--selected'));
-    document.querySelectorAll('#goal-todo-list .task__select:checked').forEach((cb) => { cb.checked = false; });
-    renderGoalBulkToolbar();
-  }
-  // Drop any selected id that's fallen out from under the selection (claimed by
-  // someone else, shipped, or we navigated to another goal) so a stale tick never
-  // outlives its card. Called after every task reload (work.js:606-619).
-  // A single batch-item failure reason → a readable fragment (work.js:545-562).
-  // Bulk claim the selected ready cards (work.js doBulkClaim, claims/batch is
-  // all-or-nothing: a 409 batch_failed means nothing was claimed). Reloads the
-  // goal's tasks either way so the cards reflect fresh truth.
-  async function doGoalBulkClaim() {
-    const ids = [...goalSel.claim].map(Number);
-    if (!ids.length) return;
-    const btn = $('#goal-bulk-claim-btn');
-    if (btn) { btn.disabled = true; btn.textContent = 'Claiming…'; }
-    try {
-      const out = await claimAction.claimMany(ids);
-      if (out.ok) goalSel.claim.clear();
-    } finally {
-      // The shared action already reloaded the open goal's task list, on the
-      // success path AND the 409 one — re-fetching here would make every bulk
-      // claim on this page fetch and re-render twice. work.js's doBulkClaim is
-      // the right shape: redraw the toolbar, nothing else. It has to happen on
-      // every path, because the button was disabled above and the paths where
-      // no reload runs (the auth redirect, a refresh that failed quietly) have
-      // nothing else to re-enable it.
-      renderGoalBulkToolbar();
-    }
-  }
+  function clearGoalSelection() { bulk.clearSelection(); }
 
   // Client-side conflict estimate: exact/prefix overlap between the declared
   // touches[] of not-yet-done tasks. Deliberately conservative — the glob-aware
@@ -464,8 +450,8 @@
   // is passed straight through; workTabs is a GETTER because it is reassigned
   // after boot and a renderer must see the current controller, not the null it
   // held here at startup. This call sits AFTER every declaration it passes.
-  const { GOAL_SORTS, WORK_SORT_HEADERS, errCode, errDetails, friendlyClaimError, goalSel, goalSelTotal, loadDetail, loadDirectory, loadGoalTasks, pagers, reflectSortHeaders, renderDetail, renderGoalBulkToolbar, renderList, renderTodoCards, renderWork } = window.OTBGoalsRender({
-    API, curLabel, getJSON, patchJSON, postJSON, sameId, selfId, state,
+  const { GOAL_SORTS, WORK_SORT_HEADERS, bulk, errCode, errDetails, friendlyClaimError, goalSel, goalSelTotal, loadDetail, loadDirectory, loadGoalTasks, pagers, reflectSortHeaders, renderDetail, renderGoalBulkToolbar, renderList, renderTodoCards, renderWork } = window.OTBGoalsRender({
+    API, claimAction, copyText, curLabel, getJSON, patchJSON, postJSON, sameId, selfId, state,
     get workTabs() { return workTabs; },
   });
 
@@ -1073,7 +1059,7 @@
   // task 1002425 — the To-do card list: multi-select + inline Claim/Release +
   // copy-prompt + open, mirroring the board's task-list wiring (work.js:1245-1272).
   $('#goal-todo-list')?.addEventListener('click', (e) => {
-    const selectCb = e.target.closest('.task__select');
+    const selectCb = e.target.closest('.task__select, .wip__select');
     if (selectCb) { const card = selectCb.closest('.task'); if (card) toggleGoalCardSelect(card, selectCb.checked); return; }
     const claimBtn = e.target.closest('[data-claim-task]');
     if (claimBtn) { e.stopPropagation(); doGoalClaim(claimBtn.dataset.claimTask, claimBtn); return; }
@@ -1095,8 +1081,7 @@
     }
   });
   // task 1002425 — the goal's bulk-action toolbar.
-  $('#goal-bulk-claim-btn')?.addEventListener('click', doGoalBulkClaim);
-  $('#goal-bulk-clear-btn')?.addEventListener('click', clearGoalSelection);
+  bulk.wire();
   // task 1002164 — Confirm on a pending-review criterion, in both the capped
   // band column and the dedicated #/goal/N/completion view.
   ['#goal-completion-body', '#goal-completion-full'].forEach((sel) => {

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

@@ -18,7 +18,7 @@
   'use strict';
 
   window.OTBGoalsRender = function createGoalsRender(ctx) {
-    const { API, curLabel, getJSON, patchJSON, postJSON, sameId, selfId, state } = ctx;
+    const { API, claimAction, copyText, curLabel, getJSON, patchJSON, postJSON, sameId, selfId, state } = ctx;
     const { escapeHtml, $, fmtNum, fmtDate, toast, rankLabel, categoryChip } = window.OTB;
     const {
       priorityRank, touchesConflict, rankTagHtml, deHashRefs,
@@ -346,12 +346,16 @@
     const claim = state.claimsByTask.get(id);
     const isReady = t.status === 'ready' && !!state.me;
     const mineActive = t.status === 'active' && claim && sameId(claim.builder_id, selfId());
-    const selected = goalSel.claim.has(id);
-    // Lead: a select checkbox on ready cards (drives bulk claim); otherwise a
-    // status tag so active/backlog cards read at a glance.
+    const releaseKey = mineActive ? String(claim.claim_id) : null;
+    const selected = isReady ? goalSel.claim.has(id) : (mineActive && goalSel.release.has(releaseKey));
+    // Lead: a select checkbox on ready cards (drives bulk claim) and on the
+    // viewer's own active cards (drives bulk release, the board's `.wip__select`);
+    // otherwise a status tag so other cards read at a glance.
     const lead = isReady
       ? `<input type="checkbox" class="task__select" data-task-id="${escapeHtml(id)}" aria-label="Select task ${escapeHtml(id)} for bulk claim"${selected ? ' checked' : ''}>`
-      : `<span class="task__tag" title="Task status">${escapeHtml(t.status || '')}</span>`;
+      : (mineActive
+        ? `<input type="checkbox" class="wip__select" data-claim-id="${escapeHtml(releaseKey)}" data-task-id="${escapeHtml(id)}" aria-label="Select task ${escapeHtml(id)} for bulk release"${selected ? ' checked' : ''}>`
+        : `<span class="task__tag" title="Task status">${escapeHtml(t.status || '')}</span>`);
     // Actions: ready → Claim + copy; mine-active → Release; other's active →
     // "claimed · @who"; anything else → nothing (open via the title / card).
     let actions = '';
@@ -392,25 +396,33 @@
         <div class="task__actions">${actions}</div>
       </div>`;
   }
-  const goalSel = { claim: new Set() };
-  function goalSelTotal() { return goalSel.claim.size; }
+  // The goal's selection: ready cards to claim, the viewer's own active cards to
+  // release (claim id -> task id). The toolbar over it is the hall's shared one.
+  const goalSel = { claim: new Set(), release: new Map() };
+  function goalSelTotal() { return goalSel.claim.size + goalSel.release.size; }
   function pruneGoalSelection() {
     const readyIds = new Set(state.work.todo.filter((t) => t.status === 'ready').map((t) => String(t.id)));
     for (const id of Array.from(goalSel.claim)) if (!readyIds.has(id)) goalSel.claim.delete(id);
+    const mineClaimIds = new Set(
+      state.work.todo
+        .filter((t) => t.status === 'active')
+        .map((t) => state.claimsByTask.get(String(t.id)))
+        .filter((c) => c && sameId(c.builder_id, selfId()))
+        .map((c) => String(c.claim_id)),
+    );
+    for (const claimId of Array.from(goalSel.release.keys())) if (!mineClaimIds.has(claimId)) goalSel.release.delete(claimId);
   }
-  function renderGoalBulkToolbar() {
-    const bar = $('#goal-bulk-toolbar');
-    if (!bar) return;
-    if (goalSelTotal() === 0) { bar.hidden = true; return; }
-    bar.hidden = false;
-    const countEl = $('#goal-bulk-count');
-    if (countEl) countEl.textContent = `${goalSel.claim.size} to claim`;
-    const claimBtn = $('#goal-bulk-claim-btn');
-    if (claimBtn) {
-      claimBtn.disabled = goalSel.claim.size === 0;
-      claimBtn.textContent = goalSel.claim.size > 1 ? `Bulk claim (${goalSel.claim.size})` : 'Bulk claim';
-    }
-  }
+  const bulk = window.OTBBulkToolbar.makeBulkToolbar({
+    ids: { bar: 'goal-bulk-toolbar', count: 'goal-bulk-count', claim: 'goal-bulk-claim-btn', release: 'goal-bulk-release-btn', parallel: 'goal-bulk-parallel-btn', sequential: 'goal-bulk-sequential-btn', clear: 'goal-bulk-clear-btn' },
+    selection: goalSel,
+    findTask: (id) => state.work.todo.find((t) => Number(t.id) === id),
+    claimAction, getJSON, API, copyText, toast, curLabel, describeReason: friendlyBatchReason,
+    onClear: () => {
+      document.querySelectorAll('#goal-todo-list .task--selected').forEach((c) => c.classList.remove('task--selected'));
+      document.querySelectorAll('#goal-todo-list .task__select:checked, #goal-todo-list .wip__select:checked').forEach((cb) => { cb.checked = false; });
+    },
+  });
+  function renderGoalBulkToolbar() { bulk.render(); }
   function taskRowsDone(tasks) {
     return tasks.map((t) => `
       <tr class="ledger__row--task" data-task-id="${escapeHtml(String(t.id))}" style="cursor:pointer" title="Open task #${escapeHtml(String(t.id))}">
@@ -1464,6 +1476,6 @@
     return d;
   }
 
-    return { GOAL_SORTS, WORK_SORT_HEADERS, errCode, errDetails, friendlyClaimError, goalSel, goalSelTotal, loadDependencyForest, loadDetail, loadDirectory, loadGoalTasks, pagers, reflectSortHeaders, renderDependencyForest, renderDetail, renderGoalBulkToolbar, renderList, renderTodoCards, renderWork };
+    return { GOAL_SORTS, WORK_SORT_HEADERS, errCode, errDetails, friendlyClaimError, bulk, goalSel, goalSelTotal, loadDependencyForest, loadDetail, loadDirectory, loadGoalTasks, pagers, reflectSortHeaders, renderDependencyForest, renderDetail, renderGoalBulkToolbar, renderList, renderTodoCards, renderWork };
   };
 })();

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

@@ -16,14 +16,6 @@
        block per the hall placement rules; shared pager/filter/tab/count-pill
        styles now live in style.css's hall-kit section. -->
   <link rel="stylesheet" href="/builders/goals.css">
-  <!-- task 1002425 — the goal-detail "Tasks" pane mirrors the Tasks board's
-       claimable cards + bulk toolbar, so it needs the board's page-local card /
-       .task__claim / .bulk-toolbar styling. That styling lives in work.css (the
-       shared base .task grid is already in style.css above); linking it here is
-       the no-duplication way to give both surfaces identical cards. (Follow-up:
-       promote the shared card/toolbar rules into style.css so work.css can go
-       back to being board-only — idea captured at ship.) -->
-  <link rel="stylesheet" href="/builders/work.css">
 </head>
 <body data-page="goals" data-page-title="Goals">
 
@@ -178,16 +170,19 @@
           </div>
 
           <!-- task 1002425 — bulk-action toolbar for the goal's task cards,
-               mirroring the Tasks board's toolbar. Hidden until 1+ ready cards are
-               selected. position:fixed (via .bulk-toolbar in work.css) so its DOM
-               location here is immaterial; it lives inside the detail view so it's
-               scoped to this route and cleared on route change. Bulk claim is the
-               headline action; bulk release + copy parallel/sequential prompts
-               stay board-only for now (noted follow-up). -->
+               mirroring the Tasks board's toolbar (task 1003141: the same shared
+               toolbar, bulk-toolbar.js, so every button the board offers is here).
+               Hidden until 1+ cards are selected; position:fixed (via
+               .bulk-toolbar in style.css) so its DOM location here is immaterial.
+               It lives inside the detail view so it's scoped to this route and
+               cleared on route change. -->
           <div id="goal-bulk-toolbar" class="bulk-toolbar" hidden role="region" aria-label="Bulk actions">
             <span class="bulk-toolbar__count" id="goal-bulk-count"></span>
             <div class="bulk-toolbar__actions">
               <button type="button" class="bulk-toolbar__btn" id="goal-bulk-claim-btn">Bulk claim</button>
+              <button type="button" class="bulk-toolbar__btn" id="goal-bulk-release-btn">Bulk release</button>
+              <button type="button" class="bulk-toolbar__btn" id="goal-bulk-parallel-btn">Copy parallel prompt</button>
+              <button type="button" class="bulk-toolbar__btn" id="goal-bulk-sequential-btn">Copy sequential prompt</button>
             </div>
             <button type="button" class="bulk-toolbar__clear" id="goal-bulk-clear-btn">Clear</button>
           </div>
@@ -261,7 +256,8 @@
 <!-- task 1003206: the page RENDERERS, the second half of the carve goals-lib.js
      began — goals-lib took the pure helpers, this takes the view painters.
      Loaded BEFORE goals-page.js, which calls window.OTBGoalsRender(ctx). -->
-<script src="/builders/goals-render.js?v=2026-09-26-claimaction1"></script>
-<script src="/builders/goals-page.js?v=2026-09-26-claimaction1"></script>
+<script src="/builders/bulk-toolbar.js"></script>
+<script src="/builders/goals-render.js?v=2026-09-30-bulktoolbar"></script>
+<script src="/builders/goals-page.js?v=2026-09-30-bulktoolbar"></script>
 </body>
 </html>

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

@@ -2876,16 +2876,87 @@ main [id] { scroll-margin-top: calc(var(--topbar-h) + 16px); }
 }
 .bulk-toolbar__clear:hover { color: var(--ink); }
 
+/* ---- shared by the Tasks board AND the goal board's cards (task 1003141) ----
+   These three used to live in work.css, which goals.html borrowed whole. They
+   are single-class rules no other sheet restates, so moving them earlier in the
+   cascade changes nothing — checked by computed style on both pages. */
+
+/* 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);
+}
+
+.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__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);
+}
+
 /* The shell's .app-content already ends in 108px of bottom air at desktop
    width, which is what clears the bar — but at 768 it drops to 48px for the
    phone, and there the bar is TALLER (its actions wrap to their own row). So
-   the phone width buys the room back, scoped to this page: goals.html loads
-   this sheet too and has no bulk toolbar to clear. */
+   the phone width buys the room back, scoped to the two pages that carry the
+   toolbar (the goal board gained the full one in task 1003141). */
 @media (max-width: 768px) {
   /* At the drawer breakpoint the sidebar leaves the flow, so the bar spans. */
   .bulk-toolbar { left: 0; padding: 10px 14px; gap: 10px; }
   .bulk-toolbar__actions { margin-left: 0; width: 100%; }
-  body[data-page="work"] .app-content { padding-bottom: 200px; }
+  body[data-page="work"] .app-content,
+  body[data-page="goals"] .app-content { padding-bottom: 200px; }
 }
 
 .task__credits { display: flex; flex-direction: column; align-items: flex-end; gap: 2px; padding-top: 2px; }