@bongos/core 1.19.36 → 1.19.38

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.36",
-  "core_contract": "1.19.36",
-  "source_commit": "f97b75c015a281b9492699354142dadb85b5458c",
+  "core_version": "1.19.38",
+  "core_contract": "1.19.38",
+  "source_commit": "ba6a8f6285476ab3cd4e33f9278b333ac0fc3a29",
   "source_ref": "HEAD",
-  "built_at": "2026-08-11T15:56:45.212Z",
+  "built_at": "2026-08-11T16:17:20.571Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
-    "docs_redacted": 287,
+    "docs_redacted": 288,
     "agent_docs_stubbed": 21,
-    "functional_verbatim": 1210,
+    "functional_verbatim": 1212,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 1518,
-  "tree_sha256": "59a933fb3e3a4fdc442f52821778e28dc3c5ca384160bcdeb6639512f861a0fc",
+  "file_count": 1521,
+  "tree_sha256": "9d55773209aeb85fef771e85aa30e901c52e54e155601030e44cd16fd5c46bda",
   "files": [
     {
       "path": ".claude/skills/blocker-review/SKILL.md",
@@ -159,6 +159,11 @@
       "mode": "0000644",
       "sha256": "e0bf90fa006499aee0a7d75f10fe4b5972c9501129b1e432e7d6e192b367a54c"
     },
+    {
+      "path": ".claude/skills/grader-health/SKILL.md",
+      "mode": "0000644",
+      "sha256": "b9823a6a14b4197f7dae90c8ad6713fcc5b3ce672d03d7b59c8e868d5d6ba70e"
+    },
     {
       "path": ".claude/skills/idea-triage/SKILL.md",
       "mode": "0000644",
@@ -1357,7 +1362,7 @@
     {
       "path": "docs/file-map.md",
       "mode": "0000644",
-      "sha256": "a499551f07ce8f6382aba46641fb06fa8e499d486433ee3bf266f264abac29ca"
+      "sha256": "f51d3978f50ec9b2a34dc12b8fa3b9e8874543e5ab3503f72a09d7d2b06c565b"
     },
     {
       "path": "docs/handoff-template.md",
@@ -3367,7 +3372,7 @@
     {
       "path": "modules/lifecycle/db.js",
       "mode": "0000644",
-      "sha256": "77528182c408edf2b8f3e07382bb83f97a7d668b979e97e60e4ff0c2e1bc7109"
+      "sha256": "c7dfc49df888857c8975077a069e8730d16926d8e92776f09489f69a40068f31"
     },
     {
       "path": "modules/lifecycle/done-when.js",
@@ -3442,7 +3447,7 @@
     {
       "path": "modules/lifecycle/routes/claims.js",
       "mode": "0000644",
-      "sha256": "6e30cf7169736737ea7aeac0aa1af9e5f31ed8ea79f08796cc2da9ed9ae03577"
+      "sha256": "92065e0a5cfd2a5d76bbf04f4efafe0e2b3bc31cf616136963d4c07fad25047e"
     },
     {
       "path": "modules/lifecycle/routes/dependencies.js",
@@ -4017,12 +4022,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "ba0c267dd729a028da03734f1aa527c2fcae016932cdbaea2d1650bc184ef8e4"
+      "sha256": "413f575fce07ba5b167f6492a4f1aed1f7eacb4f4351457303d3875f04557787"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "30c2010f68e93023955954526ed962a366d4150e5b9a07a78ff0b1ac04f7b27c"
+      "sha256": "d0d31ac616a949591bca2975236bbf6d98437e969d1618bd68811620c2a130c3"
     },
     {
       "path": "public-docs/index.html",
@@ -4547,7 +4552,7 @@
     {
       "path": "scripts/gds/claim.js",
       "mode": "0000644",
-      "sha256": "23f9932dd79c63915679eeb175e2fc6d95e43b840dba78336c23504c85617987"
+      "sha256": "6f09d9344f57039c07d2de943dabb48dbf717226aa2667f4163dab47fb74428a"
     },
     {
       "path": "scripts/gds/classify-discipline.js",
@@ -5057,7 +5062,7 @@
     {
       "path": "scripts/gds/run-unit-tests.js",
       "mode": "0000644",
-      "sha256": "7f0ad4e54c0e5c251f00c78c7a6065d4a8db7bc88f0492c75bc63f8929108203"
+      "sha256": "ce8856194aa805d1f62d47d4b04bac05168c0c748f869a094476a28b9db2a30a"
     },
     {
       "path": "scripts/gds/sandbox-stage.js",
@@ -5642,7 +5647,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "b7a1d663d910c88b285298b741d8fe6b7edb6b6c7644a59ea81f087549182ef0"
+      "sha256": "2dfd2867ab83689497aff7a3b7f213e756c182e047ef8da754e098a945491ce7"
     },
     {
       "path": "src/module-loader/loader.js",
@@ -6042,7 +6047,12 @@
     {
       "path": "tests/claim_error_surface.mjs",
       "mode": "0000644",
-      "sha256": "6273b5b86f0fecd24bcb54a36a673ec9d42f81180d602d5d374fc9d07a511072"
+      "sha256": "365f498d290298e0cd74888aff080cfbf3439e5e0cf2dd883291f39dface27e7"
+    },
+    {
+      "path": "tests/claim_gate_open_blocker.mjs",
+      "mode": "0000644",
+      "sha256": "e62324e8e504e4f2788355b1ed1ffc5b1d434ef0ef0e72c18751236436e10c49"
     },
     {
       "path": "tests/claim_gate_rebase.mjs",
@@ -7459,6 +7469,11 @@
       "mode": "0000644",
       "sha256": "76bed8e6fae3bd77d4b45be14d9f80bda71b2f92323fa5697a7e4f07b65d3ba2"
     },
+    {
+      "path": "tests/skill_grader_health.mjs",
+      "mode": "0000644",
+      "sha256": "4557c934704a009612ed8858c0f59c5b53facb5d92fa2c0740b1aecb079aa5c9"
+    },
     {
       "path": "tests/skill_prefs.mjs",
       "mode": "0000644",

package/.claude/skills/grader-health/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: grader-health
+description: Read-only health check over recent grades — consecutive outage runs, pass-rate drift vs baseline, per-grade cost anomalies, and stale model pins. The routine that would have caught the 21-outage 0.0-score streak on day one. Triggers when the user says "/grader-health", "check the grader", "is the grader healthy", "grader health check", "why are grades failing lately", or as part of a periodic ops sweep. Reports and emits exact remediation lines; changes nothing (ADR 0162 — no new gates, describe only). Optional --probe runs a live paid calibration (Metic+).
+---
+
+You are running a health check over the grading panel. Everything here is **read-only**: you read live surfaces, compare against known baselines, and emit findings + exact remediation commands. You never confirm, flip, or re-grade anything yourself — the builder (or /grade-recover) acts on what you report.
+
+## The four axes
+
+### 1 — Outage runs (the pattern this skill exists to catch)
+
+A grader outage used to be recorded as a 0.0 "quality failure": one builder accumulated **21 zero-score rows** over a month before anyone noticed, and the public tile showed a phantom 5-day 0%-pass crater. Since the outage-as-zero fix, aggregates exclude outage rounds and bucket them as `n_unavailable` — so the streak is now directly readable.
+
+1. Read the public trend: `node scripts/gds/api.js GET "/api/gds/public/grades?days=30"` — scan `trend[]` for days where the average is 0 (or null) with passes 0 and n ≥ 2, and for any nonzero `n_unavailable` streak.
+2. (Archon) Read the per-builder split: `node scripts/gds/api.js GET "/api/gds/grades/by-builder?days=30"` — a single builder with pass_rate 0.000 or a large `n_unavailable` bucket is the 21×0.0 shape localized to one machine or one environment.
+3. **Confirm outage vs rejection before alarming anyone.** For each task in a suspect window: `node scripts/gds/api.js GET "/api/gds/tasks/<id>?include=grade"` — `signals.panel_outcome='unavailable'` (with `grader_unavailable_reason` and per-worker errors in `signals.workers`) is an outage, **not a quality rejection**; a real FAIL carries findings in `issues[]`.
+4. For every task parked at `completed` by a confirmed outage, emit the exact remediation line, one per task:
+
+```bash
+node scripts/gds/ship.js <id> --regrade
+```
+
+5. Check the local spawn leg: the panel spawns `claude -p` subprocesses, so verify the CLI is present and authenticated, and run `node scripts/gds/doctor.js` for the hooks/worktree leg.
+
+### 2 — Pass-rate drift
+
+Baselines: the 14-agent evaluation window measured a **90.6%** pass rate, already above the 87% that ADR 0024 called "suspiciously high" and built the adversarial panel to fix. From `/api/gds/public/grades` compute the rolling pass rate and compare:
+
+- **Creeping up** past the baseline → grade inflation; the panel is rubber-stamping (report; candidate causes: score compression, reused grades, trivial-path overuse).
+- **Collapsing** far below it → either a real quality regression or an unconfirmed outage window — axis 1 disambiguates.
+
+### 3 — Cost anomalies
+
+Benchmark: mean panel cost **$2.14** per grade, and ~90% of it is **fixed** re-exploration cost, independent of diff size. Read grader spend: `node scripts/gds/api.js GET "/api/gds/public/cost-summary?source=grader&days=30"` and divide by the grade count from axis 2's window.
+
+- Mean drifting well above the benchmark → panel re-rolls/retries or timeout-and-retry loops (not "big diffs" — the fixed-cost share means diff size barely moves the mean).
+- Near-zero spend with grades still recording → the trivial path or grade reuse dominating; spot-check that gating lenses are actually running.
+
+### 4 — Model pins
+
+The evaluation found every grade ran on a generation-stale pin. Read the live pin from the repo: `DEFAULT_GRADER_MODEL` and `selectGraderModel` in `modules/grading/grader.js`, plus the rubric version in `modules/grading/grader-rubric.json`. Report when the pinned family is a generation behind the current Claude family, or when `selectGraderModel` would throw on a current builder model id (it throws on ids lacking opus/sonnet/haiku — a stranded-ship risk).
+
+## Optional: `--probe` (live calibration, spends real money)
+
+With `--probe`, run the live panel calibration: `node scripts/gds/grade-smoke.js`. It grades known-good and known-bad fixtures against the real panel and reports miscalibration. **Costs ~$0.30–0.90 per run; Metic+ only.** Never run it implicitly — only when the user passed `--probe` or asked for a live calibration.
+
+## Report shape
+
+End with a compact findings list, most severe first: axis, evidence (the numbers you read), verdict (outage / drift / anomaly / stale-pin / healthy), and the exact remediation command or the skill to hand off to (`/grade-recover` for a single stuck task; a GDS task via `capture.js` for systemic fixes). A clean bill of health is one line per axis.
+
+## Constraints
+
+- **Read-only, describe-only (ADR 0162).** No confirms, no regrades run by this skill, no status flips, no new gates. The remediation lines are FOR the builder to run.
+- **Confirm before alarming.** Axis 1's outage-vs-rejection check comes before any "the grader is down" conclusion — a real FAIL streak on one surface is signal, not outage.
+- **`--probe` spends money** — explicit opt-in only, Metic+.
+
+## Files this skill touches
+
+- Reads: `GET /api/gds/public/grades`, `GET /api/gds/grades/by-builder` (Archon), `GET /api/gds/public/cost-summary?source=grader`, `GET /api/gds/tasks/:id?include=grade`, `modules/grading/grader.js`, `modules/grading/grader-rubric.json`.
+- Runs (read-only): `node scripts/gds/doctor.js`; with `--probe` only: `node scripts/gds/grade-smoke.js`.
+- Writes: nothing.

package/docs/file-map.md

@@ -351,6 +351,7 @@ tests/
 ├── goal-create/SKILL.md           ← /goal-create — plan and create ONE goal (the module-scoped workspace between version and criteria, ADR 0086) in one session: <redacted>, scope wall, 2-4 criteria, seed tasks; also the auto-pickup when a task is created with no goal to live in (goal_advisory); Metic+ (Archon for a protected-module scope)
 ├── goal-review/SKILL.md           ← /goal-review — walk the criterion review queue: each auto-flagged 'met — pending review' criterion gets confirm / reject / defer; confirming a goal's last criterion auto-achieves it (ADR 0086 §6); Metic+
 ├── grade-recover/SKILL.md         ← /grade-recover N — the 'my grade failed, now what' loop: diagnose outage vs fabricated fail vs genuine fail from the persisted grade, then run the right recovery (--regrade or the auditable override-request); adds no ship-path gate (ADR 0162, task 1002655)
+├── grader-health/SKILL.md         ← /grader-health — read-only grader health check: outage runs (n_unavailable streaks, outage-vs-rejection confirmation), pass-rate drift vs baseline, per-grade cost anomalies, stale model pins; emits exact --regrade remediation lines; optional --probe live calibration (Metic+, paid) (task 1002656)
 ├── idea-triage/SKILL.md           ← /idea-triage — daily walk through the GDS idea_inbox (promote / discard / merge); Metic+
 ├── ideate/SKILL.md                ← /ideate — ideation-session playbook for ideator-discipline tasks; inverts the loop (human drives, Claude is the sounding board) ([#1267](https://example.com/builders#/task/1267))
 ├── merge-mode/SKILL.md            ← /merge-mode — manual fallback for the auto-merge: land every confirmed task (merge + smoke + deploy)

package/modules/lifecycle/db.js

@@ -2586,6 +2586,23 @@ async function claimTask({ taskId, builderId, worktreeName, headSha, creatorSess
       throw { code: 'TASK_NOT_READY', currentStatus: task.status };
     }
 
+    // task 1002650 (idea 1000644): the claimable FEED filters out ready tasks
+    // with an open blocker link, but the direct claim-by-id path never checked —
+    // the feed hid the trap and this path walked into it. Mirror migration 176's
+    // task_is_fully_unblocked clause so both gates enforce the same rule.
+    const { rows: openBlockers } = await client.query(
+      `SELECT b.id, b.title
+         FROM task_blockers tb
+         JOIN blockers b ON b.id = tb.blocker_id
+        WHERE tb.task_id = $1
+          AND b.status = 'open'
+        ORDER BY b.id`,
+      [taskId]
+    );
+    if (openBlockers.length > 0) {
+      throw { code: 'OPEN_BLOCKER', blockers: openBlockers };
+    }
+
     // Three-rank model (task #360 / ADR 0018; V3.R15 #239): a Xenos is the
     // sandboxed entry rank and may claim ONLY tasks explicitly opened to them
     // (newcomer_friendly). Metic+ (the approved working rank) and Archon claim
@@ -2893,6 +2910,27 @@ async function claimTasksBatch({ taskIds, builderId, worktreePrefix, creatorSess
       }
     }
 
+    // task 1002650 (idea 1000644): same open-blocker rule as claimTask — the
+    // batch path must not sidestep the gate the feed and single claim enforce.
+    const { rows: blockedRows } = await client.query(
+      `SELECT tb.task_id, b.id, b.title
+         FROM task_blockers tb
+         JOIN blockers b ON b.id = tb.blocker_id
+        WHERE tb.task_id = ANY($1::bigint[])
+          AND b.status = 'open'
+        ORDER BY b.id`,
+      [uniqIds]
+    );
+    const blockersByTask = new Map();
+    for (const r of blockedRows) {
+      const list = blockersByTask.get(Number(r.task_id)) || [];
+      list.push({ id: r.id, title: r.title });
+      blockersByTask.set(Number(r.task_id), list);
+    }
+    for (const [blockedTaskId, blockers] of blockersByTask) {
+      failures.push({ task_id: blockedTaskId, reason: 'OPEN_BLOCKER', blockers });
+    }
+
     // Three-rank model (task #360 / ADR 0018; V3.R15 #239): a Xenos may
     // batch-claim only tasks explicitly opened to them (newcomer_friendly).
     // Mirrors the single claimTask gate so the batch path can't be used to

package/modules/lifecycle/routes/claims.js

@@ -250,6 +250,10 @@ module.exports = function buildClaimsRouter() {
           err.code === 'TOUCHES_CONFLICT' ? 409 :
           err.code === 'MODULE_CONFLICT' ? 409 :
           err.code === 'DEPS_NOT_SHIPPED' ? 409 :
+          // task 1002650 (idea 1000644): a ready task with an open blocker link is
+          // hidden from the claimable feed; the direct claim-by-id gate now
+          // enforces the same rule instead of letting the claim walk into the trap.
+          err.code === 'OPEN_BLOCKER' ? 409 :
           // ADR 0120 part 3: the builder owes a rebase on an un-landed confirmed
           // task (reconciler-flagged needs_rebase); NEW claims are gated until
           // they land or release it. Existing claims are unaffected.
@@ -285,6 +289,12 @@ module.exports = function buildClaimsRouter() {
           const ids = (err.rebaseTasks || []).map((t) => `task ${t.id}`);
           err.hint = `Your queue is gated: ${ids.length} confirmed task(s) await your rebase (${ids.join(', ') || 'unknown'}). Land each (rebase its branch + re-ship, or /merge-mode) — or /builder-release it — then claim new work.`;
         }
+        // task 1002650: name the blocker(s) and the way forward — the same rule
+        // the claimable feed enforces, spoken at the gate instead of a bare 409.
+        if (err.code === 'OPEN_BLOCKER') {
+          const names = (err.blockers || []).map((b) => `blocker ${b.id} ("${b.title}")`);
+          err.hint = `This task is waiting on ${names.join(', ') || 'an open blocker'}. Resolve it first (/blocker-solve N drives one to done; resolving auto-promotes its linked tasks) — or pick another task from /builder-start.`;
+        }
         return res.fail(err.code, status, { ...err });
       }
       console.error('[gds] POST /claims', err);

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.36",
+  "version": "1.19.38",
   "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/claim.js

@@ -256,6 +256,13 @@ function formatClaimFailure(r, taskId) {
     lines.push('Ship those first (or release them) and try again.');
     return { lines, exit: 1 };
   }
+  if (code === 'OPEN_BLOCKER') {
+    // task 1002650: the same rule the claimable feed enforces, spoken at the gate.
+    lines.push(`Task #${taskId} is waiting on an open blocker:`);
+    for (const b of d.blockers || []) lines.push(`  - blocker ${b.id}  ${b.title}`);
+    lines.push('Resolve it first (/blocker-solve N drives one to done; resolving auto-promotes its linked tasks) — or pick another task from /builder-start.');
+    return { lines, exit: 1 };
+  }
   // Fallback — still readable: the message + code, never a raw [object Object].
   lines.push(`Claim failed (${r ? r.status : '?'})${code ? ` [${code}]` : ''}${message ? `: ${message}` : ''}.`);
   return { lines, exit: 1 };

package/scripts/gds/run-unit-tests.js

@@ -73,7 +73,7 @@ const INTEGRATION = new Set([
   // platform-server — network + package build + a spawned server, run by its own
   // .github/workflows/consumer-layout-boot.yml, not this DB-free gate (task 2142).
   'consumer_layout_boot',
-  'claim_gate_rebase', 'clawback_confirmed_backlog', 'discord_autojoin', 'discord_oauth',
+  'claim_gate_open_blocker', 'claim_gate_rebase', 'clawback_confirmed_backlog', 'discord_autojoin', 'discord_oauth',
   'governance_fold_bench', 'governance_live_proof', 'linkify_refs', 'memory_isolation',
   'memory_pull', 'needs_rebase', 'parallel-load', 'reward_mode_cost_plus_only',
   'session_records', 'setup_smoke',

package/src/module-api.js

@@ -499,8 +499,12 @@ const { validateOrRespond, LIMITS, parseId, asyncHandler, corsPublicGet, parsePa
 //         landed since 1.19.34 with no explicit bump. run 31507293725. (task 1002620)
 //   1.19.36 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
 //         landed since 1.19.35 with no explicit bump. run 31509715311. (task 1002620)
+//   1.19.37 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.36 with no explicit bump. run 31510590459. (task 1002620)
+//   1.19.38 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+//         landed since 1.19.37 with no explicit bump. run 31511537558. (task 1002620)
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.36'; // CI auto-patch carrier (ADR 0161); see changelog above
+const CORE_VERSION = '1.19.38'; // CI auto-patch carrier (ADR 0161); see changelog above
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/claim_error_surface.mjs

@@ -36,6 +36,7 @@ t('never dumps [object Object] for any known code', () => {
     'session_already_has_bound_claim',
     'newcomer_must_ship_first', 'ALREADY_CLAIMED', 'MODULE_CONFLICT',
     'TOUCHES_CONFLICT', 'TASK_NOT_READY', 'TASK_NOT_FOUND', 'DEPS_NOT_SHIPPED',
+    'OPEN_BLOCKER',
     'some_unmapped_future_code',
   ];
   for (const c of codes) {
@@ -87,6 +88,17 @@ t('DEPS_NOT_SHIPPED: lists each blocking dependency', () => {
   assert.match(out, /Dep A/);
 });
 
+// task 1002650: the wave-5 speech standard — the refusal names the blocker
+// (id + title) and the remedy, not a bare 409.
+t('OPEN_BLOCKER: names the blocker and the way forward', () => {
+  const out = text(formatClaimFailure(
+    envelope('OPEN_BLOCKER', { blockers: [{ id: 1000094, title: 'Owner must verify the installer' }] }), 9));
+  assert.match(out, /blocker 1000094/);
+  assert.match(out, /Owner must verify the installer/);
+  assert.match(out, /blocker-solve/);
+  assert.match(out, /pick another task/);
+});
+
 t('MODULE_CONFLICT + TOUCHES_CONFLICT: list conflicting task titles', () => {
   const mc = text(formatClaimFailure(
     envelope('MODULE_CONFLICT', { module_key: 'economy', conflictTaskTitles: ['Bar'] }), 4));

package/tests/claim_gate_open_blocker.mjs

@@ -0,0 +1,93 @@
+// tests/claim_gate_open_blocker.mjs — task 1002650 (idea 1000644, real DB).
+//
+// The open-blocker claim gate: a ready task linked to an OPEN blocker is
+// hidden from the claimable feed (CLAIMABLE_SQL), but the direct claim-by-id
+// path never checked — POST /claims walked straight into the trap the feed was
+// hiding. claimTask and claimTasksBatch now refuse with OPEN_BLOCKER, naming
+// the blocker, mirroring migration 176's task_is_fully_unblocked clause.
+// Real-DB integration test (self-skips without a reachable Postgres; in the
+// INTEGRATION set so the default DB-free lane never runs it).
+//
+// Run:  DATABASE_URL=... node tests/claim_gate_open_blocker.mjs
+
+import { createRequire } from 'node:module';
+import { strict as assert } from 'node:assert';
+const require = createRequire(import.meta.url);
+const { Pool } = require('pg');
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL || undefined });
+try {
+  await pool.query('SELECT 1');
+} catch (e) {
+  console.log(`claim_gate_open_blocker.mjs SKIPPED — no reachable Postgres (${e.code || e.message}).`);
+  await pool.end().catch(() => {});
+  process.exit(0);
+}
+
+const seams = require('../src/module-seams.js');
+if (!seams.hasProvider('reward')) seams.registerProvider('reward', require('../modules/economy/reward.js'));
+const db = require('../modules/lifecycle/db.js');
+
+const VER = 'ZZZ-OB', WORKER = 90000301, TRAP = 90000302, CONTROL = 90000303, BLOCKER = 90000304;
+const q = (sql, params) => pool.query(sql, params).then((r) => r.rows);
+
+async function cleanup() {
+  await q(`DELETE FROM builder_achievements WHERE builder_id=$1`, [WORKER]).catch(() => {});
+  await q(`DELETE FROM credit_log WHERE builder_id=$1 OR task_id = ANY($2::bigint[])`, [WORKER, [TRAP, CONTROL]]).catch(() => {});
+  await q(`DELETE FROM claims WHERE task_id = ANY($1::bigint[])`, [[TRAP, CONTROL]]).catch(() => {});
+  await q(`DELETE FROM task_blockers WHERE task_id = ANY($1::bigint[])`, [[TRAP, CONTROL]]).catch(() => {});
+  await q(`DELETE FROM blockers WHERE id=$1`, [BLOCKER]).catch(() => {});
+  await q(`DELETE FROM tasks WHERE id = ANY($1::bigint[])`, [[TRAP, CONTROL]]).catch(() => {});
+  await q(`DELETE FROM builders WHERE id=$1`, [WORKER]).catch(() => {});
+  await q(`DELETE FROM versions WHERE id=$1`, [VER]).catch(() => {});
+}
+
+let pass = 0;
+const ok = (cond, msg) => { assert.ok(cond, msg); console.log(`  ok  ${msg}`); pass++; };
+
+try {
+  await cleanup();
+  await q(`INSERT INTO versions (id,name,status,track) VALUES ($1,'ob','planning','internal') ON CONFLICT (id) DO NOTHING`, [VER]);
+  // Archon so no rank/newcomer gate interferes; the gate under test is OPEN_BLOCKER.
+  await q(`INSERT INTO builders (id,github_id,github_login,display_name,rank) VALUES ($1,'ob-w','ob-worker','OB Worker','archon')`, [WORKER]);
+  // TRAP: ready (feed-hidden) with an open blocker linked. CONTROL: ready, clean.
+  await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind) VALUES ($1,$2,'trap','ready',10,'feature')`, [TRAP, VER]);
+  await q(`INSERT INTO tasks (id,version_id,title,status,credits_reward,kind) VALUES ($1,$2,'control','ready',10,'feature')`, [CONTROL, VER]);
+  await q(`INSERT INTO blockers (id,title,status) VALUES ($1,'Owner must flip the switch','open')`, [BLOCKER]);
+  await q(`INSERT INTO task_blockers (task_id,blocker_id) VALUES ($1,$2)`, [TRAP, BLOCKER]);
+
+  // 1) Direct claim-by-id is refused with OPEN_BLOCKER, naming the blocker.
+  let threw = null;
+  try {
+    await db.claimTask({ taskId: String(TRAP), builderId: String(WORKER), worktreeName: 'ob-trap' });
+  } catch (e) { threw = e; }
+  ok(threw && threw.code === 'OPEN_BLOCKER', `claim refused with OPEN_BLOCKER (got ${threw && (threw.code || threw.message)})`);
+  ok(Array.isArray(threw.blockers) && threw.blockers.some((b) => Number(b.id) === BLOCKER),
+    'the 409 names the blocker id');
+  ok(threw.blockers.every((b) => typeof b.title === 'string' && b.title.length > 0),
+    'each named blocker carries its title (the wave-5 speech payload)');
+  const trapStatus = (await q(`SELECT status FROM tasks WHERE id=$1`, [TRAP]))[0].status;
+  ok(trapStatus === 'ready', 'the refused task stays ready (no partial claim)');
+
+  // 2) The batch path enforces the same rule — no sidestep via /builder-sequence.
+  let batchThrew = null;
+  try {
+    await db.claimTasksBatch({ taskIds: [TRAP, CONTROL], builderId: String(WORKER), worktreePrefix: 'ob-batch' });
+  } catch (e) { batchThrew = e; }
+  ok(batchThrew && batchThrew.code === 'BATCH_FAILED', `batch claim refused (got ${batchThrew && (batchThrew.code || batchThrew.message)})`);
+  ok((batchThrew.failures || []).some((f) => Number(f.task_id) === TRAP && f.reason === 'OPEN_BLOCKER'),
+    'the batch failure names the trapped task with reason OPEN_BLOCKER');
+
+  // 3) Resolving the blocker opens the gate.
+  await q(`UPDATE blockers SET status='resolved', resolved_at=now() WHERE id=$1`, [BLOCKER]);
+  const claim = await db.claimTask({ taskId: String(TRAP), builderId: String(WORKER), worktreeName: 'ob-trap' });
+  ok(claim && claim.id && Number(claim.task_id) === TRAP, 'claim succeeds once the blocker is resolved');
+
+  console.log(`\nclaim_gate_open_blocker (task 1002650): ${pass} passed, 0 failed`);
+} catch (e) {
+  console.error('claim_gate_open_blocker.mjs FAILED:', e.stack || e.message);
+  process.exitCode = 1;
+} finally {
+  await cleanup();
+  await pool.end();
+}

package/tests/skill_grader_health.mjs

@@ -0,0 +1,48 @@
+// tests/skill_grader_health.mjs — the /grader-health skill exists and covers
+// the four health axes from the grader-hardening evaluation §6 (task 1002656):
+// outage runs, pass-rate drift, cost anomalies, and stale model pins — reading
+// LIVE data surfaces, emitting exact --regrade remediation lines, and staying
+// read-only (describe, never confirm/flip — ADR 0162).
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { readFileSync, existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const SKILL = path.join(ROOT, '.claude', 'skills', 'grader-health', 'SKILL.md');
+
+// .claude/skills is INSTANCE-materialized; a neutral core checkout carries none
+// (task 1002470) — skip there, same guard shape as file_map.mjs.
+const skillsDirExists = existsSync(path.join(ROOT, '.claude', 'skills'));
+
+test('/grader-health exists and covers the four health axes on live data', (t) => {
+  if (!skillsDirExists) return t.skip('.claude/skills not materialized in this checkout');
+  assert.ok(existsSync(SKILL), '.claude/skills/grader-health/SKILL.md must exist (task 1002656)');
+  const md = readFileSync(SKILL, 'utf8');
+
+  // Live data surfaces, named concretely.
+  assert.match(md, /\/api\/gds\/public\/grades/, 'reads the public grade trend');
+  assert.match(md, /\/api\/gds\/grades\/by-builder/, 'reads the per-builder split (Archon)');
+  assert.match(md, /\/api\/gds\/public\/cost-summary/, 'reads grader spend');
+
+  // Axis 1 — outage runs: the 21×0.0 pattern and outage-vs-rejection confirmation.
+  assert.match(md, /n_unavailable/, 'names the outage bucket the aggregates expose');
+  assert.match(md, /panel_outcome='unavailable'/, 'confirms outage vs rejection per task');
+
+  // Axis 2 — pass-rate drift vs the evaluation baseline.
+  assert.match(md, /90\.6%/, 'names the eval-window pass-rate baseline');
+
+  // Axis 3 — cost anomalies vs the fixed-cost benchmark.
+  assert.match(md, /\$2\.14/, 'names the mean per-grade cost benchmark');
+
+  // Axis 4 — model pins.
+  assert.match(md, /DEFAULT_GRADER_MODEL|selectGraderModel/, 'checks the live model pin');
+
+  // Remediation + probe + the read-only contract.
+  assert.match(md, /node scripts\/gds\/ship\.js <(?:task-)?id> --regrade/, 'emits the exact remediation line');
+  assert.match(md, /--probe/, 'offers the optional live calibration probe');
+  assert.match(md, /grade-smoke\.js/, 'names the probe script');
+  assert.match(md, /read-only/i, 'states the read-only contract');
+  assert.match(md, /ADR 0162/, 'anchors the no-new-gates constraint');
+});