@bongos/core 1.19.864 → 1.19.866

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/modules/lifecycle/routes/tasks.js

@@ -29,6 +29,10 @@ const api = require('../../../src/module-api');
 // depRefusalRow: the ONE shape a dependency refusal carries, shared with the claim
 // path so promote and claim describe a blocked task identically (task 1003553).
 const { depRefusalRow } = require('../dead-deps.js');
+// gradeQualityWhere: the ONE definition of a task_grades row that is an actual
+// quality verdict rather than an outage or an errored worker (task 1002652).
+// The acclaim feed reads it so a grader outage never reaches a voter as 0.0.
+const { gradeQualityWhere } = require('../db-shared');
 const auth = api;
 const db = require('../db');
 const hierarchy = require('../hierarchy');
@@ -771,9 +775,28 @@ module.exports = function buildTasksRouter() {
                 t.shipped_at, t.shipped_by,
                 b.github_login, b.display_name,
                 COALESCE(pv.net, 0)::int AS net_votes,
-                mine.vote                AS my_vote
+                mine.vote                AS my_vote,
+                -- task 1002835: a karma vote is uninformed without the two facts
+                -- the ship already recorded. BOTH stay NULL when absent — an
+                -- ungraded ship and a zero-scoring one are different claims, and
+                -- so are an unlogged cost and a free one, so neither is
+                -- COALESCEd to a number the client would print as a measurement.
+                --
+                -- BOTH JOINS ARE INDEXED LOOKUPS, not scans: task_grades.task_id
+                -- is declared UNIQUE (migrations/016_pms_task_grades.sql:14, which
+                -- gives it its own index) and cost_log.task_id carries
+                -- idx_cost_log_task (migrations/003_pms.sql:152). Neither needs a
+                -- migration here, and neither degrades as cost_log grows.
+                CASE WHEN ${gradeQualityWhere('g')} THEN g.score END  AS grade_score,
+                CASE WHEN ${gradeQualityWhere('g')} THEN g.passed END AS grade_passed,
+                cost.total_usd          AS cost_usd
            FROM tasks t
            LEFT JOIN builders b ON b.id = t.shipped_by
+           LEFT JOIN task_grades g ON g.task_id = t.id
+           LEFT JOIN LATERAL (
+             SELECT SUM(amount_usd) AS total_usd
+               FROM cost_log WHERE task_id = t.id
+           ) cost ON true
            LEFT JOIN LATERAL (
              SELECT SUM(vote) AS net
                FROM peer_votes WHERE target_task_id = t.id
@@ -788,7 +811,15 @@ module.exports = function buildTasksRouter() {
           LIMIT $2`,
         [req.builder.id, limit]
       );
-      res.json({ tasks: rows, can_vote: ['metic', 'archon'].includes(req.builder.rank) });
+      const canVote = ['metic', 'archon'].includes(req.builder.rank);
+      // The cost is INTERNAL SPEND, and it is on this feed for one reason: to
+      // inform a vote. So it reaches only the ranks that can cast one. The grade
+      // is a quality verdict rather than spend and stays readable by any builder,
+      // as it already is on the grades table. Note the field is OMITTED, not
+      // nulled: a null here means "nothing was logged", and a reader who is not
+      // shown a figure must not be told a figure is missing.
+      const tasks = canVote ? rows : rows.map(({ cost_usd, ...rest }) => rest);
+      res.json({ tasks, can_vote: canVote });
     } catch (err) {
       // Log the detail server-side; don't return err.message — a raw Postgres
       // error can leak schema internals (table/column/constraint names).

package/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.864",
+  "version": "1.19.866",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@bongos/core",
-      "version": "1.19.864",
+      "version": "1.19.866",
       "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.866",
   "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/scripts/gds/run-unit-tests.js

@@ -71,6 +71,11 @@ const SUPPORT_MODULES = new Set(['helpers']);
 
 // Need a live DB / server / network — run in the integration-smoke gate instead.
 const INTEGRATION = new Set([
+  // task 1004004: the acclaim feed proves a claim about SQL semantics — that a
+  // grader outage nulls rather than scoring 0.0, and that a summed cost over no
+  // rows is NULL rather than a free ship. Only a transaction engine settles
+  // those, so this runs here and the DB-free sibling covers the renderer.
+  'acclaim_feed_evidence_db',
   'asset_version', 'auth_flow_slice1', 'backfill_sessions', 'bfg', 'bfg_write',
   'box_connect_e2e', 'box_onboard', 'boxes', 'cf_tunnel', 'cli_token_reissue',
   // consumer_layout_boot builds the core .tgz, `npm install`s it, and boots a live

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.866'; // 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/acclaim_feed_evidence_db.mjs

@@ -0,0 +1,186 @@
+// tests/acclaim_feed_evidence_db.mjs — the peer-acclaim feed's grade + cost
+// evidence, against a REAL Postgres (task 1004004, from task 1002835).
+//
+// WHY THIS EXISTS AND ITS DB-FREE SIBLING IS NOT ENOUGH.
+// tests/hall_builders_page_pass.mjs runs the RENDERER over every shape the row
+// can take, and asserts the route's SQL by reading its source. That proves the
+// client is honest about a NULL — it cannot prove the query ever PRODUCES one.
+// The whole argument of part C is a claim about SQL semantics that only a
+// transaction engine can settle:
+//
+//   - a grader OUTAGE row carries score 0 / passed=false in task_grades, and
+//     gradeQualityWhere must turn that into NULL rather than let a voter read
+//     it as a 0.0 verdict;
+//   - SUM(amount_usd) over ZERO cost_log rows is NULL, not 0, which is the
+//     difference between "no cost logged" and "this ship was free";
+//   - a ship with several cost rows must sum them, not pick one;
+//   - the two LATERALs and the grades join must not multiply the row out.
+//
+// Runs the route's own query text — sliced out of the shipped source, never
+// retyped — so a future edit to the route is tested rather than a copy of it.
+// Self-skips without a reachable Postgres; in the INTEGRATION set, so the
+// DB-free unit gate never runs it and .github/workflows/integration.yml does.
+//
+// Run:  DATABASE_URL=... node tests/acclaim_feed_evidence_db.mjs
+import { createRequire } from 'node:module';
+import { strict as assert } from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const { Pool } = require('pg');
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+try {
+  await pool.query('SELECT 1');
+} catch (e) {
+  console.log(`acclaim_feed_evidence_db.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+
+// The query under test, taken from the shipped route. gradeQualityWhere is
+// interpolated by the route at call time, so interpolate it the same way.
+const { gradeQualityWhere } = require('../modules/lifecycle/db-shared.js');
+const routeSrc = fs.readFileSync(path.join(ROOT, 'modules/lifecycle/routes/tasks.js'), 'utf8');
+const start = routeSrc.indexOf('`SELECT t.id, t.title, t.value_summary, t.version_id, t.status,');
+assert.ok(start > 0, 'the peer-votes feed query is still where this test slices it from');
+const end = routeSrc.indexOf('LIMIT $2`', start);
+assert.ok(end > start, 'the feed query still ends at its LIMIT');
+const SQL = routeSrc
+  .slice(start + 1, end + 'LIMIT $2'.length)
+  .replace(/\$\{gradeQualityWhere\('g'\)\}/g, gradeQualityWhere('g'));
+assert.ok(!SQL.includes('${'), 'every interpolation in the sliced query was resolved');
+
+const VOTER = 90000801;
+const SHIPPER = 90000802;
+const VER = 'ZZZ-ACC';
+// graded+costed, outage, ungraded, costed-twice, zero-cost
+const T = { GOOD: 90000811, OUTAGE: 90000812, UNGRADED: 90000813, TWICE: 90000814, FREE: 90000815 };
+const IDS = Object.values(T);
+
+const q = (sql, params) => pool.query(sql, params).then((r) => r.rows);
+
+async function cleanup() {
+  await q('DELETE FROM peer_votes WHERE target_task_id = ANY($1)', [IDS]);
+  await q('DELETE FROM cost_log WHERE task_id = ANY($1)', [IDS]);
+  await q('DELETE FROM task_grades WHERE task_id = ANY($1)', [IDS]);
+  await q('DELETE FROM tasks WHERE id = ANY($1)', [IDS]);
+  await q('DELETE FROM builders WHERE id = ANY($1)', [[VOTER, SHIPPER]]);
+  await q('DELETE FROM versions WHERE id = $1', [VER]);
+}
+
+let failures = 0;
+const check = (name, fn) => {
+  try { fn(); console.log(`  PASS  ${name}`); } catch (e) {
+    failures += 1; console.log(`  FAIL  ${name}\n        ${e.message}`);
+  }
+};
+
+try {
+  await cleanup();
+
+  await q("INSERT INTO versions (id, name, status) VALUES ($1, 'acclaim evidence fixture', 'planning')", [VER]);
+  for (const [id, login] of [[VOTER, 'zz-acc-voter'], [SHIPPER, 'zz-acc-shipper']]) {
+    await q("INSERT INTO builders (id, github_login, display_name, rank) VALUES ($1, $2, $2, 'metic')", [id, login]);
+  }
+  for (const [id, title] of [
+    [T.GOOD, '__acc__ graded and costed'],
+    [T.OUTAGE, '__acc__ grader outage'],
+    [T.UNGRADED, '__acc__ never graded'],
+    [T.TWICE, '__acc__ two cost rows'],
+    [T.FREE, '__acc__ a real zero'],
+  ]) {
+    await q(
+      `INSERT INTO tasks (id, version_id, title, status, shipped_by, shipped_at, discipline, kind)
+       VALUES ($1, $2, $3, 'shipped', $4, now(), 'engineer', 'feature')`,
+      [id, VER, title, SHIPPER],
+    );
+  }
+
+  const grade = (taskId, score, passed, rubric, signals) => q(
+    `INSERT INTO task_grades (task_id, score, passed, threshold, grader_kind, grader_version, rubric_scores, signals)
+     VALUES ($1, $2, $3, 7.0, 'subagent', 'test', $4::jsonb, $5::jsonb)`,
+    [taskId, score, passed, JSON.stringify(rubric), JSON.stringify(signals)],
+  );
+  const FULL = { functional_fidelity: 8, code_quality: 8 };
+  await grade(T.GOOD, 8.5, true, FULL, {});
+  // The shape that matters: an outage parks score 0 / passed=false with
+  // json-null rubric axes. A voter must never read that as a 0.0 verdict.
+  await grade(T.OUTAGE, 0, false, { functional_fidelity: null, code_quality: null }, { panel_outcome: 'unavailable' });
+  await grade(T.TWICE, 6.0, false, FULL, {});
+  await grade(T.FREE, 0, false, FULL, {});
+
+  const cost = (taskId, amount) => q(
+    "INSERT INTO cost_log (task_id, amount_usd, category, source) VALUES ($1, $2, 'api', 'test')",
+    [taskId, amount],
+  );
+  await cost(T.GOOD, '12.3456');
+  await cost(T.TWICE, '1.50');
+  await cost(T.TWICE, '2.25');
+  await cost(T.FREE, '0');
+  // T.OUTAGE and T.UNGRADED get no cost row at all.
+
+  const rows = await q(SQL, [VOTER, 100]);
+  const byId = new Map(rows.map((r) => [String(r.id), r]));
+  const got = (id) => {
+    const row = byId.get(String(id));
+    assert.ok(row, `task ${id} is on the feed`);
+    return row;
+  };
+
+  check('every fixture ship reaches the feed exactly once (the joins do not multiply rows)', () => {
+    for (const id of IDS) got(id);
+    for (const id of IDS) {
+      const n = rows.filter((r) => String(r.id) === String(id)).length;
+      assert.equal(n, 1, `task ${id} appears once, not ${n}`);
+    }
+  });
+
+  check('a graded, costed ship carries both figures', () => {
+    const r = got(T.GOOD);
+    assert.equal(Number(r.grade_score), 8.5);
+    assert.equal(r.grade_passed, true);
+    assert.equal(Number(r.cost_usd), 12.3456);
+  });
+
+  check('a GRADER OUTAGE arrives as NULL, never as its placeholder 0', () => {
+    const r = got(T.OUTAGE);
+    assert.equal(r.grade_score, null, 'the outage score is nulled by gradeQualityWhere');
+    assert.equal(r.grade_passed, null, 'and so is its passed flag — no verdict was reached');
+  });
+
+  check('a ship that was never graded has no grade row and so no score', () => {
+    assert.equal(got(T.UNGRADED).grade_score, null);
+  });
+
+  check('an unlogged cost is NULL, not 0 — the sum is never COALESCEd', () => {
+    assert.equal(got(T.UNGRADED).cost_usd, null, 'no cost_log row means no figure, not a free ship');
+    assert.equal(got(T.OUTAGE).cost_usd, null);
+  });
+
+  check('several cost rows sum rather than one winning', () => {
+    assert.equal(Number(got(T.TWICE).cost_usd), 3.75);
+  });
+
+  check('a genuine zero survives, because it IS a measurement', () => {
+    const r = got(T.FREE);
+    assert.equal(Number(r.cost_usd), 0, 'a logged 0 is a logged 0, distinct from NULL');
+    assert.notEqual(r.cost_usd, null);
+    assert.equal(Number(r.grade_score), 0, 'a real 0.0 verdict is not an outage and is not nulled');
+    assert.equal(r.grade_passed, false);
+  });
+
+  check('the caller never sees their own ships, so nobody votes on themselves', () => {
+    assert.ok(!rows.some((r) => String(r.shipped_by) === String(VOTER)));
+  });
+} finally {
+  await cleanup().catch(() => {});
+  await pool.end().catch(() => {});
+}
+
+const passed = 8 - failures;
+console.log(`\nacclaim_feed_evidence_db: ${passed} passed, ${failures} failed`);
+process.exit(failures ? 1 : 0);

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 : '\.'\)/);
+});