@bongos/core 1.19.889 → 1.19.890

package/.bongos-core.json

@@ -2,22 +2,22 @@
   "artifact": "bongos-core",
   "manifest_schema": 1,
   "generator": "scripts/gds/package-core.js",
-  "core_version": "1.19.889",
-  "core_contract": "1.19.889",
-  "source_commit": "b7871cd73a1ce5f73988d99ef63101a6a2d23050",
+  "core_version": "1.19.890",
+  "core_contract": "1.19.890",
+  "source_commit": "fb73c80a33c2f4e3aaf8d9ae3bb0295b6ec73e3b",
   "source_ref": "HEAD",
-  "built_at": "2026-09-19T21:23:27.620Z",
+  "built_at": "2026-09-19T21:31:12.716Z",
   "redaction": {
     "model": "docs-redacted+functional-verbatim",
     "docs_redacted": 497,
     "agent_docs_stubbed": 26,
-    "functional_verbatim": 2269,
+    "functional_verbatim": 2271,
     "rules": 3,
     "gate_literals": 3,
     "gate": "passed"
   },
-  "file_count": 2792,
-  "tree_sha256": "b7b8bc9e53808070c5d46a211481ceef0dea2c901bc79e2b0dc0871e60c362b1",
+  "file_count": 2794,
+  "tree_sha256": "8e1cc8300c4c29b876e8dc18b16384db7ade73e5948c7e009c0b69f9dadea8a7",
   "files": [
     {
       "path": ".claude/skills/ask-for-help/SKILL.md",
@@ -2607,7 +2607,7 @@
     {
       "path": "docs/module-api-changelog.md",
       "mode": "0000644",
-      "sha256": "01a90a40951ae88d4c36c5fabbaf3debc0e02bcaa9fa8a7b70e247aa5d61d236"
+      "sha256": "7fb640ef029a52e521d43e2828ca0201a7e53c7a94f23fcebd58aefd6f6820fe"
     },
     {
       "path": "docs/modules-contract.md",
@@ -4442,12 +4442,12 @@
     {
       "path": "modules/grading/grader-rubric.json",
       "mode": "0000644",
-      "sha256": "a08fe9f320dab2d3f699700cfb9f78d1604533d930e794d556c8f9ab533cf69b"
+      "sha256": "de0ca17fedb33bd54d73759e14e6813cd9f2c8c85ef2180e49c54794c7a63a3d"
     },
     {
       "path": "modules/grading/grader-score.js",
       "mode": "0000644",
-      "sha256": "07559f7c1f53ac8de36e1fd23965a9c29344101468542d6e636a3ce4d8860b4f"
+      "sha256": "e0f665b760e2b299a7aa9098e1ab967aa330ff20f7430e0aa23d9c7c57aa0d70"
     },
     {
       "path": "modules/grading/grader-subagent.js",
@@ -4462,7 +4462,7 @@
     {
       "path": "modules/grading/grader-workers/extract-json.js",
       "mode": "0000644",
-      "sha256": "1be95c661d95cfc7f54b9f2776eed6c1cd5b6e2e852b24c80f6b638f4d775751"
+      "sha256": "b359c904c68ae8b36ac6518c79bcebf251abcf7aaef3dae4aff4a6e2175e7914"
     },
     {
       "path": "modules/grading/grader-workers/fence.js",
@@ -4477,7 +4477,7 @@
     {
       "path": "modules/grading/grader-workers/index.js",
       "mode": "0000644",
-      "sha256": "c527d3dd996b4064ae14836e305de097edea2b1a3c46776d8ec7da8c2c6afe71"
+      "sha256": "ec8046b24550ef81c26b8a421c684360873f9eaed0ec3a7e95b8546aa1e45d6f"
     },
     {
       "path": "modules/grading/grader-workers/narc.js",
@@ -4489,6 +4489,11 @@
       "mode": "0000644",
       "sha256": "1ad616532dc2c240bf94992db17b12f1334e3e74667c402d997c03c2c8df1566"
     },
+    {
+      "path": "modules/grading/grader-workers/reader.js",
+      "mode": "0000644",
+      "sha256": "b7fdf28a76914c708b628a20ee90278ed29ad1e4c886b4e4f0edb2a2515d4d2c"
+    },
     {
       "path": "modules/grading/grader-workers/rubric.js",
       "mode": "0000644",
@@ -4507,7 +4512,7 @@
     {
       "path": "modules/grading/grader.js",
       "mode": "0000644",
-      "sha256": "4c664f5080513169c35369e5406f32efa64ce24259fefc47f527a94ff8001b1f"
+      "sha256": "1234bb3c9938fd4cf71c39e4660d69c56a27de667ee7ff09b0f865374b6beba4"
     },
     {
       "path": "modules/grading/module.json",
@@ -5367,7 +5372,7 @@
     {
       "path": "modules/lifecycle/cascade.js",
       "mode": "0000644",
-      "sha256": "acc9cf557aabc3fe10efc8c7272162cf288428e8077a24f5df06648e30881337"
+      "sha256": "b168a58926ee0506d3fba4f448c797b8611bc8ae0dfeca322086f22769e7ae35"
     },
     {
       "path": "modules/lifecycle/check-rollup.js",
@@ -5797,7 +5802,7 @@
     {
       "path": "modules/lifecycle/tests/cascade.mjs",
       "mode": "0000644",
-      "sha256": "0734ad734ac5ef05c86fa81493c12fed08ffe421781d9ceeebe413c876bf9cf1"
+      "sha256": "9439accf7648ef22000c75f3e315695c806969eb5a908275d7db33e5491499f8"
     },
     {
       "path": "modules/lifecycle/version-autoclose.js",
@@ -7702,12 +7707,12 @@
     {
       "path": "package-lock.json",
       "mode": "0000644",
-      "sha256": "d1348f68cd79ad102a381e3d7f90b784d9df605e859269ede84ad859cc831deb"
+      "sha256": "f9267b40d96aa3395f93b456da92cb8ff99f579340e1e9ac57e2264764e7b293"
     },
     {
       "path": "package.json",
       "mode": "0000644",
-      "sha256": "36e895c05e2aed3f97ce34ae3b3f73b0492fff7185077519068bc69dda6a8fd6"
+      "sha256": "4185cf704dd2b4d4dddd72ad802fbc6861c66181b69bbc66eaafdec7e603da35"
     },
     {
       "path": "public-docs/index.html",
@@ -9062,7 +9067,7 @@
     {
       "path": "scripts/gds/ship-grade.js",
       "mode": "0000644",
-      "sha256": "79fcf45dd254681e7f91fe83fbb8a208b30c93eebe77df569aae505a025daa68"
+      "sha256": "b1fb38635433b579fbb38d65e92b9db226cccb753866ab7a2a15227796be66cd"
     },
     {
       "path": "scripts/gds/ship-honesty.js",
@@ -9712,7 +9717,7 @@
     {
       "path": "src/module-api.js",
       "mode": "0000644",
-      "sha256": "541b09991f4858b3255f250ef7e52e86b0d561ec69d058e74bc218fe1a104932"
+      "sha256": "7b2ddf6ecca1f92f1ae2ba7a70e0e6aeb9726ec0fa9c4a5375f075755b036796"
     },
     {
       "path": "src/module-loader/catalog.js",
@@ -10962,7 +10967,7 @@
     {
       "path": "tests/extract_json.mjs",
       "mode": "0000644",
-      "sha256": "8bdee65e64ba4bce81f2c8aeb3068affe78ec1bc893a8b209eece8fde5b93fa5"
+      "sha256": "74f8d8852b8949dc55ac38dd6f31da85bb55aae1215a146213495db898515086"
     },
     {
       "path": "tests/figma_adapter.mjs",
@@ -11504,6 +11509,11 @@
       "mode": "0000644",
       "sha256": "cbe81b9176d6ffdd59ea8d6955e30aab9bf6d13bd15144fd79d126455aa0e1e3"
     },
+    {
+      "path": "tests/grader_reader_lens.mjs",
+      "mode": "0000644",
+      "sha256": "93e24012252c08798e3017ce9a7130ce9ece4e5e07456892b3632ab12f44ad47"
+    },
     {
       "path": "tests/grader_regrade_delta.mjs",
       "mode": "0000644",

package/docs/module-api-changelog.md

@@ -2252,5 +2252,7 @@ is load-bearing: the script throws rather than guess if it is missing, and
         landed since 1.19.887 with no explicit bump. run 35468948342. (task 1002620)
   1.19.889 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
         landed since 1.19.888 with no explicit bump. run 35470239834. (task 1002620)
+  1.19.890 — CI auto-patch (publish-on-merge, ADR 0161): carrier for merges
+        landed since 1.19.889 with no explicit bump. run 35470624284. (task 1002620)
 ---------------------------------------------------------------------------
 ```

package/modules/grading/grader-rubric.json

@@ -12,16 +12,16 @@
     "assumed_builder_model": "claude-fable-5",
     "model_refresh_note": "task 1002659 (2026-08-11): pins refreshed to the Claude 5 family. Assumed builder = claude-fable-5 (the owner-top-model default per CLAUDE.md §2); default grader = claude-sonnet-5 (cross-model per ADR 0024, cost-parity with the prior sonnet-4-6 posture — opus-5 grades the sonnet/haiku builders where the grader should be the stronger model). selectGraderModel no longer throws on an unknown builder id: it warns loudly and falls back to default_model (the #117 throw stranded ships whose builder id lacked an opus/sonnet/haiku substring — exactly what claude-fable-5 is).",
     "active_panel": ["narc", "quality", "hacker", "efficiency"],
-    "worker_model_tiers": { "quality": "claude-sonnet-5" },
-    "worker_model_tiers_note": "task 1002660: per-worker cost tiering. Quality was 41% of panel spend with 75% nit findings — its cq/economy lens ran on the haiku tier. task 1003318: moved to claude-sonnet-5 — haiku 4.5's 200k window overflows on any diff over ~150 KB (`Prompt is too long`, deterministic; tasks 1003297 and 1003298 each lost three ~$5 panel runs to it) and a Quality worker that never starts is missing signal on a GATING lens. For fable/opus builders the panel model is already claude-sonnet-5, so the tier coincides with default_model and acts as a floor — a future default_model bump must not pin Quality back onto a smaller window; it stays a live cost lever only for haiku builders (whose panel runs on opus-5). workerModelFor refuses an override that lands on the builder's own model family (the ADR 0024 cross-model guarantee outranks the cost lever); gate semantics unchanged — Quality's verdict still gates identically.",
+    "worker_model_tiers": { "quality": "claude-sonnet-5", "reader": "claude-sonnet-5" },
+    "worker_model_tiers_note": "task 1002660: per-worker cost tiering. Quality was 41% of panel spend with 75% nit findings — its cq/economy lens ran on the haiku tier. task 1003318: moved to claude-sonnet-5 — haiku 4.5's 200k window overflows on any diff over ~150 KB (`Prompt is too long`, deterministic; tasks 1003297 and 1003298 each lost three ~$5 panel runs to it) and a Quality worker that never starts is missing signal on a GATING lens. For fable/opus builders the panel model is already claude-sonnet-5, so the tier coincides with default_model and acts as a floor — a future default_model bump must not pin Quality back onto a smaller window; it stays a live cost lever only for haiku builders (whose panel runs on opus-5). workerModelFor refuses an override that lands on the builder's own model family (the ADR 0024 cross-model guarantee outranks the cost lever); gate semantics unchanged — Quality's verdict still gates identically. task 1003977: the READER is pinned to claude-sonnet-5 for the same task-1003318 reason — it is Read-heavy by construction (the voice guide, then the render paths that decide whether a string is user-facing), and a small window fails deterministically with PROMPT_TOO_LONG. For a NON-GATING worker that means silently reading no copy at all on exactly the biggest copy diffs, with nothing blocking to reveal it.",
     "fallthrough_confidence": 0.3,
     "low_confidence_threshold": 0.4,
     "rationale": "GDS-V3 task #410 (MAS Phase 2.0), 2026-05-29. Supersedes v3 (single-prompt 3-shot generalist). Phase 1 calibration showed minimal between-shot disagreement on the same prompt — the strict gate fired correctly but the diversity signal was weak. v4 trades sampling-variance for lens-specialization: replace 3 identical-prompt shots with N workers (each a distinct prompt focused on one axis). Phase 2.0 ships 2 of the 3 planned workers (narc for completion, quality for cq + advisory economy) — keeps the gate at the same strictness while the framework calibrates. Phase 2.1 adds hacker (security; wraps /builder-redteam as a CI gate). Phase 2.2 adds efficiency_monger.",
     "worker_contract": {
-      "kind": "string — worker registry key (narc | quality | hacker | efficiency)",
+      "kind": "string — worker registry key (narc | quality | hacker | efficiency | reader)",
       "name": "string — display name",
       "specialty": "string — one-line description of what this worker judges",
-      "verdict": "'pass' | 'concerns' | 'fail' — per-worker verdict, sub-classification of the panel gate",
+      "verdict": "'pass' | 'concerns' | 'fail' — per-worker verdict, sub-classification of the panel gate; plus 'advisory', the ONLY verdict a NON-GATING worker emits (task 1003977 — see active_workers.reader and panel_gate.non_gating). Mirrored by WORKER_VERDICTS in grader-score.js, which hasPanelEvidence checks with an `every`.",
       "scores": "{ functional_fidelity?, code_quality?, economy? } — only the axes this worker reports",
       "issues": "[{ severity, file, summary }] — concrete problems found",
       "notes_md": "short markdown summary",
@@ -31,12 +31,22 @@
       "error": "null | 'parse_error' | 'schema_error' | 'SUBAGENT_*' — set when the subagent comms failed; verdict will be 'fail'"
     },
     "panel_gate": {
-      "fail": "ANY worker.verdict='fail' OR worker.error != null → overall passed=false, no advance to confirmed.",
-      "concerns": "ANY worker.verdict='concerns' (and no fails) → overall passed=false, forwarded confidence = fallthrough_confidence (manual-confirm available).",
-      "pass": "ALL workers.verdict='pass' → overall passed=true, advance to confirmed."
+      "fail": "ANY GATING worker.verdict='fail' OR worker.error != null → overall passed=false, no advance to confirmed.",
+      "concerns": "ANY GATING worker.verdict='concerns' (and no fails) → overall passed=false, forwarded confidence = fallthrough_confidence (manual-confirm available).",
+      "pass": "ALL GATING workers.verdict='pass' → overall passed=true, advance to confirmed.",
+      "non_gating": "task 1003977: a worker in NON_GATING_WORKERS (today: reader) is partitioned out of workerResults BEFORE any gate arithmetic — the pass/concerns/fail counts, the missing-signal and total-outage detection, the forwarded-confidence median and every verdict branch read the gating workers only. Its scores and issues still land in rubric_scores and signals.workers. Consequence worth stating out loud: a HEALTHY non-gating worker cannot mask a total grader outage by making 'every gating worker is missing signal' false — that is the task-1003574 regression class, where an outage presented as FAIL 0/10 and routed the builder to a re-grade that could not clear it."
     },
     "severity_gate_policy": "Task 1002663: style findings (comment style/length/placement, naming conventions, doc placement, test-name conventions) are ADVISORY — severity nit, recorded in issues[] for the audit trail, never a verdict driver. Enforced deterministically in grader-workers/worker-verdict.js applySeverityGatePolicy for narc/quality/efficiency: a worker 'fail' whose only basis is a sub-threshold score with NO major/blocker finding is an inconsistent self-report and downgrades to 'concerns' (manual-confirm pause) — a worker whose findings are all nit/minor can never verdict fail. The HACKER is deliberately EXEMPT: the security lens stays fail-closed on an unbacked sub-threshold score (a real finding mislabeled minor must still hard-fail). Untouched everywhere: blocker-driven fails, non-score fail triggers (Narc missing-AC), error short-circuits. Every worker prompt carries the matching STYLE_ADVISORY paragraph (worker-prompt.js).",
     "active_workers": {
+      "reader": {
+        "specialty": "user-facing copy: truth, clarity, voice, judged against docs/voice.md",
+        "scores_reported": ["copy_score"],
+        "gating": false,
+        "verdict_rules": "NON-GATING (task 1003977, ADR 0298). Emits the single verdict 'advisory' on every path INCLUDING its own errors — computeVerdict has no branch returning pass/concerns/fail, so 'cannot block' is a property of the function, not a promise kept by callers. aggregatePanel additionally partitions it out of the gate (NON_GATING_WORKERS in grader-workers/index.js). Belt and braces: a filter is one refactor from being forgotten, a verdict is not. Stronger than the advisory treatment narc receives, which only downgrades a fail to manual-confirm — the reader cannot reach 'concerns' either. A 'blocker' severity is FLOORED to 'major' rather than dropped: the observation survives, the veto does not. Deliberately NO blocker escape hatch of the kind narc/hacker carry (grader.js isAdvisory, '... && !hasBlocker'), because that hatch is the exact hole the owner's term closes. An errored reader records NO copy_score rather than 0 — a 0 is a real reading, an outage is missing signal (the #943 distinction, per worker).",
+        "scope": "copy-bearing diffs ONLY. The caller (scripts/gds/ship-grade.js) asks hasCopyOrVisualWork(task) from modules/lifecycle/cascade.js and passes the answer to WORKERS.panelFor({ copyBearing }); the grading module may not require a sibling module (ADR 0083, CI-enforced), and a second predicate inside grading would let the at-ship lens and the after-the-fact artist review disagree about what they cover. Where false the panel is byte-identical to DEFAULT_PANEL and costs what it costs today, and the skip is recorded as signals.reader_skipped='not_copy_bearing' — never a silent absence, because a missing copy score must not read as a passing one.",
+        "standard": "docs/voice.md (task 1003976), cited by rule id. Hard rules V1-V5 are checkable and may be ASSERTED as breaks; judgement rules V6-V11 may only be FLAGGED with the line quoted. A finding that cites no rule id is not a finding — the guide's own rule, carried into the prompt, and what keeps an advisory lens from recording taste as fact.",
+        "prompt_lives_in": "modules/grading/grader-workers/reader.js"
+      },
       "narc": {
         "specialty": "semantic completion (description vs diff, line-level)",
         "scores_reported": ["functional_fidelity"],

package/modules/grading/grader-score.js

@@ -55,7 +55,13 @@ function isSubstantiveIssue(it) {
 // grade-time input (the ADR's documented honor-system residual for Metic+);
 // its job is separating "the panel ran and unanimously found nothing" (the
 // guard's confirmed false-positive class) from "no evidence at all".
-const WORKER_VERDICTS = new Set(['pass', 'concerns', 'fail']);
+// 'advisory' (task 1003977) is the Reader's only verdict — a non-gating lens
+// whose row must still COUNT AS EVIDENCE that the panel ran. Omit it here and
+// hasPanelEvidence returns false for every copy-bearing ship, because the check
+// below is an `every`: one unrecognised verdict makes a fully-healthy five-worker
+// panel look like no evidence at all, and the implausible-pass guard then fires
+// on exactly the ships that carry the most lenses.
+const WORKER_VERDICTS = new Set(['pass', 'concerns', 'fail', 'advisory']);
 function hasPanelEvidence(signals) {
   const ws = Array.isArray(signals?.workers) ? signals.workers : null;
   if (!ws || ws.length < 3) return false;

package/modules/grading/grader-workers/extract-json.js

@@ -17,7 +17,13 @@
 
 // Score keys that mark a parsed object as the real grade (vs an incidental
 // prose object). Module-level so extractJson doesn't re-allocate per call.
-const GRADE_SHAPE_KEYS = ['functional_fidelity', 'code_quality', 'security_score', 'efficiency_score'];
+// task 1003977: 'copy_score' joins the list when the Reader joins the panel.
+// reader.js re-exports THIS extractJson, so without its key the disambiguation
+// above silently does not apply to it — an ambiguous multi-object response would
+// fall back to candidates[0] with no score-based preference. It fails safe (a
+// non-gating worker with no signal blocks nothing), but failing safe is not the
+// same as getting the protection every other worker gets.
+const GRADE_SHAPE_KEYS = ['functional_fidelity', 'code_quality', 'security_score', 'efficiency_score', 'copy_score'];
 
 function extractJson(raw) {
   if (typeof raw !== 'string') return null;

package/modules/grading/grader-workers/index.js

@@ -18,18 +18,52 @@ const narc = require('./narc');
 const quality = require('./quality');
 const hacker = require('./hacker');
 const efficiency = require('./efficiency');
+const reader = require('./reader');
 
 const REGISTRY = {
   [narc.KIND]: narc,
   [quality.KIND]: quality,
   [hacker.KIND]: hacker,
   [efficiency.KIND]: efficiency,
+  [reader.KIND]: reader,
 };
 
 // The active panel for the ship-time gate. Order is presentation-only —
 // workers run in parallel inside gradeSubagent.
 const DEFAULT_PANEL = [narc.KIND, quality.KIND, hacker.KIND, efficiency.KIND];
 
+// Workers that are NEVER part of the gate — not a hard fail, not a downgrade to
+// concerns, not a missing-signal outage. Distinct from grader.js's
+// ADVISORY_WORKERS ('narc'), which only softens a fail into manual-confirm.
+//
+// The Reader is here because the owner's term for it (2026-09-17, ADR 0298) is
+// absolute: ADR 0241 put the artist's judgement on the DEPLOY and off the ship
+// path, and a copy lens that could hold a ship puts back what ADR 0162 retired.
+// Deliberately NO blocker escape hatch of the kind narc/hacker carry — see the
+// header of reader.js for why that hatch would be the hole the term closes.
+//
+// This set is belt; reader.js's computeVerdict, which cannot return anything but
+// 'advisory', is braces. Either alone would hold; both, because a filter is one
+// refactor from being forgotten and a verdict is not.
+const NON_GATING_WORKERS = new Set([reader.KIND]);
+function isNonGatingKind(kind) { return NON_GATING_WORKERS.has(kind); }
+
+// The panel for one ship. `copyBearing` is the CALLER's answer, never computed
+// here: the one definition is hasCopyOrVisualWork() in modules/lifecycle/
+// cascade.js, and a module may require only src/module-api.js (ADR 0083), so
+// grading cannot reach it. Writing a second predicate here is exactly what the
+// task forbids — the at-ship lens and the after-the-fact artist review must
+// never disagree about what they cover, and widening that set must widen both
+// at once. So the caller (scripts/gds/ship-grade.js, which is not a module and
+// may require both) asks lifecycle and passes the answer down.
+//
+// Where it is false the panel is BYTE-IDENTICAL to today's and costs what it
+// costs today. The skip is recorded by the caller as a visible signal, never as
+// a silent absence — a missing copy score must not read as a passing one.
+function panelFor({ copyBearing = false } = {}) {
+  return copyBearing ? [...DEFAULT_PANEL, reader.KIND] : [...DEFAULT_PANEL];
+}
+
 // #465: transient subprocess/parse errors are infra noise, not a quality
 // signal — auto-retry the worker ONCE on these before letting the error stand.
 // Deliberately EXCLUDES:
@@ -79,6 +113,11 @@ const WORKER_MAX_TIMEOUT_MS = {
   quality: 360_000,    // Read-heavy: reads changed files for cleanliness review
   hacker: 360_000,     // Read-heavy on a security diff: exploit-surface scan of every changed file
   efficiency: 360_000, // Read-heavy on a large diff: traces perf across every changed file
+  // Read-heavy by construction: the Reader's first Read is the voice guide, and
+  // the rest confirm that a string really is user-facing. Same heavy tier as the
+  // rest — worst-case panel wall time is max(), and the four already sit at 360s,
+  // so adding a fifth at the same budget does not move it (task 1003977).
+  reader: 360_000,
 };
 
 // task 1003313: the diagnostic a dark panel used to throw away.
@@ -244,6 +283,9 @@ async function runWorker(worker, { task, valueSummary, diff, changedFiles, diffS
 module.exports = {
   REGISTRY,
   DEFAULT_PANEL,
+  NON_GATING_WORKERS,
+  isNonGatingKind,
+  panelFor,
   resolvePanel,
   runWorker,
   timeoutForWorker, // public surface; WORKER_MAX_TIMEOUT_MS stays module-internal
@@ -255,4 +297,5 @@ module.exports = {
   quality,
   hacker,
   efficiency,
+  reader,
 };

package/modules/grading/grader-workers/reader.js

@@ -0,0 +1,218 @@
+// The Reader — the advisory copy lens (task 1003977, ADR 0298).
+//
+// Specialty: the SENTENCES. Is a line a person reads true, clear, in the
+// project's voice, and worth their attention? The other four workers read
+// completion (Narc), code quality (Quality), security (Hacker) and runtime cost
+// (Efficiency); not one of them reads a sentence. Task 1003937 established that
+// across four consecutive artist reviews, all of which found the same wall and
+// all of whose graded ships deservedly passed on the axes that WERE measured.
+//
+// ADVISORY, FULL STOP — and that is structural here, not a filter elsewhere.
+// This worker's computeVerdict cannot return 'fail' or 'concerns'; it returns
+// the single verdict 'advisory' on every path, including its own errors. The
+// panel then excludes it from the gate (NON_GATING_WORKERS in index.js, and the
+// partition in grader.js aggregatePanel). Two independent mechanisms, because
+// the owner's term (2026-09-17) is absolute: ADR 0241 put the artist's judgement
+// on the DEPLOY and off the ship path, after ADR 0162 retired review gates for
+// stranding graded-PASS work. A reader that could fail a ship puts that back.
+//
+// NOTE THIS IS STRONGER THAN ADVISORY_WORKERS. The Narc is "advisory" in the
+// sense that a Narc-only fail DOWNGRADES to concerns (manual-confirm). The
+// Reader cannot reach concerns either. There is deliberately NO blocker escape
+// hatch of the kind narc/hacker carry ("advisory ONLY if it carries no
+// blocker"): a copy lens finding something that genuinely blocks a ship is a
+// finding in another lens's territory, and the escape hatch would be the exact
+// hole the owner's term closes.
+//
+// THE STANDARD IS WRITTEN DOWN. docs/voice.md (task 1003976) is the rubric, and
+// its own rule is that a finding citing no rule id is not a finding. The guide
+// splits HARD rules (V1-V5, checkable — a lens may assert a break) from
+// JUDGEMENT rules (V6-V11, recognisable but not provable — a lens may only FLAG
+// a candidate and must quote the line). That split is reproduced in the prompt
+// below, because it is what keeps an advisory lens from recording taste as fact.
+
+const { buildWorkerPrompt, LLM_PROJECT } = require('./worker-prompt');
+const { parseCommon } = require('./worker-verdict');
+const { extractJson } = require('./extract-json');
+
+const KIND = 'reader';
+const NAME = 'Reader';
+const SPECIALTY = 'user-facing copy: truth, clarity, voice (docs/voice.md), against the written guide';
+
+// The ONE verdict this worker emits. Not 'pass': a pass is a claim the gate may
+// read, and an errored Reader claiming 'pass' would be a false one. Registered
+// in grader-score.js WORKER_VERDICTS so hasPanelEvidence still recognises a
+// panel that carries a Reader row.
+const ADVISORY_VERDICT = 'advisory';
+
+const PROMPT_HEADER = `You are the **Reader** — the copy lens for the ${LLM_PROJECT} project. You read the SENTENCES a person will see.
+
+You are ADVISORY. Nothing you report can block this ship, and you should not write as though it could. Your output is coaching for the artist who reviews this work afterwards, and a record of where the grade was otherwise blind.
+
+Your ONLY job is user-facing copy. You do NOT score whether the description was implemented (Narc), whether the code is well-written (Quality), whether it is secure (Hacker), or what it costs to run (Efficiency). If you notice something in those territories, say so in \`notes_md\` and move on — do not file it as an issue.
+
+## The standard is written down, and you must cite it
+
+\`docs/voice.md\` is the voice guide. **Read it first** — it is the rubric for this grade, and its rules carry ids (V1, V2, …).
+
+**A finding that cites no rule id is not a finding.** If a line is bad and no rule in the guide reaches it, say that in \`notes_md\` as a gap in the guide. Do not invent a rule at grade time. This is the guide's own instruction and it is what separates a lens from a second model's taste.
+
+The guide splits its rules in two, and the split governs what you may say:
+
+- **Hard rules (V1-V5)** can be checked. A line either breaks one or it does not. You MAY assert a break.
+- **Judgement rules (V6-V11)** name a failure a person can recognise but a checker cannot prove. You may **flag a candidate** and must quote the line and the rule id. You may NEVER assert that the line is wrong. The artist decides.
+
+Set \`kind\` on every issue to \`"break"\` (hard rule, asserted) or \`"flag"\` (judgement rule, offered). A judgement-rule issue filed as a break is the single most damaging thing you can do here, because it records taste as fact.
+
+## What counts as user-facing copy
+
+What the guide governs: every string a person reads on the builders' hall, the status dashboard and the landing surface; server-side route failures and validation text; outbound broadcast text.
+
+What it does NOT govern, and you must not score: repository documentation, ADRs, session logs, code comments, commit messages, skill prose. Those are written for builders and agents in ordinary technical prose. A diff that changes ONLY those carries no copy for you to read — say so and score 10.
+
+## How you work
+
+1. Read \`docs/voice.md\`.
+2. Walk the diff for CHANGED or ADDED user-facing strings. Quote each line you judge.
+3. For each, name the rule id it breaks or that it is a candidate against.
+4. Score \`copy_score\` (0-10):
+   - 10 = no user-facing copy changed, or every changed line is clean against the guide.
+   - 8 = clean; one or two judgement-rule flags worth the artist's eye.
+   - 6 = at least one hard-rule break in a line a person will read.
+   - 4 = several hard-rule breaks, or one in a high-traffic surface.
+   - 2 = the copy actively misleads (a word that means something else here, a claim the code does not support).
+   - 0 = the copy is wrong in a way that would embarrass the project in front of a user.
+
+   The score is a RECORD, not a gate. Nothing happens to the ship at any value.
+
+5. Severities: \`major\` for a hard-rule break on a line a person reads; \`minor\` for a hard-rule break somewhere quiet; \`nit\` for a judgement-rule flag. Never \`blocker\` — you cannot block, and a blocker severity from this lens is a category error.
+
+## Read budget
+
+**5 Read calls.** Spend the first on \`docs/voice.md\`. Spend the rest confirming that a string you are judging really is user-facing — the surrounding render path tells you, and a string in a code comment is not copy.
+
+## Sanity checks
+
+- A diff with no user-facing string changes scores 10 with no issues. That is a normal, common outcome. Do not manufacture findings to look useful.
+- Every issue quotes the line and names a rule id.
+- No issue carries severity \`blocker\`.
+- Do not rewrite the copy for them unless the fix is obvious and one line; the artist owns the remake.
+
+## Return ONLY JSON
+
+No prose, no markdown fences:
+
+\`\`\`
+{
+  "copy_score": <number 0-10>,
+  "confidence": <number 0-1>,
+  "reads_used": <integer 0-5>,
+  "strings_reviewed": [
+    { "where": "<file:line>", "line": "<the string, quoted>", "verdict": "ok"|"break"|"flag", "rule": "<V-id or null>" }
+  ],
+  "issues": [
+    { "severity": "major"|"minor"|"nit", "kind": "break"|"flag", "rule": "<V-id>", "file": "<path>", "summary": "<one line, quotes the copy and names the rule>" }
+  ],
+  "notes_md": "<short markdown — which surfaces carried copy, what you could not judge, and any gap in the guide you hit>"
+}
+\`\`\`
+
+You have a Read tool with a hard budget of 5 calls. Do not run tests, do not edit files, do not call the network.`;
+
+function buildPrompt({ task, valueSummary, diff, changedFiles, diffStats, priorRound, contextBundle }) {
+  return buildWorkerPrompt({
+    priorRound,
+    contextBundle,
+    header: PROMPT_HEADER,
+    task: task || {},
+    valueSummary,
+    diff,
+    changedFiles,
+    taskHeader: '## Task (context — you judge the copy, not the completion)',
+    descLabel: '**Description:**',
+    emptyFilesText: '(no files changed)',
+    readFilesHint: 'You can Read any of these files to see their post-merge state (5-call budget — spend the first on docs/voice.md).',
+    finalInstruction: 'Now read the copy. Cite a rule id on every finding, or do not file it. Output ONLY the JSON object.',
+  });
+}
+
+// The Reader's verdict is 'advisory' on EVERY path — a clean read, a bad read,
+// a crashed subagent, a timeout. There is no branch that returns anything else,
+// which is what makes "it cannot block" a property of this function rather than
+// a promise kept by its callers.
+//
+// An error still travels: `error` is set, the notes say so, and copy_score is
+// null rather than 0. A 0 would be a real score meaning "the copy is wrong in a
+// way that would embarrass the project", and an outage is not that. The same
+// distinction #943 draws for the panel — missing signal is not a bad signal.
+function computeVerdict(parsed, meta = {}) {
+  const advisory = (extra) => ({
+    verdict: ADVISORY_VERDICT,
+    scores: {},
+    issues: [],
+    confidence: null,
+    error: null,
+    ...extra,
+  });
+
+  if (meta.subprocess_error) {
+    return advisory({
+      notes_md: `Reader — ADVISORY, no signal: subagent error (${meta.subprocess_error}). The copy was not read; this does not affect the ship.`,
+      error: meta.subprocess_error,
+    });
+  }
+  if (!parsed || typeof parsed !== 'object') {
+    return advisory({
+      notes_md: 'Reader — ADVISORY, no signal: could not parse subagent output as JSON. The copy was not read; this does not affect the ship.',
+      error: 'parse_error',
+    });
+  }
+
+  const { conf, issues: rawIssues, notesFromSubagent } = parseCommon(parsed);
+  const score = Number(parsed.copy_score);
+  const reviewed = Array.isArray(parsed.strings_reviewed) ? parsed.strings_reviewed : [];
+
+  // A blocker from this lens is a category error, not a blocking finding. It is
+  // FLOORED to major rather than dropped: the observation may be real and the
+  // artist should see it; what it may not be is a severity the gate reads as
+  // blocking. Dropping it would hide a finding; honouring it would hand this
+  // worker the veto the owner's term denies it.
+  const issues = rawIssues.map((i) => (
+    i && i.severity === 'blocker'
+      ? { ...i, severity: 'major', severity_floored_from: 'blocker' }
+      : i
+  ));
+
+  if (!Number.isFinite(score) || score < 0 || score > 10) {
+    return advisory({
+      issues,
+      notes_md: `Reader — ADVISORY, no score: copy_score was non-numeric or out of range (got ${parsed.copy_score}). Findings below still stand.`,
+      error: 'schema_error',
+      confidence: conf,
+    });
+  }
+
+  const s = Math.round(score * 10) / 10;
+  const breaks = issues.filter((i) => i.kind === 'break').length;
+  const flags = issues.filter((i) => i.kind === 'flag').length;
+  const prefix = `Reader — ADVISORY (copy=${s}/10, ${breaks} rule break${breaks === 1 ? '' : 's'}, ${flags} flag${flags === 1 ? '' : 's'}, ${reviewed.length} string${reviewed.length === 1 ? '' : 's'} reviewed, conf=${conf ?? '?'})`;
+
+  return advisory({
+    scores: { copy_score: s },
+    issues,
+    strings_reviewed: reviewed,
+    notes_md: `${prefix}\n${notesFromSubagent.trim()}`.trim(),
+    confidence: conf,
+  });
+}
+
+module.exports = {
+  KIND,
+  NAME,
+  SPECIALTY,
+  ADVISORY_VERDICT,
+  PROMPT_HEADER,
+  buildPrompt,
+  extractJson,
+  computeVerdict,
+};

package/modules/grading/grader.js

@@ -110,7 +110,27 @@ function describeOutage(gating) {
 }
 
 function aggregatePanel(workerResults, meta = {}) {
-  const N = workerResults.length;
+  // task 1003977 — THE NON-GATING PARTITION, before any gate arithmetic.
+  //
+  // A non-gating worker (today: the Reader, the advisory copy lens) contributes
+  // its scores and issues to the RECORD and nothing at all to the GATE. It is
+  // removed here, once, rather than special-cased in each of the counts below —
+  // pass/concerns/fail counts, the error and outage detection, the confidence
+  // median and every branch of the verdict all read `gateResults`.
+  //
+  // Removing it from the counts is why a Reader outage cannot reach #943's
+  // "every gating worker is missing signal" branch, and why a Reader cannot
+  // nudge the confidence median that drives the server-side gate. `N` stays the
+  // GATE's denominator so the verdict strings keep meaning what they said
+  // before ("2/4 gating worker(s) failed" counts the four that can fail).
+  //
+  // ADVISORY_WORKERS below is a DIFFERENT, weaker thing: narc is advisory in
+  // that a narc-only fail downgrades to manual-confirm. A non-gating worker
+  // never reaches even that.
+  const isNonGating = (w) => w && workers.isNonGatingKind(w.kind);
+  const nonGatingResults = workerResults.filter(isNonGating);
+  const gateResults = workerResults.filter((w) => !isNonGating(w));
+  const N = gateResults.length;
 
   // Score axes — median across workers that reported each. Reuses the
   // module-level median() helper (rounded to one decimal).
@@ -124,6 +144,12 @@ function aggregatePanel(workerResults, meta = {}) {
   // Phase 2.2 (#421): Efficiency Monger reports efficiency_score. Same
   // additive treatment as security_score.
   const efficiencyScore = median(workerResults.map((w) => w.scores?.efficiency_score));
+  // task 1003977: the Reader reports copy_score. Recorded like security_score
+  // and efficiency_score before it — additive, and read from the FULL result
+  // list rather than gateResults, because the whole point is that a non-gating
+  // worker's SIGNAL lands in the record even though its verdict never reaches
+  // the gate. Null whenever no Reader ran, which is every non-copy-bearing ship.
+  const copyScore = median(workerResults.map((w) => w.scores?.copy_score));
 
   const economyPenalty =
     economy != null ? Math.max(0, (THRESHOLD - economy) / 2) : 0;
@@ -131,8 +157,8 @@ function aggregatePanel(workerResults, meta = {}) {
   const blended = ff != null && cq != null ? r1((ff + cq) / 2) : 0;
 
   // Verdict counts.
-  const passCount = workerResults.filter((w) => w.verdict === 'pass').length;
-  const concernsCount = workerResults.filter((w) => w.verdict === 'concerns').length;
+  const passCount = gateResults.filter((w) => w.verdict === 'pass').length;
+  const concernsCount = gateResults.filter((w) => w.verdict === 'concerns').length;
   // A crashed worker sets verdict='fail' as a DEFAULT in its computeVerdict()
   // subprocess_error / parse_error / schema_error early returns (see each
   // worker module) — that is MISSING SIGNAL, not a substantive finding, and
@@ -149,12 +175,12 @@ function aggregatePanel(workerResults, meta = {}) {
   const hasSubstantiveIssue = (w) =>
     (w.issues || []).some((i) => i.severity === 'blocker' || i.severity === 'major');
   const isMissingSignal = (w) => !!w.error && !hasSubstantiveIssue(w);
-  const failCount = workerResults.filter((w) => w.verdict === 'fail' && !isMissingSignal(w)).length;
+  const failCount = gateResults.filter((w) => w.verdict === 'fail' && !isMissingSignal(w)).length;
   // NOTE (#473/#589): signals.error_count counts only isMissingSignal workers — i.e. a worker that
   // errored AND surfaced no blocking issue. A worker that errored but still raised a blocker/major
   // is a real finding, so it counts in fail_count (above), NOT here. This is a deliberate semantic
   // change from the old "all w.error" meaning; keep error_count = missing-signal-only.
-  const errorCount = workerResults.filter((w) => isMissingSignal(w)).length;
+  const errorCount = gateResults.filter((w) => isMissingSignal(w)).length;
 
   // V3.R85 (#481): the Narc (functional_fidelity) is ADVISORY in the gate —
   // Lars's call 2026-05-30 after #303, where over-literal acceptance-criteria
@@ -188,8 +214,8 @@ function aggregatePanel(workerResults, meta = {}) {
   // taken out by a grader outage, so it is not evidence either way about whether the
   // panel ran. Task 1003574.
   const isDeterministic = (w) => w && w.model === 'deterministic';
-  const nonAdvisory = workerResults.filter((w) => !isAdvisory(w));
-  const gating = nonAdvisory.length ? nonAdvisory : workerResults;
+  const nonAdvisory = gateResults.filter((w) => !isAdvisory(w));
+  const gating = nonAdvisory.length ? nonAdvisory : gateResults;
   const gatingFail = gating.filter((w) => w.verdict === 'fail' && !isMissingSignal(w)).length;
   const gatingError = gating.filter((w) => isMissingSignal(w)).length;
   const gatingConcerns = gating.filter((w) => w.verdict === 'concerns').length;
@@ -228,15 +254,15 @@ function aggregatePanel(workerResults, meta = {}) {
   const gatingErrorAll = subagentGating.length > 0 && subagentGating.every((w) => isMissingSignal(w));
   // Advisory-worker outcomes — never a hard block. Uses isAdvisory so a Narc
   // that DID raise a blocker is treated as gating (in `nonAdvisory`), not here.
-  const advisoryFail = workerResults.some((w) => isAdvisory(w) && w.verdict === 'fail' && !isMissingSignal(w));
-  const advisoryConcerns = workerResults.some((w) => isAdvisory(w) && w.verdict === 'concerns');
+  const advisoryFail = gateResults.some((w) => isAdvisory(w) && w.verdict === 'fail' && !isMissingSignal(w));
+  const advisoryConcerns = gateResults.some((w) => isAdvisory(w) && w.verdict === 'concerns');
 
   // Confidence — median for pass, fallthrough for concerns, 0 for fail.
   // (Drives the server-side gate; see file header.) Computed UNROUNDED —
   // confidence sits near the 0.4 gate cap so the module-level median()
   // helper (which rounds via r1()) would risk nudging a borderline value
   // across the boundary. Inlined for that one-decimal-precision reason.
-  const confVals = workerResults
+  const confVals = gateResults
     .map((w) => w.confidence)
     .filter((n) => Number.isFinite(n))
     .slice()
@@ -360,7 +386,12 @@ function aggregatePanel(workerResults, meta = {}) {
 
   // Build display notes.
   const lines = [];
-  lines.push(`Subagent grader ${VERSION} (panel of ${N}: ${workerResults.map((w) => w.kind).join(', ')}) — ${verdict}`);
+  // N counts the GATING workers; a non-gating one is named separately so the
+  // line cannot read as an off-by-one ("panel of 4: …five kinds…").
+  const advisoryKinds = nonGatingResults.map((w) => w.kind);
+  lines.push(`Subagent grader ${VERSION} (panel of ${N}: ${gateResults.map((w) => w.kind).join(', ')}`
+    + (advisoryKinds.length ? ` · advisory, non-gating: ${advisoryKinds.join(', ')}` : '')
+    + `) — ${verdict}`);
   if (ff != null) lines.push(`  functional_fidelity (Narc):  ${ff}/10`);
   if (cq != null) lines.push(`  code_quality (Quality):      ${cq}/10`);
   if (economy != null) lines.push(`  economy (Quality, adv.):     ${economy}/10`);
@@ -421,6 +452,7 @@ function aggregatePanel(workerResults, meta = {}) {
       code_quality_effective: cqEffective,
       security_score: security,
       efficiency_score: efficiencyScore,
+      copy_score: copyScore,
     },
     signals: {
       grader_kind: 'subagent-panel',
@@ -470,6 +502,10 @@ function graderUnavailableResult({ reason, note, meta = {} } = {}) {
       code_quality_effective: null,
       security_score: null,
       efficiency_score: null,
+      // task 1003977: nulled with the rest so an outage grade's rubric_scores
+      // has the SAME SHAPE as a normal one. A key that is absent here and
+      // present there is a difference a consumer has to know about.
+      copy_score: null,
     },
     signals: {
       grader_kind: 'subagent-panel',

package/modules/lifecycle/cascade.js

@@ -135,23 +135,33 @@ function hasCopyOrVisualWork(task) {
 // STEP 2 remakes the copy/visuals with both routes explicitly offered — R04's
 // brief, verbatim in intent.
 //
-// STEP 1 used to say "coach the grader", and for as long as that was the wording
-// it asked for something no artist could do (task 1003937, ADR 0298). The panel's
-// four lenses — narc, quality, hacker, efficiency — read completion, code quality,
-// security and runtime cost; not one of them reads a sentence, so there was no
-// counterpart to coach and four consecutive reviews found the same wall. The
-// ADR's decision is a fifth ADVISORY 'reader' lens, scoped to copy-bearing diffs
-// by this file's own hasCopyOrVisualWork, built only after the instance writes a
-// voice guide to judge against. Until it exists the step asks for the RECORD
-// instead of the coaching: followable today, and it is the corpus both the guide
-// and the lens will be written from. When the reader lands, this reverts to
-// coaching a lens that is actually listening — and the wording is the signal for
-// which of those two worlds we are in, so do not restore the old sentence early.
+// STEP 1 ASKS FOR COACHING AGAIN, because there is now a lens listening.
+//
+// The history, because the wording is load-bearing: STEP 1 originally said
+// "coach the grader", which asked for something no artist could do (task
+// 1003937, ADR 0298) — the panel's four lenses read completion, code quality,
+// security and runtime cost, and not one read a sentence, so four consecutive
+// reviews found the same wall. The step was rewritten to ask for the RECORD
+// instead, and that version carried an explicit instruction not to restore the
+// coaching wording early, because the wording is the signal for which world we
+// are in.
+//
+// Task 1003977 shipped the fifth lens: an ADVISORY 'reader', scoped to
+// copy-bearing diffs by THIS FILE'S hasCopyOrVisualWork — the same predicate
+// that fires this cascade, so an artist review and the copy lens cover exactly
+// the same set by construction, and widening one widens both. The voice guide
+// it waited on is docs/voice.md (task 1003976). So there is a counterpart to
+// coach, it has a written standard to be coached against, and the record the
+// interim wording collected is what both were built from.
+//
+// What has NOT changed: the reader is non-gating and cannot hold a ship (ADR
+// 0241 keeps the artist's judgement on the deploy), so this review is still a
+// request triage may dismiss.
 function artistReviewBody(task) {
   return [
     `This is an ARTIST REVIEW, generated automatically because task ${task.id} put copy or visuals in front of a person. It is a REQUEST, not a gate — it blocks nothing that shipped, and triage may dismiss it.`,
     '',
-    `STEP 1 — READ THE GRADE, AND WRITE DOWN WHAT IT COULD NOT SEE. Pull how the grader judged task ${task.id} (GET /tasks/${task.id}?include=grade), then record what an artist would have caught and no lens did: slop, an off-voice line, a claim that does not land, a visual that reads as generated. Do not expect to find a copy verdict to argue with — the panel's four lenses read completion, code quality, security and runtime cost, and none of them reads a sentence (ADR 0298). Your record IS the compounding part: it is the evidence the advisory 'reader' lens is being built from, and the corpus the voice guide it waits on will be written against.`,
+    `STEP 1 — COACH THE READER. Pull how the grader judged task ${task.id} (GET /tasks/${task.id}?include=grade) and find the 'reader' row in signals.workers, with its copy_score in rubric_scores. That lens read the changed copy against docs/voice.md and cited rule ids. Say where it was RIGHT, where it was WRONG, and — the valuable one — what it did not see at all. A finding it filed that you disagree with is worth as much as one it missed: both are corrections to a lens that is listening, which is what this step could not ask for before task 1003977 shipped it (ADR 0298). If the miss is because no rule in docs/voice.md reaches it, that is a gap in the GUIDE — file it against the guide rather than expecting the lens to invent a rule at grade time. Two cases where there will be no reader row and that is not a fault: a ship that took the trivial-diff path (a single generalist shot, no panel), and one where the lens errored — it is advisory, so an outage is recorded and nothing is blocked.`,
     '',
     'STEP 2 — REMAKE OR TWEAK the copy/visuals if they need it. Your choice of route, both offered on purpose: OUTSIDE the AI chat (edit the surface directly and land it through the copy desk or the normal pipeline), or WITH it (draft in chat, then land). Either way it lands as a claimed, graded, shipped task like everything else — there is no live CMS (goal 1000074\'s hard rule).',
     '',

package/modules/lifecycle/tests/cascade.mjs

@@ -213,15 +213,24 @@ await test('a copy/visual ship generates the two-step artist review', () => {
   assert.match(spec.title, /7001/);
   // Both steps, and both routes of step 2, are in the body.
   //
-  // STEP 1's label tracks ADR 0298 (task 1003937). It used to read
-  // "REVIEW THE GRADER … coach it", which asked for something no artist could
-  // do: the panel's four lenses read completion, code quality, security and
-  // runtime cost, so there was no copy verdict to coach. Until the advisory
-  // reader worker ships (task 1003977, itself gated on the voice guide in
-  // task 1003976) the step asks for the RECORD instead — hence the pin on the
-  // new label AND on the ADR reference, which is what stops a well-meaning
-  // copy-edit from restoring the unfollowable version without reading why.
-  assert.match(spec.description, /STEP 1 — READ THE GRADE, AND WRITE DOWN WHAT IT COULD NOT SEE/);
+  // STEP 1's label tracks ADR 0298 (task 1003937), and it has now turned twice.
+  // It first read "REVIEW THE GRADER … coach it", which asked for something no
+  // artist could do: the panel's four lenses read completion, code quality,
+  // security and runtime cost, so there was no copy verdict to coach. It was
+  // rewritten to ask for the RECORD instead, as an explicitly INTERIM wording,
+  // pinned here so a well-meaning copy-edit could not restore the unfollowable
+  // version without reading why.
+  //
+  // Task 1003977 shipped the advisory reader lens and the voice guide it waited
+  // on (task 1003976), so the step is coaching again — and this pin moves with
+  // it. The two must turn TOGETHER: the wording is the signal for which world
+  // we are in, so a body that still said "no lens reads a sentence" after the
+  // lens landed would send every artist looking for a counterpart that is
+  // sitting right there in the grade record.
+  assert.match(spec.description, /STEP 1 — COACH THE READER/);
+  assert.match(spec.description, /docs\/voice\.md/, 'and names the written standard to coach against');
+  assert.doesNotMatch(spec.description, /none of them reads a sentence/,
+    'the interim claim is gone — it stopped being true when the reader shipped');
   assert.match(spec.description, /ADR 0298/, 'the step names the decision that shaped it');
   assert.match(spec.description, /STEP 2 — REMAKE OR TWEAK/);
   assert.match(spec.description, /OUTSIDE the AI chat/);

package/package-lock.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bongos/core",
-  "version": "1.19.889",
+  "version": "1.19.890",
   "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/ship-grade.js

@@ -12,6 +12,14 @@ const crypto = require('node:crypto');
 const { spawn } = require('node:child_process');
 const { cliClient } = require('./cli-lib');
 const grader = require('../../modules/grading/grader');
+// task 1003977: the ONE definition of "does this ship put copy in front of a
+// person". It lives in the lifecycle module and the grading module may not
+// require a sibling (ADR 0083), so this script — which is not a module and
+// already requires grading directly — is the seam where the two meet. Writing a
+// second predicate inside grading would let the at-ship reader lens and the
+// after-the-fact artist review disagree about what they cover, and widening the
+// set would then have to be done twice.
+const { hasCopyOrVisualWork } = require('../../modules/lifecycle/cascade.js');
 const { resolveBuilderModel } = require('./ship-memory-sync.js');
 const { argvOut, gitArgvOk, gitOk, shellOk } = require('./ship-git.js');
 const { GRADER_DIFF_CHAR_CAP, GRADER_TIMEOUT_MS, REPO_ROOT, noteServerReward } = require('./ship-state.js');
@@ -285,9 +293,16 @@ async function runSubagentGrader({ task, valueSummary, baseline, changedFiles: p
       lenses_dropped: ['hacker', 'efficiency'],
     };
   } else {
-    const panel = grader.WORKERS.DEFAULT_PANEL;
+    // task 1003977: the advisory Reader rides along on copy-bearing diffs only.
+    // Where the predicate says no, `panel` is byte-identical to DEFAULT_PANEL
+    // and the ship costs exactly what it costs today.
+    const copyBearing = hasCopyOrVisualWork(task);
+    const panel = grader.WORKERS.panelFor({ copyBearing });
     console.log(`  subagent grader ${grader.VERSION}: panel of ${panel.length} workers (${panel.join(', ')}), model=${grader.selectGraderModel({ builderModel })} (builder ${builderModel || `${grader.ASSUMED_BUILDER_MODEL} assumed`}), changed_files=${changedFiles.length}, diff_chars=${diff.length}, per-worker timeout=${GRADER_TIMEOUT_MS}ms`);
-    console.log(`  gate: every worker must return verdict='pass'; 'concerns' → manual-confirm fall-through; 'fail' blocks`);
+    console.log(`  gate: every GATING worker must return verdict='pass'; 'concerns' → manual-confirm fall-through; 'fail' blocks`);
+    console.log(copyBearing
+      ? `  copy lens: ON — this task is copy-bearing, so the advisory 'reader' reads the changed strings against docs/voice.md. It is NON-GATING: nothing it reports, and no error or timeout it hits, can stop this ship.`
+      : `  copy lens: off — not a copy-bearing task (no copy-proposal source, not artist-discipline, module not in COPY_VISUAL_MODULES), so the panel is the usual four.`);
     if (priorRound) {
       console.log(`  delta re-grade (task 1002662): prior round's findings + builder response ride along, fenced; answered findings can only re-veto with NEW evidence`);
     }
@@ -300,8 +315,19 @@ async function runSubagentGrader({ task, valueSummary, baseline, changedFiles: p
       builderRank,          // SEC #863: drives the permission-path pre-pass
       builderModel,         // task 1002659: real session model → cross-model grader pick
       priorRound,           // task 1002662: delta-aware re-grade context (panel path only)
+      workers: panel,       // task 1003977: DEFAULT_PANEL, plus the advisory reader when copy-bearing
       runOpts,
     });
+    // A SKIPPED LENS IS RECORDED, NEVER SILENT. Without this a grade with no
+    // copy_score is indistinguishable from one where the copy was read and
+    // found clean — a missing score would read as a passing one. Same pattern
+    // and same reason as the trivial path's `lenses_dropped` above.
+    if (!copyBearing) {
+      result.signals = {
+        ...(result.signals || {}),
+        reader_skipped: 'not_copy_bearing',
+      };
+    }
   }
   const wallMs = Date.now() - t0;
   // Decorate signals with the local shortstat — useful in audit-trail.

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.889'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.890'; // 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/extract_json.mjs

@@ -128,11 +128,19 @@ test('nothing parseable is null', () => {
 test('GRADE_SHAPE_KEYS is the exported score-key list', () => {
   // Exported so workers and grader.js agree on what "grade-shaped" means; the
   // preference test above depends on functional_fidelity being in this list.
+  //
+  // ONE ENTRY PER WORKER THAT REPORTS A SCORE. task 1003977 added copy_score
+  // with the reader: reader.js re-exports this extractJson, so a worker missing
+  // from this list silently loses the score-based disambiguation every other
+  // worker gets. Kept as an exact list rather than loosened, because that
+  // silence is the whole reason to pin it — a new worker must appear here in
+  // the same change that adds it.
   assert.deepEqual(GRADE_SHAPE_KEYS, [
     'functional_fidelity',
     'code_quality',
     'security_score',
     'efficiency_score',
+    'copy_score',
   ]);
 });
 

package/tests/grader_reader_lens.mjs

@@ -0,0 +1,257 @@
+// tests/grader_reader_lens.mjs — the advisory Reader lens (task 1003977, ADR 0298).
+//
+// The owner settled three terms on 2026-09-17 and each is pinned here:
+//   SCOPE      copy-bearing diffs only, keyed off the ONE existing predicate.
+//   AUTHORITY  advisory, full stop — it cannot fail, cannot reach 'concerns',
+//              and cannot block via an error or a timeout.
+//   STANDARD   docs/voice.md, cited by rule id.
+//
+// The task names the error exemption as "the single most important test in this
+// task", because a worker error normally HARD-FAILS the panel
+// (panel_gate: 'ANY worker.error != null → passed=false'). It is §2 below.
+//
+// The subtlest case is §3: a HEALTHY reader must not mask a total grader
+// outage. Before the non-gating partition, a passing fifth worker would make
+// "every gating worker is missing signal" false, and a total outage would
+// present as FAIL · 0/10 with every axis null — the exact regression class
+// task 1003574 documents, where a builder sat dark on an unclearable re-grade.
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const grader = require('../modules/grading/grader.js');
+const WORKERS = require('../modules/grading/grader-workers/index.js');
+const reader = require('../modules/grading/grader-workers/reader.js');
+const { hasPanelEvidence } = require('../modules/grading/grader-score.js');
+const { hasCopyOrVisualWork } = require('../modules/lifecycle/cascade.js');
+
+const W = (kind, verdict, extra = {}) => ({
+  kind, name: kind, verdict, scores: {}, issues: [], confidence: 0.9, error: null, ...extra,
+});
+const healthyFour = () => [
+  W('narc', 'pass', { scores: { functional_fidelity: 9 } }),
+  W('quality', 'pass', { scores: { code_quality: 9, economy: 9 } }),
+  W('hacker', 'pass', { scores: { security_score: 9 } }),
+  W('efficiency', 'pass', { scores: { efficiency_score: 9 } }),
+];
+const agg = (ws) => grader.aggregatePanel(ws, {});
+
+// ---- 1. AUTHORITY: the verdict itself cannot be a blocking one -------------
+
+test('computeVerdict returns "advisory" on EVERY path, including its own failures', () => {
+  // Structural, not a filter: there is no branch that returns pass/concerns/fail,
+  // so "it cannot block" is a property of the function rather than a promise
+  // kept by its callers.
+  const paths = [
+    ['clean', [{ copy_score: 10, issues: [] }, {}]],
+    ['bad copy', [{ copy_score: 0, issues: [{ severity: 'major', kind: 'break', rule: 'V1' }] }, {}]],
+    ['subagent error', [null, { subprocess_error: 'SUBAGENT_TIMEOUT' }]],
+    ['spawn failure', [null, { subprocess_error: 'SUBAGENT_SPAWN_FAILED' }]],
+    ['unparseable', ['not json at all', {}]],
+    ['schema error', [{ copy_score: 'banana', issues: [] }, {}]],
+    ['null parse', [null, {}]],
+  ];
+  for (const [name, [parsed, meta]] of paths) {
+    const v = reader.computeVerdict(parsed, meta);
+    assert.equal(v.verdict, 'advisory', `${name} → ${v.verdict}`);
+    assert.equal(v.verdict, reader.ADVISORY_VERDICT);
+  }
+});
+
+test('an errored Reader reports NO score rather than a zero', () => {
+  // 0/10 is a real reading ("would embarrass the project in front of a user").
+  // An outage is missing signal, not a bad signal — the distinction #943 draws
+  // for the whole panel, applied to one worker.
+  const v = reader.computeVerdict(null, { subprocess_error: 'SUBAGENT_TIMEOUT' });
+  assert.deepEqual(v.scores, {});
+  assert.equal(v.error, 'SUBAGENT_TIMEOUT');
+});
+
+test('a blocker severity is FLOORED to major, not dropped', () => {
+  // Dropping would hide a real observation; honouring would hand this lens the
+  // veto the owner's term denies it.
+  const v = reader.computeVerdict({ copy_score: 3, issues: [{ severity: 'blocker', kind: 'break', rule: 'V2' }] }, {});
+  assert.equal(v.issues.length, 1, 'the finding survives');
+  assert.equal(v.issues[0].severity, 'major');
+  assert.equal(v.issues[0].severity_floored_from, 'blocker');
+});
+
+// ---- 2. THE EXEMPTION THE TASK CALLS THE MOST IMPORTANT --------------------
+
+test('NO Reader outcome can stop a ship — including an error, which normally hard-fails', () => {
+  const baseline = agg(healthyFour());
+  assert.equal(baseline.passed, true);
+
+  const cases = {
+    'clean reader': W('reader', 'advisory', { scores: { copy_score: 9 } }),
+    'copy_score 0': W('reader', 'advisory', { scores: { copy_score: 0 } }),
+    'errored (timeout)': W('reader', 'advisory', { error: 'SUBAGENT_TIMEOUT' }),
+    'errored (prompt too long)': W('reader', 'advisory', { error: 'PROMPT_TOO_LONG' }),
+    'two major findings': W('reader', 'advisory', { scores: { copy_score: 2 }, issues: [{ severity: 'major' }, { severity: 'major' }] }),
+    // Belt AND braces: even if a future edit made the worker emit a gating
+    // verdict, the panel partition still refuses to read it.
+    'ILLEGALLY emits fail': W('reader', 'fail', { issues: [{ severity: 'blocker' }] }),
+  };
+  for (const [name, row] of Object.entries(cases)) {
+    const r = agg([...healthyFour(), row]);
+    assert.equal(r.passed, true, `${name} must not block the ship`);
+    assert.equal(r.signals.panel_outcome, 'pass', `${name} must not move the outcome`);
+  }
+});
+
+test('the Reader is absent from every gate count', () => {
+  const r = agg([...healthyFour(), W('reader', 'advisory', { error: 'SUBAGENT_TIMEOUT' })]);
+  assert.equal(r.signals.worker_count, 4, 'the gate denominator counts gating workers only');
+  assert.equal(r.signals.error_count, 0, "an errored Reader is not a gate error");
+  assert.equal(r.signals.fail_count, 0);
+  assert.equal(r.signals.pass_count, 4);
+});
+
+// ---- 3. THE SUBTLE ONE -----------------------------------------------------
+
+test('a HEALTHY Reader does not mask a total grader outage', () => {
+  const allErrored = ['narc', 'quality', 'hacker', 'efficiency'].map((k) => W(k, 'fail', { error: 'SUBAGENT_SPAWN_FAILED' }));
+  const without = agg(allErrored);
+  assert.equal(without.signals.panel_outcome, 'unavailable', 'baseline: a total outage is an outage');
+
+  const with_ = agg([...allErrored, W('reader', 'advisory', { scores: { copy_score: 9 } })]);
+  assert.equal(with_.signals.panel_outcome, 'unavailable',
+    'a passing fifth worker must not turn an outage into a FAIL 0/10 (the task-1003574 class)');
+  assert.equal(with_.passed, false);
+});
+
+test("the Reader's confidence cannot move the server-gate median", () => {
+  const four = healthyFour();
+  const noReader = agg(four).signals.confidence;
+  const withReader = agg([...four, W('reader', 'advisory', { confidence: 0.01, scores: { copy_score: 1 } })]).signals.confidence;
+  assert.equal(withReader, noReader, 'a low-confidence Reader must not drag the forwarded confidence');
+});
+
+// ---- 4. THE SIGNAL STILL LANDS ---------------------------------------------
+
+test('copy_score and the findings reach the RECORD even though the gate ignores them', () => {
+  const r = agg([...healthyFour(), W('reader', 'advisory', { scores: { copy_score: 4 }, issues: [{ severity: 'major', rule: 'V1' }] })]);
+  assert.equal(r.rubric_scores.copy_score, 4, 'the score is recorded');
+  assert.ok(r.signals.workers.some((w) => w.kind === 'reader'), 'the Reader row is in the record');
+  assert.equal(agg(healthyFour()).rubric_scores.copy_score, null, 'and is null when no Reader ran');
+});
+
+test('a Reader row still counts as evidence that the panel ran', () => {
+  // hasPanelEvidence is an `every` over the worker verdicts. Leave 'advisory'
+  // out of WORKER_VERDICTS and a fully-healthy five-worker panel reads as NO
+  // evidence, firing the implausible-pass guard on exactly the ships carrying
+  // the most lenses.
+  const rows = (extra = []) => ({ workers: [
+    { kind: 'narc', verdict: 'pass' }, { kind: 'quality', verdict: 'pass' },
+    { kind: 'hacker', verdict: 'pass' }, { kind: 'efficiency', verdict: 'pass' }, ...extra,
+  ] });
+  assert.equal(hasPanelEvidence(rows()), true);
+  assert.equal(hasPanelEvidence(rows([{ kind: 'reader', verdict: 'advisory' }])), true);
+  assert.equal(hasPanelEvidence(rows([{ kind: 'reader', verdict: 'nonsense' }])), false, 'the vocabulary is still closed');
+});
+
+// ---- 5. SCOPE --------------------------------------------------------------
+
+test('the panel is byte-identical to today when the diff is not copy-bearing', () => {
+  assert.deepEqual(WORKERS.panelFor({ copyBearing: false }), WORKERS.DEFAULT_PANEL);
+  assert.deepEqual(WORKERS.panelFor(), WORKERS.DEFAULT_PANEL, 'and when the caller says nothing');
+  assert.deepEqual(WORKERS.panelFor({ copyBearing: true }), [...WORKERS.DEFAULT_PANEL, 'reader']);
+});
+
+test('scope keys off the ONE existing predicate, not a second copy', () => {
+  // The at-ship lens and the after-the-fact artist review must never disagree
+  // about what they cover. Widening COPY_VISUAL_MODULES must widen both at once,
+  // which it only does while there is one predicate.
+  const src = fs.readFileSync(path.join(ROOT, 'scripts', 'gds', 'ship-grade.js'), 'utf8');
+  assert.match(src, /hasCopyOrVisualWork/, 'the caller asks lifecycle for the answer');
+  assert.match(src, /panelFor\(\{ copyBearing \}\)/, 'and passes it down');
+  // RECURSIVE. A readdirSync of modules/grading alone skips grader-workers/,
+  // which holds reader.js — the file this assertion is most about. The first
+  // version of this test did exactly that and proved nothing it claimed.
+  const walk = (dir) => fs.readdirSync(dir, { withFileTypes: true }).flatMap((e) => {
+    const full = path.join(dir, e.name);
+    return e.isDirectory() ? walk(full) : (e.name.endsWith('.js') ? [full] : []);
+  });
+  const gradingFiles = walk(path.join(ROOT, 'modules', 'grading'));
+  assert.ok(gradingFiles.some((f) => f.endsWith(`grader-workers${path.sep}reader.js`)),
+    'the scan reaches grader-workers/reader.js — otherwise it checks everything except the file in question');
+  for (const f of gradingFiles) {
+    const body = fs.readFileSync(f, 'utf8').replace(/^\s*\/\/.*$/gm, '');
+    assert.ok(!/COPY_VISUAL_MODULES|copy-proposal/.test(body),
+      `${path.relative(ROOT, f)} must not re-implement the copy predicate — grading cannot require lifecycle (ADR 0083), so the CALLER decides`);
+  }
+  // Sanity: the predicate really does discriminate.
+  assert.equal(hasCopyOrVisualWork({ discipline: 'artist' }), true);
+  assert.equal(hasCopyOrVisualWork({ module_key: 'hall-ui' }), true);
+  assert.equal(hasCopyOrVisualWork({ module_key: 'grading', discipline: 'engineer' }), false);
+});
+
+// ---- 6. STANDARD -----------------------------------------------------------
+
+test('the prompt sends the worker to the written guide, and forbids an uncited finding', () => {
+  const p = reader.PROMPT_HEADER;
+  assert.match(p, /docs\/voice\.md/, 'the rubric is the voice guide');
+  assert.match(p, /cites no rule id is not a finding/i, "the guide's own rule travels with it");
+  // The hard/judgement split is what stops an advisory lens recording taste as
+  // fact, so it is pinned rather than left to the prompt's good intentions.
+  assert.match(p, /V1-V5/, 'hard rules may be asserted');
+  assert.match(p, /V6-V11/, 'judgement rules may only be flagged');
+  assert.match(p, /ADVISORY/, 'the worker is told it cannot block');
+  assert.ok(!/blocker/.test(p.split('## Return ONLY JSON')[1] || ''),
+    'the JSON schema offers no blocker severity');
+});
+
+test('docs/voice.md exists — the lens has a standard to judge against', () => {
+  // The hard dependency (task 1003976). A copy lens with no written standard
+  // records taste and calls it a finding.
+  const guide = fs.readFileSync(path.join(ROOT, 'docs', 'voice.md'), 'utf8');
+  for (const id of ['V1', 'V2', 'V3', 'V4', 'V5']) {
+    assert.ok(guide.includes(`## ${id} —`) || guide.includes(`## ${id} `), `${id} is a rule in the guide`);
+  }
+});
+
+// ---- 7. THE DONE-WHEN CLAUSE THAT LIVES IN ANOTHER FILE ---------------------
+
+test('the artist review now coaches the reader, because there is a lens listening', () => {
+  // The task's own DONE WHEN: "Then STEP 1 of the artist review reverts to true
+  // coaching — see the comment in modules/lifecycle/cascade.js, which says so
+  // and asks not to be reverted early." The interim wording was explicitly a
+  // signal for which world we are in, so shipping the lens without turning it
+  // leaves the instruction to artists describing a panel that no longer exists.
+  const { artistReviewBody } = require('../modules/lifecycle/cascade.js');
+  const body = artistReviewBody({ id: '1234' });
+  assert.match(body, /COACH THE READER/, 'STEP 1 asks for coaching again');
+  assert.match(body, /docs\/voice\.md/, 'and names the standard to coach against');
+  assert.ok(!/none of them reads a sentence/.test(body),
+    'the interim claim that no lens reads a sentence is gone — it is no longer true');
+  // Still a request, never a gate (ADR 0241) — unchanged by this task.
+  assert.match(body, /REQUEST, not a gate/);
+});
+
+test('the cascade and the copy lens cover the SAME set by construction', () => {
+  // Both key off hasCopyOrVisualWork, so an artist review exists for exactly
+  // the ships a reader ran on. If these ever diverge, an artist is asked to
+  // coach a lens that never looked.
+  const cascadeSrc = fs.readFileSync(path.join(ROOT, 'modules', 'lifecycle', 'cascade.js'), 'utf8');
+  const shipSrc = fs.readFileSync(path.join(ROOT, 'scripts', 'gds', 'ship-grade.js'), 'utf8');
+  assert.match(cascadeSrc, /hasCopyOrVisualWork/);
+  assert.match(shipSrc, /hasCopyOrVisualWork/);
+});
+
+// ---- 8. COST ---------------------------------------------------------------
+
+test('the Reader sits at the heavy timeout tier, so it cannot change worst-case wall time', () => {
+  // The four already sit at 360s and workers run in parallel, so the panel's
+  // wall time is max() and a fifth at the same budget does not move it.
+  const t = WORKERS.timeoutForWorker(reader, {});
+  assert.equal(t, 360_000);
+  for (const k of ['narc', 'quality', 'hacker', 'efficiency']) {
+    assert.equal(WORKERS.timeoutForWorker(WORKERS.REGISTRY[k], {}), t, `${k} shares the tier`);
+  }
+});