@bongos/core 1.19.864 → 1.19.865

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

@@ -1,19 +1,35 @@
-// blockers.js — the Blockers page: the full open-blocker queue (task 1003455,
-// goal 1000089).
+// blockers.js — the Blockers page: the full open-blocker queue, and now (task
+// 1003456, goal 1000089) the write half — file, resolve, link.
 //
 // GET /blockers (modules/ideas/routes/blockers.js) is PUBLIC and had ZERO hall
-// consumers before this task — the only blocker a builder could ever see was the
-// #/blocker/N overlay task-detail.js already renders, reachable only by typing
-// the id into the address bar. Owner decision 2026-08-30: BOTH surfaces, from
-// ONE code path — this page is the full queue (a long list has nowhere else to
-// live), and goal-inbox.js's attention-inbox slice is the capped summary. Both
-// render from blockers-lib.js's blockerFacts(), so the two cannot drift apart
-// the way ~10 hand-rolled pagers did before the kit (hall-ui/CLAUDE.md).
+// consumers before task 1003455 — the only blocker a builder could ever see was
+// the #/blocker/N overlay task-detail.js already renders, reachable only by
+// typing the id into the address bar. Owner decision 2026-08-30: BOTH surfaces,
+// from ONE code path — this page is the full queue (a long list has nowhere
+// else to live), and goal-inbox.js's attention-inbox slice is the capped
+// summary. Both render from blockers-lib.js's blockerFacts(), so the two
+// cannot drift apart the way ~10 hand-rolled pagers did before the kit.
+//
+// task 1003456 — the write half. POST /blockers, POST /blockers/:id/resolve
+// and POST /blockers/:id/link already carry their own rank floors (any-builder
+// for filing, blocker.review — metic+archon — for resolve/link; proven by the
+// fitness route-rank-check gate, not re-proven here). AUTHORITY IS UNCHANGED:
+// this file adds no floor of its own, only a COSMETIC mirror of the real one —
+// the exact idea-triage-panel precedent in task-detail.js ("The panel only
+// renders for metic/archon; the server enforces the same gate regardless").
+// The one control open to EVERY signed-in viewer, including a non-reviewer, is
+// filing — and the file form's own "blocking task #" field is deliberately
+// NOT hidden from a non-reviewer, because a builder who is themselves stuck is
+// exactly who most needs to say what it blocks, even though completing the
+// LINK half needs a Metic+. That is the case "every API refusal renders as
+// honest copy rather than a silent no-op" (the task's own done-when) exists
+// for: filing still succeeds, and the honest message says a Metic+ has to
+// finish the link — never a swallowed failure.
 //
-// Read-only: filing, resolving and linking a blocker to a task are task 1003456.
 // Deliberately UNGATED (tests/hall_page_gate_map.mjs) — its one data source is
 // public, the roster/drachmae precedent: a page must not be gated tighter than
-// the API it fronts.
+// the API it fronts. A signed-out visitor sees the queue and the File button;
+// clicking it redirects to sign-in, same as every other hall write.
 (function () {
   'use strict';
   var kit = window.OTBKit;
@@ -22,6 +38,45 @@
   var body = document.getElementById('blockers-body');
   var countPill = document.getElementById('blockers-count');
   var sub = document.getElementById('blockers-sub');
+  var fileArea = document.getElementById('blockers-file-area');
+
+  // The generated typed client (task-detail.js's own pattern), result-mode so
+  // the status-inspecting control flow below (401 → sign-in, 403 → honest
+  // copy) reads 1:1.
+  var api = window.BongosClient.createClient({ baseUrl: '', credentials: 'same-origin', throwOnError: false });
+  var toast = function (m) { if (window.OTB && window.OTB.toast) window.OTB.toast(m, { duration: 3200 }); };
+
+  async function writeJSON(method, path, payload) {
+    var res = await api.request(method, path, { body: payload || {} });
+    if (res.status === 401) { window.location.assign(API + '/auth/web/start'); throw new Error('redirecting to auth'); }
+    var data = null;
+    try { data = res.data; } catch (_) { /* empty / non-JSON */ }
+    if (!res.ok) { var err = new Error(path + ' → ' + res.status); err.status = res.status; err.data = data || {}; throw err; }
+    return data;
+  }
+
+  // The R01/ADR-0116 envelope is `{ error: { code, message } }` — nested, the
+  // same trap task-detail.js's errMessage() guards against.
+  function errMessage(err) {
+    var d = err && err.data;
+    var e = d && d.error;
+    if (e && typeof e === 'object' && e.message) return e.message;
+    return (d && d.message) || '';
+  }
+  // Honest copy for a refusal — never a silent no-op (the done-when, verbatim).
+  // Generic: prefers the server's own message, falling back to the caller's.
+  // Filing has NO rank floor, so a 403 there is never "you need Metic+" — that
+  // reading belongs only to the two calls that actually gate on blocker.review.
+  function refusalMessage(err, fallback) {
+    return errMessage(err) || fallback;
+  }
+  // The reviewer-gated calls' version: a 403 on resolve/link IS the
+  // blocker.review floor, so it gets the specific message rather than
+  // whatever (or nothing) the server's envelope happened to say.
+  function reviewerRefusalMessage(err, fallback) {
+    if (err && err.status === 403) return 'You need Metic+ access to do that.';
+    return refusalMessage(err, fallback);
+  }
 
   var taskHref = function (id) {
     return window.OTBTaskDetail ? window.OTBTaskDetail.href(id) : ('/task/' + encodeURIComponent(id));
@@ -29,6 +84,17 @@
   var blockerHref = function (id) { return '#/blocker/' + encodeURIComponent(id); };
 
   var all = [];
+  // Which rank a reviewer action (Resolve / Link) needs — mirrors the server's
+  // blocker.review floor (metic+archon), cosmetically only; the server holds
+  // the actual gate regardless of what this variable says.
+  var viewer = { rank: null };
+  var isReviewer = function () { return viewer.rank === 'metic' || viewer.rank === 'archon'; };
+
+  // Which row (if any) has an inline action form open, and which form.
+  // { id, mode: 'resolve' | 'link' } | null — a row's OWN form, not a global
+  // one, so opening a second row's form closes whichever was open (one at a
+  // time keeps the list from growing a form per row on a long queue).
+  var openRow = null;
 
   function rowHtml(b) {
     var facts = lib.blockerFacts(b, {
@@ -38,12 +104,46 @@
       blockerHref: blockerHref,
       taskHref: taskHref,
     });
+    var right = '';
+    if (isReviewer()) {
+      var id = String(b.id);
+      if (openRow && String(openRow.id) === id && openRow.mode === 'resolve') {
+        right = '<div class="ov-row__right"><form class="td-form" data-resolve-form="' + lib.esc(id) + '">'
+          + '<label class="td-field td-field--wide"><span>Resolution note (optional)</span>'
+          + '<input type="text" name="note" maxlength="1000" placeholder="what got un-stuck"></label>'
+          + '<div class="td-actions">'
+          + '<button type="submit" class="td-btn td-btn--primary" data-submit>Resolve</button>'
+          + '<button type="button" class="td-btn" data-row-cancel>Cancel</button>'
+          + '</div><p class="td-action-note" data-err></p></form></div>';
+      } else if (openRow && String(openRow.id) === id && openRow.mode === 'link') {
+        right = '<div class="ov-row__right"><form class="td-form" data-link-form="' + lib.esc(id) + '">'
+          + '<label class="td-field td-field--wide"><span>Task #</span>'
+          + '<input type="number" name="taskId" min="1" required placeholder="e.g. 1002980"></label>'
+          + '<div class="td-actions">'
+          + '<button type="submit" class="td-btn td-btn--primary" data-submit>Link</button>'
+          + '<button type="button" class="td-btn" data-row-cancel>Cancel</button>'
+          + '</div><p class="td-action-note" data-err></p></form></div>';
+      } else {
+        right = '<div class="ov-row__right"><div class="ov-row__actions">'
+          + '<button type="button" class="btn-ghost" data-resolve-open="' + lib.esc(id) + '">Resolve</button>'
+          + '<button type="button" class="btn-ghost" data-link-open="' + lib.esc(id) + '">Link a task</button>'
+          + '</div></div>';
+      }
+    }
+    // Plain .ov-row, never --lead: this row has no LEAD column (a face, as
+    // collab's rows have) — it is .ov-row__main + .ov-row__right, exactly the
+    // shape .ov-row's own grid (minmax(0,1fr) auto) already handles correctly,
+    // both at full width and under the family's ≤640px collapse. --lead's
+    // three-column grid (auto minmax(0,1fr) auto) would misread the actions
+    // column as the row's middle content and pin it beside the text on a
+    // phone instead of dropping it beneath.
     return '<li class="ov-row" data-id="' + lib.esc(String(b.id)) + '">'
       + '<div class="ov-row__main">'
       + facts.titleHtml
       + facts.noteHtml
       + '<div class="ov-row__facts">' + facts.factsHtml + '</div>'
       + '</div>'
+      + right
       + '</li>';
   }
 
@@ -57,6 +157,10 @@
       : kit.emptyStateHtml('Nothing is stuck on the owner right now.');
   }
 
+  function reload() {
+    return fetchBlockers().catch(function () { toast('Couldn’t refresh the queue — try reloading the page.'); });
+  }
+
   function mountBlockers(rows) {
     all = Array.isArray(rows) ? rows : [];
     if (countPill) { countPill.textContent = String(all.length); countPill.hidden = all.length === 0; }
@@ -78,11 +182,172 @@
     body.textContent = msg;
   }
 
-  fetch(API + '/blockers?limit=200', { headers: { Accept: 'application/json' } })
-    .then(function (r) {
-      if (!r.ok) throw new Error('http ' + r.status);
-      return r.json();
-    })
-    .then(function (data) { mountBlockers(data && data.blockers); })
-    .catch(function () { notice('Couldn’t load the blocker queue right now.'); });
+  function fetchBlockers() {
+    return fetch(API + '/blockers?limit=200', { headers: { Accept: 'application/json' } })
+      .then(function (r) {
+        if (!r.ok) throw new Error('http ' + r.status);
+        return r.json();
+      })
+      .then(function (data) { mountBlockers(data && data.blockers); });
+  }
+
+  // ---- filing (any signed-in builder) ----------------------------------------
+
+  function fileFormHtml() {
+    return '<div class="td-actions" id="blockers-file-toggle">'
+      + '<button type="button" class="btn-ghost" id="blockers-file-open">+ File a blocker</button>'
+      + '</div>'
+      + '<form class="td-form" id="blockers-file-form" hidden>'
+      + '<label class="td-field td-field--wide"><span>Title</span>'
+      + '<input type="text" id="bf-title" maxlength="200" required placeholder="what needs the owner’s decision"></label>'
+      + '<label class="td-field td-field--wide"><span>What’s stuck (optional)</span>'
+      + '<input type="text" id="bf-note" maxlength="2000" placeholder="a sentence of context"></label>'
+      + '<label class="td-field"><span>Blocking task # (optional)</span>'
+      + '<input type="number" id="bf-task-id" min="1" placeholder="e.g. 1002980"></label>'
+      + '<div class="td-actions">'
+      + '<button type="submit" class="td-btn td-btn--primary" id="bf-submit">File it</button>'
+      + '<button type="button" class="td-btn" id="bf-cancel">Cancel</button>'
+      + '</div><p class="td-action-note" id="bf-err"></p>'
+      // The one control open to a non-reviewer that the review floor still
+      // touches: filing succeeds regardless, but linking needs blocker.review,
+      // and a viewer below it is told so BEFORE they submit — not left to
+      // discover it from a refusal.
+      + (isReviewer() ? '' : '<p class="td-form-hint">Filing is open to anyone. Linking to a task needs Metic+ — if you name one and aren’t, the blocker still files and a Metic+ can link it.</p>')
+      + '</form>';
+  }
+
+  function wireFileForm() {
+    var openBtn = document.getElementById('blockers-file-open');
+    var form = document.getElementById('blockers-file-form');
+    var cancelBtn = document.getElementById('bf-cancel');
+    var errEl = document.getElementById('bf-err');
+    if (!openBtn || !form) return;
+    openBtn.addEventListener('click', function () {
+      openBtn.parentElement.hidden = true;
+      form.hidden = false;
+      document.getElementById('bf-title').focus();
+    });
+    cancelBtn.addEventListener('click', function () {
+      form.hidden = true;
+      openBtn.parentElement.hidden = false;
+      form.reset();
+      errEl.textContent = '';
+    });
+    form.addEventListener('submit', async function (ev) {
+      ev.preventDefault();
+      errEl.textContent = '';
+      var title = document.getElementById('bf-title').value.trim();
+      var note = document.getElementById('bf-note').value.trim();
+      var taskIdRaw = document.getElementById('bf-task-id').value.trim();
+      if (!title) { errEl.textContent = 'A title is required.'; return; }
+      var submitBtn = document.getElementById('bf-submit');
+      submitBtn.disabled = true;
+      try {
+        var res = await writeJSON('POST', API + '/blockers', { title: title, body_md: note });
+        var blocker = res && res.blocker;
+        if (res && res.skipped) {
+          // A duplicate (source, source_ref) skip returns no blocker id at
+          // all, so a typed task # was NEVER attempted — say so rather than
+          // silently dropping half the request the builder asked for.
+          toast(taskIdRaw
+            ? 'That blocker was already filed. It was NOT linked to task #' + taskIdRaw + ' — open the existing blocker to link it.'
+            : 'That blocker was already filed.');
+        } else if (blocker && taskIdRaw) {
+          var taskId = Number(taskIdRaw);
+          try {
+            await writeJSON('POST', API + '/blockers/' + encodeURIComponent(blocker.id) + '/link', { task_id: taskId });
+            toast('Blocker #' + blocker.id + ' filed and linked to task #' + taskId + '.');
+          } catch (linkErr) {
+            // Honest copy, not a silent no-op: the filing DID succeed, and the
+            // reader is told exactly what still needs a Metic+.
+            toast('Blocker #' + blocker.id + ' filed. ' + reviewerRefusalMessage(linkErr, 'Could not link it to task #' + taskId + ' — a Metic+ can do that from this page.'));
+          }
+        } else if (blocker) {
+          toast('Blocker #' + blocker.id + ' filed.');
+        } else {
+          toast('Filed.');
+        }
+        form.reset();
+        form.hidden = true;
+        document.getElementById('blockers-file-toggle').hidden = false;
+        await reload();
+      } catch (err) {
+        errEl.textContent = refusalMessage(err, 'Could not file that blocker. Try again.');
+      } finally {
+        submitBtn.disabled = false;
+      }
+    });
+  }
+
+  // ---- resolve / link (blocker.review — metic+archon; cosmetic mirror only) --
+
+  function closeRowForms() { openRow = null; rerender(); }
+
+  body.addEventListener('click', function (e) {
+    var resolveOpen = e.target.closest('[data-resolve-open]');
+    if (resolveOpen) { openRow = { id: resolveOpen.dataset.resolveOpen, mode: 'resolve' }; rerender(); return; }
+    var linkOpen = e.target.closest('[data-link-open]');
+    if (linkOpen) { openRow = { id: linkOpen.dataset.linkOpen, mode: 'link' }; rerender(); return; }
+    if (e.target.closest('[data-row-cancel]')) { closeRowForms(); }
+  });
+
+  body.addEventListener('submit', async function (e) {
+    var resolveForm = e.target.closest('[data-resolve-form]');
+    var linkForm = e.target.closest('[data-link-form]');
+    if (!resolveForm && !linkForm) return;
+    e.preventDefault();
+    var form = resolveForm || linkForm;
+    var id = (resolveForm || linkForm).getAttribute(resolveForm ? 'data-resolve-form' : 'data-link-form');
+    var errEl = form.querySelector('[data-err]');
+    var submitBtn = form.querySelector('[data-submit]');
+    submitBtn.disabled = true;
+    try {
+      if (resolveForm) {
+        var note = form.querySelector('[name="note"]').value.trim();
+        await writeJSON('POST', API + '/blockers/' + encodeURIComponent(id) + '/resolve', { resolution_note: note || null });
+        toast('Blocker #' + id + ' resolved.');
+      } else {
+        var taskId = Number(form.querySelector('[name="taskId"]').value);
+        await writeJSON('POST', API + '/blockers/' + encodeURIComponent(id) + '/link', { task_id: taskId });
+        toast('Blocker #' + id + ' linked to task #' + taskId + '.');
+      }
+      openRow = null;
+      await reload();
+    } catch (err) {
+      errEl.textContent = reviewerRefusalMessage(err, 'Could not do that. Try again.');
+      submitBtn.disabled = false;
+    }
+  });
+
+  // ---- boot -------------------------------------------------------------------
+
+  async function loadViewer() {
+    try {
+      var res = await api.request('GET', API + '/me');
+      if (res.ok && res.data && res.data.builder) {
+        viewer = { rank: String(res.data.builder.rank || '').toLowerCase() };
+      }
+    } catch (_) { /* signed out or offline — viewer stays { rank: null }, isReviewer() false */ }
+  }
+
+  loadViewer().then(function () {
+    if (fileArea) { fileArea.innerHTML = fileFormHtml(); wireFileForm(); }
+    // Boot race: GET /me and GET /blockers fire together, and rowHtml() reads
+    // isReviewer() at RENDER time. If the queue rendered first (the common
+    // case — /me is Metic+-gated work the server does more of), it rendered
+    // with isReviewer() still false and nothing re-draws it once the real
+    // rank lands — a Metic/Archon would see no Resolve/Link buttons until an
+    // unrelated re-render (a pager click, a file, an otb:blocker-resolved).
+    // Re-render now that the viewer is known, but only if the list actually
+    // exists yet (fetchBlockers may still be in flight — it will render
+    // correctly on its own the moment it resolves).
+    if (listEl) rerender();
+  });
+
+  fetchBlockers().catch(function () { notice('Couldn’t load the blocker queue right now.'); });
+
+  // A row's title opens the #/blocker/N overlay ON TOP of this page
+  // (task-detail.js), whose own Resolve panel fires this — refresh the queue
+  // in place rather than leaving a resolved row sitting there.
+  window.addEventListener('otb:blocker-resolved', reload);
 }());

package/modules/hall-ui/public/goal-inbox.js

@@ -530,4 +530,10 @@
     id: 'attention-scroll', label: 'Needs your attention', order: 20, mount, core: true,
     labelledby: 'attention-h', view: 'home', zone: 'home-main', hiddenByDefault: true,
   });
+
+  // task 1003456: a blocker resolved through the #/blocker/N overlay (which
+  // this slice's own row titles open into) should not sit in the inbox until
+  // the next full load — the otb:idea-triaged precedent, applied to the
+  // sibling event task-detail.js's blockerPanel fires.
+  window.addEventListener('otb:blocker-resolved', loadBlockers);
 })();

package/modules/hall-ui/public/task-detail.js

@@ -153,9 +153,97 @@
     if (kind === 'idea' && r.triage_note) {
       nodes.push(h('p', 'deeplink-card__note', 'Triage note: ' + r.triage_note));
     }
+
+    // task 1003456 (goal 1000089): the write half of the blocker queue. The
+    // overlay is the SAME summary→detail relationship the idea triage panel
+    // above already has with the /idea page — a compact card, not the full
+    // queue — so it carries only Resolve (the one-tap "this is done" verb);
+    // Link a task lives on the fuller /blockers page, which has room for the
+    // task-id field and the queue to confirm against. Rendered only for
+    // metic/archon, the COSMETIC mirror of the real blocker.review floor —
+    // "AUTHORITY IS UNCHANGED... the hall must add none of its own" — the
+    // server enforces the same gate regardless, exactly the idea panel's rule.
+    if (kind === 'blocker' && r.status === 'open' && (rank === 'metic' || rank === 'archon')) {
+      nodes.push(blockerPanel(r));
+    }
+    // A resolved blocker says what closed it — otherwise the status word has
+    // no story behind it (the idea triage_note precedent, two blocks up).
+    if (kind === 'blocker' && r.status === 'resolved') {
+      nodes.push(h('p', 'deeplink-card__note', 'Resolved' + (r.resolution_note ? ': ' + r.resolution_note : '.')));
+    }
     return nodes;
   }
 
+  // ---- the blocker resolve panel (task 1003456) ------------------------------
+  //
+  // One verb, one form — the renderDiscard shape below, at blocker scale.
+  function blockerPanel(blocker) {
+    var box = h('div', 'td-triage');
+    var mode = 'idle';
+
+    function note(text) {
+      var p = box.querySelector('[data-err]');
+      if (p) p.textContent = text || '';
+    }
+    function busy(on, submitLabel) {
+      box.querySelectorAll('button, input').forEach(function (el) { el.disabled = on; });
+      var submit = box.querySelector('[data-submit]');
+      if (submit) submit.textContent = on ? '…' : submitLabel;
+    }
+    function go(next) { mode = next; render(); }
+
+    function render() {
+      if (mode === 'idle') return renderIdle();
+      return renderResolve();
+    }
+
+    function renderIdle() {
+      box.innerHTML = '<div class="td-actions"><button type="button" class="td-btn td-btn--primary" data-go="resolve">Resolve</button></div>';
+    }
+
+    function renderResolve() {
+      box.innerHTML =
+        '<form class="td-form" data-form="resolve">'
+        + '<label class="td-field td-field--wide"><span>Resolution note (optional)</span>'
+        + '<input type="text" name="note" maxlength="1000" placeholder="what got un-stuck"></label>'
+        + '<div class="td-actions">'
+        + '<button type="submit" class="td-btn td-btn--primary" data-submit>Resolve</button>'
+        + '<button type="button" class="td-btn" data-go="idle">Cancel</button>'
+        + '</div><p class="td-action-note" data-err></p></form>';
+      box.querySelector('[data-form="resolve"]').addEventListener('submit', function (ev) {
+        ev.preventDefault();
+        submitResolve(ev.target);
+      });
+    }
+
+    async function submitResolve(form) {
+      note('');
+      busy(true, 'Resolve');
+      try {
+        await postJSON(API + '/blockers/' + encodeURIComponent(blocker.id) + '/resolve', {
+          resolution_note: String(form.note.value || '').trim() || null,
+        });
+        toast('Blocker #' + blocker.id + ' resolved.');
+        try {
+          window.dispatchEvent(new CustomEvent('otb:blocker-resolved', { detail: { id: blocker.id } }));
+        } catch (_) { /* CustomEvent unsupported — the refresh is a nicety */ }
+        clearLink();
+      } catch (err) {
+        // Honest copy, never a silent no-op — the done-when, verbatim.
+        var msg = (err && err.status === 403) ? 'You need Metic+ access to resolve blockers.' : (errMessage(err) || 'Could not resolve that blocker. Try again.');
+        busy(false, 'Resolve');
+        note(msg);
+      }
+    }
+
+    box.addEventListener('click', function (e) {
+      var btn = e.target.closest('[data-go]');
+      if (btn) go(btn.dataset.go);
+    });
+    render();
+    return box;
+  }
+
   // ---- the triage panel (task 1002447) ---------------------------------------
   //
   //   Promote → POST /tasks, then PATCH the idea promoted + linked to it.
@@ -633,10 +721,11 @@
     render({ loading: true, kind: kind, id: id });
     try {
       var ref = await fetchRef(kind, id);
-      // task 759: probe the viewer's rank only for an idea (so the overlay can
-      // offer Metic+ triage). Best-effort — a failure just hides the button.
+      // task 759: probe the viewer's rank for an idea OR a blocker (task
+      // 1003456 added the latter) so the overlay can offer Metic+ triage /
+      // resolve. Best-effort — a failure just hides the button.
       var viewer = null;
-      if (kind === 'idea' && ref) {
+      if ((kind === 'idea' || kind === 'blocker') && ref) {
         try {
           var me = await getJSON(API + '/me', { softAuth: true });
           viewer = (me && me.builder) ? me.builder : null;

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.864",
+  "version": "1.19.865",
   "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.864'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.865'; // 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/blockers_hall.mjs

@@ -27,6 +27,7 @@ const GOAL_INBOX_SRC = readFileSync(join(HALL, 'goal-inbox.js'), 'utf8');
 const BLOCKERS_JS_SRC = readFileSync(join(HALL, 'blockers.js'), 'utf8');
 const BLOCKERS_HTML_SRC = readFileSync(join(HALL, 'blockers.html'), 'utf8');
 const INDEX_HTML_SRC = readFileSync(join(HALL, 'index.html'), 'utf8');
+const TASK_DETAIL_SRC = readFileSync(join(HALL, 'task-detail.js'), 'utf8');
 
 // ---- the attention-inbox slice (goal-inbox.js) -----------------------------
 
@@ -105,3 +106,94 @@ test('every title link opens the SAME #/blocker/N overlay task-detail.js already
   assert.match(GOAL_INBOX_SRC, /`#\/blocker\/\$\{encodeURIComponent\(id\)\}`/);
   assert.match(BLOCKERS_JS_SRC, /'#\/blocker\/' \+ encodeURIComponent\(id\)/);
 });
+
+// ---- task 1003456: the write half — file, resolve, link -------------------
+//
+// POST /blockers, POST /blockers/:id/resolve and POST /blockers/:id/link
+// already carry their own server-side rank floors (any-builder / blocker.review
+// respectively), proven by the fitness route-rank-check gate — not re-proven
+// here. What this pins is the CLIENT side of the done-when: filing/resolving/
+// linking are actually wired to those routes, resolve/link mirror the real
+// floor cosmetically (never invent a stricter or looser one), filing itself
+// carries no such gate, and a refusal renders as honest copy rather than a
+// silent no-op.
+
+test('blockers.js files a blocker against the real POST /blockers route', () => {
+  assert.match(BLOCKERS_JS_SRC, /writeJSON\('POST', API \+ '\/blockers', \{ title: title, body_md: note \}\)/);
+});
+
+test('blockers.js resolves against the real POST /blockers/:id/resolve route', () => {
+  assert.match(BLOCKERS_JS_SRC, /API \+ '\/blockers\/' \+ encodeURIComponent\(id\) \+ '\/resolve'/);
+});
+
+test('blockers.js links against the real POST /blockers/:id/link route, from both the file form and a row', () => {
+  const matches = BLOCKERS_JS_SRC.match(/\/blockers\/'\s*\+\s*encodeURIComponent\([^)]+\)\s*\+\s*'\/link'/g) || [];
+  assert.ok(matches.length >= 2, `expected the file-form link attempt AND the per-row link form, found ${matches.length}`);
+});
+
+test('filing has no rank gate — any signed-in builder sees the File button, mirroring the any-builder route', () => {
+  assert.match(BLOCKERS_JS_SRC, /fileArea\.innerHTML = fileFormHtml\(\); wireFileForm\(\);/,
+    'the file form is mounted unconditionally, not behind an isReviewer()/rank check');
+});
+
+test('resolve/link controls mirror the SAME metic-or-archon floor the idea triage panel already uses — no floor of its own', () => {
+  assert.match(BLOCKERS_JS_SRC, /isReviewer\s*=\s*function\s*\(\)\s*\{\s*return viewer\.rank === 'metic' \|\| viewer\.rank === 'archon';\s*\}/);
+  assert.match(TASK_DETAIL_SRC, /kind === 'blocker' && r\.status === 'open' && \(rank === 'metic' \|\| rank === 'archon'\)/);
+});
+
+test('a 403 on resolve/link/file-link renders HONEST copy, not a silent no-op (the done-when, verbatim)', () => {
+  assert.match(BLOCKERS_JS_SRC, /err && err\.status === 403.*You need Metic\+ access to do that\./);
+  // The file-then-link flow specifically: a filer without blocker.review still
+  // gets told the filing succeeded AND that linking needs a Metic+ — never a
+  // swallowed catch that leaves them guessing whether anything happened.
+  assert.match(BLOCKERS_JS_SRC, /catch \(linkErr\) \{[\s\S]*?reviewerRefusalMessage\(linkErr,/);
+});
+
+test('the reviewer-only Metic+ message is scoped to resolve/link, never applied to filing itself (which has no rank floor)', () => {
+  // Two distinct helpers: a bare 403 on POST /blockers (filing) is NOT a
+  // blocker.review refusal and must not be read as one.
+  assert.match(BLOCKERS_JS_SRC, /function refusalMessage\(err, fallback\) \{\s*return errMessage\(err\) \|\| fallback;\s*\}/);
+  assert.match(BLOCKERS_JS_SRC, /function reviewerRefusalMessage\(err, fallback\)/);
+  assert.match(BLOCKERS_JS_SRC, /errEl\.textContent = refusalMessage\(err, 'Could not file that blocker\. Try again\.'\);/,
+    'the FILE form\'s own catch uses the generic helper, not the reviewer-specific one');
+});
+
+test('a deduped file with a task # typed says the link was NOT attempted, rather than a silent no-op', () => {
+  assert.match(BLOCKERS_JS_SRC, /taskIdRaw\s*\n\s*\?\s*'That blocker was already filed\. It was NOT linked/);
+});
+
+test('a 401 on any blockers.js write redirects to sign-in, same as every other hall write', () => {
+  assert.match(BLOCKERS_JS_SRC, /res\.status === 401.*window\.location\.assign\(API \+ '\/auth\/web\/start'\)/);
+});
+
+test('task-detail.js\'s blocker resolve panel posts to the real route and reports a refusal honestly', () => {
+  assert.match(TASK_DETAIL_SRC, /function blockerPanel\(blocker\)/);
+  assert.match(TASK_DETAIL_SRC, /postJSON\(API \+ '\/blockers\/' \+ encodeURIComponent\(blocker\.id\) \+ '\/resolve'/);
+  assert.match(TASK_DETAIL_SRC, /function submitResolve[\s\S]*?err && err\.status === 403[\s\S]*?You need Metic\+ access to resolve blockers\./);
+});
+
+test('resolving through the overlay tells the two OTHER blocker surfaces to refresh, so a resolved row does not sit there stale', () => {
+  assert.match(TASK_DETAIL_SRC, /new CustomEvent\('otb:blocker-resolved', \{ detail: \{ id: blocker\.id \} \}\)/);
+  assert.match(GOAL_INBOX_SRC, /window\.addEventListener\('otb:blocker-resolved', loadBlockers\)/);
+  assert.match(BLOCKERS_JS_SRC, /window\.addEventListener\('otb:blocker-resolved', reload\)/);
+});
+
+test('blockers.html carries the file-form mount, above the list', () => {
+  const fileAt = BLOCKERS_HTML_SRC.indexOf('id="blockers-file-area"');
+  const bodyAt = BLOCKERS_HTML_SRC.indexOf('id="blockers-body"');
+  assert.ok(fileAt > -1 && bodyAt > -1);
+  assert.ok(fileAt < bodyAt, 'filing sits above the queue it adds to');
+});
+
+test('a row never carries .ov-row--lead — this row has no lead/face column, and oversight.css\'s --lead grid would misplace the actions column on a phone', () => {
+  assert.doesNotMatch(BLOCKERS_JS_SRC, /ov-row--lead/);
+});
+
+test('viewer carries no unread field — dead state is not left lying around', () => {
+  assert.doesNotMatch(BLOCKERS_JS_SRC, /\bauthed\b/, 'viewer.authed was written and never read');
+});
+
+test('a resolved blocker on the overlay shows what closed it, the idea triage_note precedent', () => {
+  assert.match(TASK_DETAIL_SRC, /kind === 'blocker' && r\.status === 'resolved'/);
+  assert.match(TASK_DETAIL_SRC, /'Resolved' \+ \(r\.resolution_note \? ': ' \+ r\.resolution_note : '\.'\)/);
+});