clearotron 0.3.2 → 0.3.3-beta.0

package/driver/contract-e3-backlog.mjs

@@ -62,7 +62,7 @@
 // rows before this shape was chosen, and each is wrong on a live row: reading the surface off the file
 // that CONTAINS the anchor calls common-law-half a driver module (connotation-search.mjs authors it;
 // perplexity-server.mjs delivers it), and an MCP import closure calls register-digest's brief a tool
-// response through coverage-server → coverage-tool → coverage-form, when pipeline.mjs:3553 appends it to
+// response through coverage-server → coverage-tool → coverage-form, when pipeline.mjs coverageFormBrief appends it to
 // the stage message. The finding is precisely that authorship and delivery come apart, so no function of
 // the authored path can decide the answer.
 //
@@ -106,7 +106,7 @@ export const E3_BACKLOG = [
   // Two `literal-json-skeleton` and two `exactly-these-keys`, all four stamped "NOTHING ON THE PLAN
   // REMOVES THIS". The conversion removed them:
   //
-  //   stages.mjs:922            the dispatch dictated variant-manifest.json key by key and enum by enum;
+  //   stages.mjs:923            the dispatch dictated variant-manifest.json key by key and enum by enum;
   //                             `record_clearance_variants`'s schema IS that shape now, so the key-set and
   //                             enum families are unreachable from a typed call rather than caught after
   //                             the file is written.
@@ -171,7 +171,7 @@ export const E3_BACKLOG = [
   {
     stage: "common-law",
     kind: "dictated-line-shape",
-    where: "driver/stages.mjs:1081 (emitted at 1032, 1061, 1147, 1276)",
+    where: "driver/stages.mjs:1082 (emitted at 1032, 1061, 1147, 1276)",
     surface: "stage-message",
     evidence: "CROSS-CHECK HAND-OFF: … record it on its OWN line in EXACTLY the form \"CROSS-CHECK REQUIRED: <what> — <why>\" (that exact prefix; an em-dash between what and why; name the mark in CAPS in <what>). The driver parses ONLY this exact line shape…",
     reparsedBy: "driver/doubt-ledger.mjs:183 CROSS_CHECK_RE = /^(?:[-*]\\s+)?CROSS-CHECK REQUIRED:\\s*(.+?)\\s+—\\s+(.+?)\\s*$/ → mintCrossCheckDoubts",
@@ -227,7 +227,7 @@ export const E3_BACKLOG = [
   {
     stage: "common-law",
     kind: "dictated-line-shape",
-    where: "driver/stages.mjs:1054 and driver/stages.mjs:1059 (the no-grid-spec legacy branch)",
+    where: "driver/stages.mjs:1055 and driver/stages.mjs:1060 (the no-grid-spec legacy branch)",
     surface: "stage-message",
     evidence: "GRID KEYS (the validator checks EXACTLY these N terms — use each VERBATIM as its Negative-results matrix key…) … MACHINE RECEIPTS (MANDATORY): save the grid call's stdout JSON VERBATIM … the single stdout object, or a JSON ARRAY of the per-batch stdout objects in batch order when batched.",
     reparsedBy: "driver/common-law-receipts.mjs — the receipts gate's exact identity join on the dictated key list; validators.commonLaw grid-completeness arm",
@@ -256,7 +256,7 @@ export const E3_BACKLOG = [
   {
     stage: "register-unit",
     kind: "literal-json-skeleton",
-    where: "driver/stages.mjs:2253 (the non-supplemental-lane branch)",
+    where: "driver/stages.mjs:2260 (the non-supplemental-lane branch)",
     surface: "stage-message",
     evidence: "BAND ARTIFACT (MANDATORY): ALSO write the COMPLETE NAMED BAND for this axis to <path> — a JSON ARRAY, one block per register_enumerate / count-probe call, in the named-band contract: {\"state\":\"enumerated\",\"query\":\"<what was searched>\",\"total_hits\":N,\"records\":[{record_id, mark_text, classes, status,",
     reparsedBy: "driver/named-band.mjs parseNamedBand / bandRecords / bandCrowds / mergeNamedBands (named in driver/skills/clearance-register/unit.md:60-62); validators.registerUnit",
@@ -265,7 +265,7 @@ export const E3_BACKLOG = [
   {
     stage: "register-unit",
     kind: "exactly-these-keys",
-    where: "driver/stages.mjs:2217",
+    where: "driver/stages.mjs:2224",
     surface: "stage-message",
     evidence: "Every block you append MUST carry \"state\":\"enumerated\" (ONLY if you paged it to has_more:false) or \"state\":\"incomplete\" — EXACTLY those two strings; there is no \"verified\"/\"checked\"/\"complete\"/\"clean\" state, and any other value fails the stage.",
     reparsedBy: "driver/named-band.mjs parseNamedBand (off-enum state fails validators.registerUnit)",
@@ -274,7 +274,7 @@ export const E3_BACKLOG = [
   {
     stage: "register-unit",
     kind: "literal-json-skeleton",
-    where: "driver/skills/clearance-register/unit.md:83-97",
+    where: "driver/skills/clearance-register/unit.md:122-136",
     surface: "skill-file",
     evidence: "Two block shapes (no third):\\n```json\\n[\\n { \"state\":\"enumerated\", \"query\":\"…\", \"total_hits\": 12, \"records\": [ { \"record_id\":\"/mark/eu/018…\", \"mark_text\":\"…\", … } ] },\\n { \"state\":\"incomplete\", \"query\":\"…\", \"total_hits\": 2416, \"fetched\": 1, \"sample\":[ … ], \"reason\":\"…\" }\\n]\\n```",
     reparsedBy: "driver/named-band.mjs parseNamedBand — named in the skill file itself at unit.md:60-62",
@@ -283,7 +283,7 @@ export const E3_BACKLOG = [
   {
     stage: "register-unit",
     kind: "exactly-these-keys",
-    where: "driver/stages.mjs:4195 (the frame-reopen / scoped-retry message builder). A second number stood here and had been stale for some time: it pointed at a contract-element description rather than a builder, at its old line and at every mechanical shift of it. Two candidate builders sit beside 4157 and picking one would be a guess, so the wrong pointer is removed rather than moved a third time — one accurate citation beats one accurate and one invented.",
+    where: "driver/stages.mjs:4202 (the frame-reopen / scoped-retry message builder). A second number stood here and had been stale for some time: it pointed at a contract-element description rather than a builder, at its old line and at every mechanical shift of it. Two candidate builders sit beside 4157 and picking one would be a guess, so the wrong pointer is removed rather than moved a third time — one accurate citation beats one accurate and one invented.",
     surface: "stage-message",
     evidence: "Every block you append MUST carry \"state\":\"enumerated\" (ONLY if paged to has_more:false) or \"state\":\"incomplete\" — EXACTLY those two strings … (re-dispatch builders, which REPLACE def.message)",
     reparsedBy: "driver/named-band.mjs parseNamedBand. Scope warning: these builders replace def.message on every escalation / envelope-close / frame-reopen dispatch, so an E3 lint that walks STAGES[*].message only never sees them",
@@ -301,7 +301,7 @@ export const E3_BACKLOG = [
   {
     stage: "placement-inquiry",
     kind: "exactly-these-keys",
-    where: "driver/stages.mjs:2413",
+    where: "driver/stages.mjs:2420",
     surface: "stage-message",
     evidence: "· tier EXACTLY one of headline-candidate / sheet-2 / watchlist-annex / out-of-scope-filtered.",
     reparsedBy: "driver/placement-form.mjs / driver/placement-model.mjs via validators.placement",
@@ -313,7 +313,7 @@ export const E3_BACKLOG = [
     where: "driver/skills/placement-inquiry/SKILL.md:58-66",
     surface: "skill-file",
     evidence: "**2. The structured mirror** `…/placements.json` … `{\"schema_version\":1,\"placements\":[...]}`, ONE object per placed candidate, keys EXACTLY `{\"mark\",\"owner\",\"jurisdiction\",\"records\",\"tier\",\"reason\"}` plus the optional `\"borderline\"` … `tier` — EXACTLY one of `headline-candidate` / `sheet-2` / `watch",
-    reparsedBy: "driver/placement-model.mjs. AND IT IS STALE: #562 made placements.json driver-rendered, and stages.mjs:2373 says \"DO NOT WRITE placements.json (the driver renders it from this form)\" — the skill file the stage is ordered to \"read and follow exactly\" dictates the key set of a file the message forbids it to write. Two contracts in one dispatch",
+    reparsedBy: "driver/placement-model.mjs. AND IT IS STALE: #562 made placements.json driver-rendered, and stages.mjs:2416 says \"DO NOT WRITE placements.json (the driver renders it from this form)\" — the skill file the stage is ordered to \"read and follow exactly\" dictates the key set of a file the message forbids it to write. Two contracts in one dispatch",
     removedByMove: "NOTHING ON THE #850 PLAN REMOVES THIS",
   },
   {
@@ -346,7 +346,7 @@ export const E3_BACKLOG = [
     // (coverage-form.mjs coverageFormBrief) and the tool schema, with every row receiver-validated at
     // call time. Same dictated vocabulary, same authored site, new route — this row's evidence follows
     // the dictation so the row keeps describing something that exists.
-    where: "driver/stages.mjs:2622 (the digest message) + driver/coverage-form.mjs (coverageFormBrief — the dispatch block carrying the enum and the row shape)",
+    where: "driver/stages.mjs:2629 (the digest message) + driver/coverage-form.mjs (coverageFormBrief — the dispatch block carrying the enum and the row shape)",
     surface: "stage-message",
     evidence: "Record a \"status\" and a \"reason\" on EVERY row ONLY by calling the … tool — the driver validates each row as it arrives, holds the record itself, and renders both the ## Coverage ledger table and the coverage JSON from it",
     reparsedBy: "driver/coverage-call.mjs validateCoverageCall (receiver-validated at call time, the same predicates the gate judges with) + driver/coverage-form.mjs rowIsSettled via validators.registerFindings over the _driver/ accumulator",
@@ -401,16 +401,16 @@ export const E3_BACKLOG = [
     // values, receiver-validated as they arrive.
     where: "driver/skills/clearance-register/digest.md:216-218",
     surface: "skill-file",
-    evidence: "- `status` — EXACTLY one bare token: `confirmed-clean` / `coverage-limited` / `deferred`. Qualifiers never go in the status; they go in the reason.",
+    evidence: "- `status` — EXACTLY one bare token: `confirmed-clean` / `coverage-limited` / `deferred` / `withheld-by-judgment`. Qualifiers never go in the status; they go in the reason.",
     reparsedBy: "driver/coverage-call.mjs validateCoverageCall (status_invalid at call time) + driver/coverage-form.mjs rowIsSettled via validators.registerFindings; the archived-era prose-table reader (coverage-ledger.mjs parseCoverageLedgerFull) survives for replay only",
     removedByMove: "M6 LANDED and removed the no-form arm this row originally described (both sites). The surviving status-vocabulary dictation (as a typed call) is removed by NOTHING on the #850 plan",
   },
   {
     stage: "register-digest",
     kind: "exactly-these-keys",
-    where: "driver/skills/clearance-register/SKILL.md:198-199",
+    where: "driver/skills/clearance-register/SKILL.md:237-238",
     surface: "skill-file",
-    evidence: "**The status vocabulary is CLOSED: EXACTLY one bare token of: `confirmed-clean` / `coverage-limited` / `deferred`.** Qualifiers never go in a status cell; they go in the reason.",
+    evidence: "**The status vocabulary is CLOSED: EXACTLY one bare token of: `confirmed-clean` / `coverage-limited` / `deferred` / `withheld-by-judgment`.** Qualifiers never go in a status cell; they go in the reason.",
     reparsedBy: "driver/coverage-form.mjs / driver/coverage-ledger.mjs. Since the typed-transport conversion the STAGE MESSAGE no longer restates the enum; the surviving copies are SKILL.md (here), digest.md:207, the dispatch brief (coverage-form.mjs coverageFormBrief), the record_coverage schema (coverage-server.mjs) and gateway.mjs's repair hints — still one enum spelled at five sites",
     removedByMove: "NOTHING ON THE #850 PLAN REMOVES THIS",
   },
@@ -429,7 +429,7 @@ export const E3_BACKLOG = [
   {
     stage: "frame-diff",
     kind: "exactly-these-keys",
-    where: "driver/stages.mjs:2802",
+    where: "driver/stages.mjs:2809",
     surface: "stage-message",
     evidence: "For each blind-model variant / field / source the run did NOT scope or search, emit one directive {layer, item, observation, severity} … severity = dominant-element (the omission is ON the spine) | material (a real omission worth a targeted sweep) | minor (already covered, or presentation only).",
     reparsedBy: "driver/verify.mjs validators.frameDiff + driver/pipeline.mjs runSupplementalSweeps (the parser REFUSES a firing variant directive that dictates nothing dispatchable)",
@@ -447,13 +447,13 @@ export const E3_BACKLOG = [
     where: "driver/skills/frame-diff/SKILL.md:44-48",
     surface: "skill-file",
     evidence: "A directive may carry a structured `remedy`:\\n```json\\n\"remedy\": { \"terms\": [\"TROPICAL TIKI\", \"ISLAND TIKI\"], \"nice_classes\": [\"5\", \"32\"], \"regions\": [] }\\n```",
-    reparsedBy: "driver/pipeline.mjs runSupplementalSweeps — the remedy lint refuses a label-shaped term; stages.mjs:2788 restates the same shape in the message (\"THE ASK CONTRACT, stated at BOTH levels\")",
+    reparsedBy: "driver/pipeline.mjs runSupplementalSweeps — the remedy lint refuses a label-shaped term; stages.mjs:2809 restates the same shape in the message (\"THE ASK CONTRACT, stated at BOTH levels\")",
     removedByMove: "NOTHING ON THE #850 PLAN REMOVES THIS",
   },
   {
     stage: "synthesis",
     kind: "literal-json-skeleton",
-    where: "driver/stages.mjs:3182",
+    where: "driver/stages.mjs:3189",
     surface: "stage-message",
     evidence: "MACHINE FINDINGS (MANDATORY): … a JSON OBJECT {\"schema_version\":<FINDINGS_SCHEMA_VERSION>,\"rated_under_framework\":\"…\",\"findings\":[...],\"coverage\":[...],\"context_notes\":[...],\"actions\":[...],\"ask_answers\":[...]} … Each finding object has EXACTLY these keys: {\"ordinal\",\"mark\",\"owner\",\"band\",\"net\",\"bor",
     reparsedBy: "driver/findings-model.mjs:844 parseFindingsJson via validators.narrative",
@@ -467,7 +467,7 @@ export const E3_BACKLOG = [
   {
     stage: "synthesis",
     kind: "exactly-these-keys",
-    where: "driver/stages.mjs:3218",
+    where: "driver/stages.mjs:3226",
     surface: "stage-message",
     evidence: "- off_field_ground (MANDATORY on every off-field finding, FORBIDDEN on every other disposition): EXACTLY one bare token of: ${OFF_FIELD_GROUNDS.join(\" / \")}",
     reparsedBy: "driver/findings-model.mjs validateOffFieldGround — the enum is imported from findings-model.mjs and interpolated back into the prompt, so code already holds the list it asks the model to type",
@@ -476,7 +476,7 @@ export const E3_BACKLOG = [
   {
     stage: "synthesis",
     kind: "literal-json-skeleton",
-    where: "driver/stages.mjs:3219",
+    where: "driver/stages.mjs:3226",
     surface: "stage-message",
     evidence: "- manageable …: {\"category\":\"<EXACTLY one of large-competitor / commercial-partner / troll / well-known-enforcer>\",\"reason\":\"<one-two lines…>\"}",
     reparsedBy: "driver/findings-model.mjs:844 parseFindingsJson",
@@ -485,7 +485,7 @@ export const E3_BACKLOG = [
   {
     stage: "synthesis",
     kind: "literal-json-skeleton",
-    where: "driver/stages.mjs:3235",
+    where: "driver/stages.mjs:3243",
     surface: "stage-message",
     evidence: "- meters: {\"mark_similarity\":{...},\"goods_proximity\":{...},\"use\":{...},\"enforcer\":{...}} — all four present, each {\"token\",\"basis\",\"source\"}. … mark_similarity = high | medium | low. goods_proximity = high | medium | low. enforcer = high | medium | low | unknown. use = confirmed | not-confirmed | un",
     reparsedBy: "driver/findings-model.mjs:844 parseFindingsJson; driver/verify.mjs:1171 checkFindingsSibling gates meters.*.source; finding_basis_source_missing",
@@ -494,7 +494,7 @@ export const E3_BACKLOG = [
   {
     stage: "synthesis",
     kind: "literal-json-skeleton",
-    where: "driver/stages.mjs:3236",
+    where: "driver/stages.mjs:3243",
     surface: "stage-message",
     evidence: "- quadrant: {\"x\",\"y\"} numbers in [0,1]. x = goods/services proximity (0 = distant, 1 = identical). y = mark similarity (0 = distinct, 1 = identical).",
     reparsedBy: "driver/findings-model.mjs:844 parseFindingsJson",
@@ -503,7 +503,7 @@ export const E3_BACKLOG = [
   {
     stage: "synthesis",
     kind: "literal-json-skeleton",
-    where: "driver/stages.mjs:3237",
+    where: "driver/stages.mjs:3245",
     surface: "stage-message",
     evidence: "- source: {\"source_type\",\"resolved_link\"}. source_type EXACTLY one of: register-vendor / register-euipo / common-law-marketplace / common-law-web / case-law",
     reparsedBy: "driver/findings-model.mjs:844 parseFindingsJson",
@@ -512,7 +512,7 @@ export const E3_BACKLOG = [
   {
     stage: "synthesis",
     kind: "exactly-these-keys",
-    where: "driver/stages.mjs:3238",
+    where: "driver/stages.mjs:3245",
     surface: "stage-message",
     evidence: "coverage[]: ONE object per coverage AREA, EXACTLY {\"area\",\"state\",\"note\"}. … state EXACTLY one of: confirmed-clean / coverage-limited / open / not-searched / note.",
     reparsedBy: "driver/findings-model.mjs:844 parseFindingsJson; the render owns the coverage panel from these typed states",
@@ -521,7 +521,7 @@ export const E3_BACKLOG = [
   {
     stage: "synthesis",
     kind: "literal-json-skeleton",
-    where: "driver/stages.mjs:3247",
+    where: "driver/stages.mjs:3254",
     surface: "stage-message",
     evidence: "use_check = {\"source\",\"quality\"}: … quality: OPTIONAL, EXACTLY one of owner-site / independent / register-mirror … own_rights = {\"source\"}",
     reparsedBy: "driver/verify.mjs:988 checkFindingsSibling (finding_use_check_missing); driver/own-rights.mjs:19-22",
@@ -530,7 +530,7 @@ export const E3_BACKLOG = [
   {
     stage: "synthesis",
     kind: "literal-json-skeleton",
-    where: "driver/stages.mjs:3304",
+    where: "driver/stages.mjs:3311",
     surface: "stage-message",
     evidence: "MARK ASSESSMENT … STRUCTURED FORM …: either field may instead be an OBJECT {\"read\":\"…\",\"spectrum\":\"…\",\"per_class\":[{\"class\":\"5\",\"note\":\"…\"}],\"per_market\":[{\"market\":\"CN\",\"note\":\"…\"}],\"counter_registrations\":[{\"mark\":\"…\",\"uri\":\"/mark/…\",\"note\":\"…\"}],\"acquired\":\"<optional>\",\"note\":\"<optional residual>",
     reparsedBy: "driver/findings-model.mjs:844 parseFindingsJson; the report collapses the rows behind toggles and the audit workbook renders them",
@@ -539,7 +539,7 @@ export const E3_BACKLOG = [
   {
     stage: "synthesis",
     kind: "literal-json-skeleton",
-    where: "driver/stages.mjs:3310",
+    where: "driver/stages.mjs:3317",
     surface: "stage-message",
     evidence: "FOUR ANSWERS …: \"four_answers\": {\"third_party_rights\":{...},\"objection_likelihood\":{...},\"registrability\":{...},\"client_enforceability\":{...}} … Each answer … is {\"read\":\"…\",\"token\":\"…\",\"basis\":\"…\",\"ordinals\":[…]}. Tokens (closed enums …): third_party_rights = strong|moderate|weak; objection_likelih",
     reparsedBy: "driver/findings-model.mjs:844 parseFindingsJson",
@@ -557,7 +557,7 @@ export const E3_BACKLOG = [
   {
     stage: "synthesis",
     kind: "exactly-these-keys",
-    where: "driver/stages.mjs:3317",
+    where: "driver/stages.mjs:3324",
     surface: "stage-message",
     evidence: "COVERAGE JUDGMENT …: emit \"coverage_judgment\": {\"sufficient\":<bool>, \"reason\":\"<one line…>\"} — EXACTLY those two keys. Do NOT emit \"rows\": the driver writes that register itself … anything you type there is replaced wholesale.",
     reparsedBy: "driver/findings-model.mjs:844 parseFindingsJson. The \"Do NOT emit rows\" clause is the purest E3 case in the tree — the prompt names a field, dictates its shape and states in the same breath that code overwrites it",
@@ -566,7 +566,7 @@ export const E3_BACKLOG = [
   {
     stage: "synthesis",
     kind: "literal-json-skeleton",
-    where: "driver/stages.mjs:3160",
+    where: "driver/stages.mjs:3167",
     surface: "stage-message",
     // RE-QUOTED, NOT PARKED. The writer's conversion reworded this dictation — the
     // ask answers ride the findings RECORD now and the driver renders the labelled line into both the
@@ -590,7 +590,7 @@ export const E3_BACKLOG = [
   {
     stage: "synthesis",
     kind: "dictated-line-shape",
-    where: "driver/stages.mjs:3081 (restated at driver/skills/clearance-search/synthesis-rules.md:428)",
+    where: "driver/stages.mjs:3088 (restated at driver/skills/clearance-search/synthesis-rules.md:428)",
     surface: "stage-message",
     evidence: "END that finding's actual-use line with a literal \"- **Use-check source:** <result URL | \"perplexity_research — no result\">\" line",
     reparsedBy: "driver/verify.mjs validators.narrative (spec-11 hard reject); the repair hint re-dictates the literal at driver/gateway.mjs:2153",
@@ -599,7 +599,7 @@ export const E3_BACKLOG = [
   {
     stage: "synthesis",
     kind: "dictated-line-shape",
-    where: "driver/stages.mjs:3094 (restated at driver/skills/clearance-search/synthesis-rules.md:475)",
+    where: "driver/stages.mjs:3101 (restated at driver/skills/clearance-search/synthesis-rules.md:475)",
     surface: "stage-message",
     evidence: "END that finding's reasoning with a literal \"- **Own-rights source:** <record URI(s) | \"no applicant-owned registrations in the searched register material\">\" line",
     reparsedBy: "driver/own-rights.mjs:19-22 — \"This module only requires the 'Own-rights source:' line to exist\"; repair hint at driver/gateway.mjs:2361 (the `own_rights_missing` branch; re-verified 2026-08-29 — the old :1736 predated this branch and pointed into the A4 repeat-signature block)",
@@ -608,7 +608,7 @@ export const E3_BACKLOG = [
   {
     stage: "synthesis",
     kind: "exactly-these-keys",
-    where: "driver/stages.mjs:3296",
+    where: "driver/stages.mjs:3303",
     surface: "stage-message",
     evidence: "add it to the top-level \"context_notes\" array — each object EXACTLY {\"type\":\"famous-neighbour-ungrounded\",\"mark\",\"owner\",\"context\"}",
     reparsedBy: "driver/findings-model.mjs:844 parseFindingsJson",
@@ -617,7 +617,7 @@ export const E3_BACKLOG = [
   {
     stage: "synthesis",
     kind: "literal-json-skeleton",
-    where: "driver/stages.mjs:3184",
+    where: "driver/stages.mjs:3191",
     surface: "stage-message",
     evidence: "- owner: {\"name\",\"country\",\"registrations\":[...]}. … Each registration: {\"uri\", optionally \"classes\":[\"9\",\"41\"],\"status\",\"filed\",\"expiry\",\"jurisdiction\"}. The \"uri\" is the ONLY field that matters: the driver BINDS classes/status/filed/expiry/jurisdiction AND the owner name from the FETCHED record ke",
     reparsedBy: "driver/findings-model.mjs:844 parseFindingsJson + the record-binding join. Six of the seven keys are stated in the prompt and overwritten by code in the same sentence",
@@ -626,7 +626,7 @@ export const E3_BACKLOG = [
   {
     stage: "case-law",
     kind: "literal-json-skeleton",
-    where: "driver/stages.mjs:3466",
+    where: "driver/stages.mjs:3473",
     surface: "stage-message",
     evidence: "ALSO write the RETRIEVAL RECORD to <path> — a JSON OBJECT with EXACTLY these keys: {\"schema_version\":1,\"queries\":[{\"query\":\"<the search you dispatched, verbatim>\",\"jurisdiction\":\"…\",\"results\":<how many hits it returned>}, …],\"citations\":[{\"proceeding\":\"…\",\"forum\":\"…\",\"jurisdiction\":\"…\",\"decided\":\"…\"",
     reparsedBy: "driver/verify.mjs validators.caseLaw — the ledger arm, armed by the stage-contract marker `citations` (stages.mjs:1820)",
@@ -635,7 +635,7 @@ export const E3_BACKLOG = [
   {
     stage: "case-law",
     kind: "dictated-line-shape",
-    where: "driver/stages.mjs:3474",
+    where: "driver/stages.mjs:3481",
     surface: "stage-message",
     evidence: "EVERY \"Grounded profile\" section MUST start its body with the line \"- ord: <N>\" naming which finding it grounds (use the ordinal from this list; a profile that grounds no listed finding omits the line)",
     reparsedBy: "driver/publish/parse.mjs:339, parseCaseLawProfiles() in parse.mjs (\"the optional '- ord: <N>' first body line … gives an EXACT join\"); driver/findings-model.mjs:273 /^-\\s*ord:\\s*(\\d+)\\s*$/m; driver/publish/index.mjs:778 runOrigins",
@@ -669,7 +669,7 @@ export const E3_BACKLOG = [
   {
     stage: "narrative-refutation",
     kind: "dictated-line-shape",
-    where: "driver/stages.mjs:3606",
+    where: "driver/stages.mjs:3613",
     surface: "stage-message",
     // RE-QUOTED BY CONVERSION 9. The LINE-TOKEN half is gone — no "anywhere on the line", no "[kind: …]
     // token", no "a line with no token is treated as fact", because a kind is a typed field now and an
@@ -768,7 +768,7 @@ export const E3_BACKLOG = [
   {
     stage: "report-card",
     kind: "literal-json-skeleton",
-    where: "driver/stages.mjs:3915",
+    where: "driver/stages.mjs:3922",
     surface: "stage-message",
     evidence: "The finding's OWN record — the ONLY source for this card …:\\n```json\\n<JSON.stringify(finding, null, 2)>\\n```",
     reparsedBy: "none — this is the INPUT side, and that is why it belongs in the survey: a full JSON object rendered into the prompt is exactly the mechanism #850 proves produced R-RECEIPT (the model pattern-matches a shown shape). E3's clause 1 as written (\"a code fence or inline example showing the exact object shape the model must emit\") does not reach an injected record, so the lint needs an explicit rule for shown-but-not-owed structure",
@@ -879,7 +879,7 @@ export const E3_EVIDENCE_UNRESOLVED = [
  * multi-witness rows were settled by the site their anchor resolves at (narrative-refutation to its
  * SKILL.md, two synthesis rows to stages.mjs). Two were decided by reading the delivering call site:
  * common-law-half is `tool-response` (perplexity-server.mjs:111), register-digest is `stage-message`
- * (pipeline.mjs:3553 appends coverageFormBrief to the dispatch).
+ * (pipeline.mjs, where coverageFormBrief is appended to the dispatch).
  */
 // 35 -> 32 stage-message. The three rows that left were the send stages' dictated line shapes
 // — `notify`'s verbatim-HTML instruction and the two chat pings' EXACTLY-this-text lines. They were not

package/driver/contract-vocabulary.mjs

@@ -21,7 +21,7 @@
 //   D4 verify.mjs  parseCoverageLedgerJson, same shape
 //   D5 verify.mjs:1504  fail(`${unaccounted[0].token}:…`)    — token minted in a DATA ROW
 //   D6 verify.mjs:1567  fail(`${violations[0].token}…`)      — validatePlanFeasibility in register-plan.mjs
-//   D7 verify.mjs:1558  fail(`${v2[0].token}${detail}…`)     — register-plan.mjs:2424 disclosureTextByAxis
+//   D7 verify.mjs:1558  fail(`${v2[0].token}${detail}…`)     — register-plan.mjs disclosureTextByAxis
 //   D8 verify.mjs:2470 caseLawLedgerFail  fail(caseLawLedgerFail(…))  — token built in case-law-ledger.mjs:195 caseLawLedgerFail
 //
 // A partition built on the 60 tokens a regex CAN see would run green while blind to the rest, which is
@@ -139,10 +139,10 @@ export const VOCABULARY = [
   { token: "coverage_form_missing", stages: ["register-digest"], site: "driver/verify.mjs" },
   { token: "coverage_form_empty", stages: ["register-digest"], site: "driver/verify.mjs" },
   { token: "coverage_status_offenum", stages: ["register-digest"], site: "driver/verify.mjs:2050" },
-  { token: "coverage_deferred_unaccounted", stages: ["register-digest"], site: "driver/verify.mjs coverageFormFail", family: "driver/register-plan.mjs:2101 PROVIDER_HARD_ERROR_PREFIX — token on a data row", dynamic: "D5" },
-  { token: "coverage_clean_unexecuted", stages: ["register-digest"], site: "driver/verify.mjs, the matterContext validator", family: "driver/register-plan.mjs:1835 validatePlanFeasibility", dynamic: "D6" },
-  { token: "coverage_clean_skipped", stages: ["register-digest"], site: "driver/verify.mjs, the matterContext validator", family: "driver/register-plan.mjs:2196 searchedJurisdictionsFromPlan", dynamic: "D6" },
-  { token: "coverage_clean_unverified_incomplete", stages: ["register-digest"], site: "driver/verify.mjs, the matterContext validator", family: "driver/register-plan.mjs:2424 disclosureTextByAxis", dynamic: "D7" },
+  { token: "coverage_deferred_unaccounted", stages: ["register-digest"], site: "driver/verify.mjs coverageFormFail", family: "driver/register-plan.mjs PROVIDER_HARD_ERROR_PREFIX — token on a data row", dynamic: "D5" },
+  { token: "coverage_clean_unexecuted", stages: ["register-digest"], site: "driver/verify.mjs, the matterContext validator", family: "driver/register-plan.mjs validatePlanFeasibility", dynamic: "D6" },
+  { token: "coverage_clean_skipped", stages: ["register-digest"], site: "driver/verify.mjs, the matterContext validator", family: "driver/register-plan.mjs searchedJurisdictionsFromPlan", dynamic: "D6" },
+  { token: "coverage_clean_unverified_incomplete", stages: ["register-digest"], site: "driver/verify.mjs, the matterContext validator", family: "driver/register-plan.mjs disclosureTextByAxis", dynamic: "D7" },
   { token: "coverage_clean_tainted", stages: ["register-digest"], site: "driver/verify.mjs" },
   { token: "coverage_ledger_", stages: ["register-digest"], site: "driver/verify.mjs", family: "driver/coverage-ledger.mjs (parseCoverageLedgerJson token-first throws)", dynamic: "D4" },
   { token: "coverage_key_unknown", stages: ["register-digest"], site: "driver/verify.mjs", family: "driver/coverage-ledger.mjs", dynamic: "D4" },
@@ -509,9 +509,9 @@ export const INNER_CODES = Object.freeze([
   // ONE CODE, TWO TOKENS, and the split is by `cause` rather than by code: verify.mjs peels the
   // `axis_invalid` cause into its own family before counting the rest. A ruling naming only
   // `coverage_no_status` would be true of most `no_status` records and false of the ones that matter most.
-  { code: "no_status", mints: ["driver/coverage-form.mjs:836"], rollsUpTo: ["coverage_no_status", "coverage_form_axis_invalid"],
+  { code: "no_status", mints: ["driver/coverage-form.mjs:856"], rollsUpTo: ["coverage_no_status", "coverage_form_axis_invalid"],
     why: "Two composites, split on the record's `cause`: `checkFindingsSibling()` in verify.mjs for cause `axis_invalid`, `dispositionForm()` there for the rest. NOT the `@returns` annotation above `COVERAGE_CAUSES` in coverage-form.mjs — that is the annotation, not the mint." },
-  { code: "engine_vocabulary", mints: ["driver/coverage-form.mjs:826"], rollsUpTo: ["coverage_form_engine_vocabulary"],
+  { code: "engine_vocabulary", mints: ["driver/coverage-form.mjs:846"], rollsUpTo: ["coverage_form_engine_vocabulary"],
     why: "#669 — the seat wrote an engine token into the `reason` sentence that reaches the reader's page. Checked on settled rows too, because a row the seat considers finished is exactly the one whose sentence gets printed. Namespaced at verify.mjs:1165; the bare code names a row, never a stage." },
 
   // ── ONE CODE, TWO MODULES ────────────────────────────────────────────────────────────────────────
@@ -522,7 +522,7 @@ export const INNER_CODES = Object.freeze([
   // the census output would have been half a ruling. verify.mjs:1075 already states the rule this row
   // records: `coverage_form_damaged`, never a bare `form_damaged`.
   { code: "form_damaged",
-    mints: ["driver/connotation-search.mjs:2075", "driver/connotation-search.mjs:2151", "driver/coverage-form.mjs:818"],
+    mints: ["driver/connotation-search.mjs:2075", "driver/connotation-search.mjs:2151", "driver/coverage-form.mjs:838"],
     rollsUpTo: ["connotation_form_damaged", "coverage_form_damaged"],
     why: "Minted in two lanes and namespaced per lane: verify.mjs:1019 for the meaning sweep, verify.mjs:1119 for the register digest. The namespacing is what keeps them apart — see verify.mjs:1075." },
 ]);

package/driver/coverage-form-io.mjs

@@ -31,6 +31,7 @@ import { driverDir } from "../shared/driver-dir.mjs";   //
 import { COVERAGE_STATUSES, COVERAGE_FORM_NAME, REGISTER_AXES } from "./coverage-ledger.mjs";
 import { coverageFormSidecarName, parseCoverageForm } from "./coverage-form.mjs";
 import { capabilitiesFor } from "./register-capabilities.mjs";
+import { readWithheldFamilies } from "./withheld-families.mjs";
 
 export { COVERAGE_FORM_NAME };
 
@@ -147,7 +148,8 @@ export function coverageFormInput(runDir) {
   catch { capabilities = null; }   // an unknown provider id reads as unestablished, which discloses
   const orderedTerritories = Array.isArray(plan.ordered_jurisdictions) ? plan.ordered_jurisdictions : [];
   return { input: { skeleton: exec.skeleton, plan, bandBlocksByAxis, deferredReasons, activeAxes,
-    bandsUnreadable, orderedTerritories, capabilities, unknownAxisUnits }, absent: null };
+    bandsUnreadable, orderedTerritories, capabilities, unknownAxisUnits,
+    awaiting: Array.isArray(exec.awaiting) ? exec.awaiting : [], withheld: readWithheldFamilies(runDir) }, absent: null };
 }
 
 /**

package/driver/coverage-form.mjs

@@ -32,10 +32,10 @@ import { REGISTER_AXES, COVERAGE_STATUSES, normalizeAxis, CROWD_RULING_TOKEN,
   CROWD_RULING_UNIT_GRAMMAR } from "./coverage-ledger.mjs";
 import { shortId } from "./connotation-search.mjs";
 import { openBlocksByAxis } from "./register-plan.mjs";
-import { territoryLayerReport, unsearchedLayerReason } from "./binding-layers.mjs";
+import { territoryLayerReport, unsearchedLayerReason } from "./binding-layers.mjs"; import { goodsTermsList } from "../providers/_shared/term-shape.mjs";
 
 const STATUS_SET = new Set(COVERAGE_STATUSES);
-const DRIVER_KINDS = new Set(["axis", "block", "deferred"]);
+const DRIVER_KINDS = new Set(["axis", "block", "deferred", "family"]);
 
 // ── SEAT ROWS — WHAT THE FORM DOES NOT TAKE AWAY ────────────────────────────────────────────────────
 //
@@ -238,7 +238,7 @@ export function seatRows(rows, driverKeys) {
 }
 
 // The coverage unit label, composed by the machine from the plan entry it is about — never a string the
-// seat invents and never one it has to reproduce. `<axis> / <predicate>: <term(s)> [cl <classes>]`, the
+// seat invents and never one it has to reproduce. `<axis> / <predicate>: <term(s)> [cl <classes>] goods: <words>`, the
 // same left-of-slash-is-the-axis shape every downstream coverage consumer keys on (coverage-ledger.mjs
 // normalizeAxis, scope-facts, the taint join). Terms are bounded so an OR-stack of forty cannot make one
 // table cell unreadable; the qid rides its own column, so nothing identifying is lost to the cut.
@@ -256,7 +256,7 @@ function unitLabel(axis, entry) {
     String(entry.predicate ?? "").trim(),
     shown.length ? `${shown.join(" OR ")}${more}` : "",
   ].filter(Boolean).join(": ");
-  return `${axis} / ${scope || String(entry.qid ?? "")}${cls}`;
+  return `${axis} / ${scope || String(entry.qid ?? "")}${cls}${goodsTermsList(entry).length ? ` goods: ${goodsTermsList(entry).join(" OR ")}` : ""}`;   // the goods words are part of the question (ruled for the client's table 2026-09-22): a goods slice shares predicate, term and classes with the identical one
 }
 
 /**
@@ -304,7 +304,7 @@ function unitLabel(axis, entry) {
  */
 export function coverageFormRows({ skeleton = [], activeAxes = null, plan = null,
   bandBlocksByAxis = {}, deferredReasons = {}, bandsUnreadable = [],
-  orderedTerritories = [], capabilities = null } = {}) {
+  orderedTerritories = [], capabilities = null, awaiting = [], withheld = {} } = {}) {
   const skel = Array.isArray(skeleton) ? skeleton.filter((s) => s && typeof s === "object") : [];
   const entriesByQid = new Map((plan?.entries ?? []).map((e) => [e.qid, e]));
   const open = openBlocksByAxis(skel, bandBlocksByAxis, plan);
@@ -376,6 +376,26 @@ export function coverageFormRows({ skeleton = [], activeAxes = null, plan = null
         status: null, reason: null,
       });
     }
+    // ── A WAITING FAMILY THE READING TURN DID NOT ASK (withheld-families.mjs) ─────────────────────
+    //
+    // It was never searched, and the one honest judgment of it is the turn's: withheld, with the reason
+    // it was not asked. The row arrives settled when the turn recorded that, and open when nobody did,
+    // so an unjudged family is an obligation the digest's gate refuses to pass. `family` rows stay out of
+    // the ledger the report is built from; the reason is the run's record and the audit workbook's.
+    for (const f of (Array.isArray(awaiting) ? awaiting : [])) {
+      const qid = String(f?.qid ?? "").trim();
+      if (!qid || String(f?.axis ?? "").trim() !== axis) continue;
+      const w = withheld?.[qid];
+      rows.push({
+        row_id: shortId("CF", `family:${qid}`),
+        axis, kind: "family",
+        unit: unitLabel(axis, entriesByQid.get(qid)),
+        qid,
+        open: true,
+        open_because: "a waiting family the reading turn did not ask — it was never searched, and its only judgment is withheld-by-judgment with the reason it was not asked",
+        status: w?.reason ? "withheld-by-judgment" : null, reason: w?.reason ? String(w.reason) : null,
+      });
+    }
     // ── AN OFFICE THIS DEPLOYMENT COULD NOT REACH ────────────────────────────────────────
     //
     // The one deferral shape that arrives WITHOUT A QID, which is why every row above missed it.
@@ -681,14 +701,14 @@ export function rowIsSettled(row, canonical) {
   // qid and blockIsDisclosed' qid-or-hit-count — because the driver's own row for that obligation IS the
   // naming, so requiring THAT row to be non-clean asks for precisely what "named by a non-clean row on
   // its own axis" asked for. Per row, never per axis: a sibling row's status discharges nothing.
-  if (canonical.open === true && status === "confirmed-clean") return false;
+  if (canonical.open === true && status === "confirmed-clean") return false; if (canonical.kind === "family" && status !== "withheld-by-judgment") return false;   // a waiting family never ran: withheld is its only judgment
   return true;
 }
 
 /** The settled rows of a form, in the shape every coverage consumer reads: {axis, status, unit, reason}. */
 export function formLedgerRows(rows) {
   return (rows ?? [])
-    .filter((r) => r && STATUS_SET.has(String(r.status ?? "").trim().toLowerCase()))
+    .filter((r) => r && r.kind !== "family" && STATUS_SET.has(String(r.status ?? "").trim().toLowerCase()))
     .map((r) => ({
       axis: String(r.axis ?? "").trim().toLowerCase(),
       status: String(r.status).trim().toLowerCase(),
@@ -860,7 +880,7 @@ const cell = (s) => String(s ?? "").replace(/\\/g, "\\\\").replace(/\|/g, "\\|")
 
 /** The `## Coverage ledger` section, rendered from the form's rows. "" when nothing is settled. PURE. */
 export function renderCoverageLedgerSection(rows) {
-  const usable = (rows ?? []).filter((r) => r && STATUS_SET.has(String(r.status ?? "").trim().toLowerCase()));
+  const usable = (rows ?? []).filter((r) => r && r.kind !== "family" && STATUS_SET.has(String(r.status ?? "").trim().toLowerCase()));
   if (!usable.length) return "";
   return [
     "## Coverage ledger",
@@ -936,7 +956,7 @@ export function spliceCoverageLedger(md, section) {
  * @returns {string} a JSON ARRAY string that round-trips through parseCoverageLedgerJson
  */
 export function renderCoverageLedgerJsonFromForm(rows, classTokens) {
-  const usable = (rows ?? []).filter((r) => r && STATUS_SET.has(String(r.status ?? "").trim().toLowerCase()));
+  const usable = (rows ?? []).filter((r) => r && r.kind !== "family" && STATUS_SET.has(String(r.status ?? "").trim().toLowerCase()));
   return JSON.stringify(usable.map((r) => {
     const unit = String(r.unit ?? r.axis ?? "");
     const i = unit.indexOf("/");
@@ -995,19 +1015,26 @@ export function coverageFormBrief(form) {
     "row as it arrives, holds the record itself, and renders the table and the coverage JSON from it —",
     "nothing you write into any file is read.",
     "",
-    `There are ${rows.length} row(s) — one per axis, one per unaccounted crowd block, one per deferred slice —`,
+    `There are ${rows.length} row(s) — one per axis, one per unaccounted crowd block, one per deferred slice, one per waiting family the reading turn did not ask —`,
     "and every identifier is computed: the coverage unit, the query id, the hit count, the unaccounted",
     "classes and terms, and each deferred slice's own receipt reason. This is the complete list: nothing is",
     "abbreviated, truncated or elided, and there is nothing owed that is not a row below.",
     "",
     "For EVERY row, call `record_coverage` with `row_id` (as listed), `status` — exactly one bare token of",
-    "confirmed-clean / coverage-limited / deferred — and `reason`, the sentence the lawyer reads: a",
+    "confirmed-clean / coverage-limited / deferred / withheld-by-judgment — and `reason`, the sentence the lawyer reads: a",
     "lawyer's words, never the engine's (a reason naming primary-sweep, saturation-probe,",
     "transliteration-numeric, incumbent-class or crowd-context is REFUSED, because the coverage unit",
     "already carries the identifier and your sentence is printed on the client's report). A call carries a",
     "batch; refused rows name what to change and the rest of the call is KEPT; statuses accumulate across",
     "attempts, so a row settled once stays settled. The answer lists every obligation still outstanding.",
     "",
+    ...(rows.some((r) => r.kind === "family") ? [
+      "A `family` row is a waiting family the reading turn did not ask. It was never searched, so its only",
+      "status is withheld-by-judgment. Most arrive settled with the reading turn's reason; for any that did",
+      "not, record withheld-by-judgment and why it was not asked. That reason goes into the audit workbook, not",
+      "the report.",
+      "",
+    ] : []),
     "THE ROWS:",
     ...rows.map(briefRow),
     "",

package/driver/coverage-ledger.mjs

@@ -72,7 +72,22 @@ export function coverageUnitLabel(unit) {
 // The closed status set. BARE tokens only — the prose table may carry suffixed statuses like
 // `coverage-limited (count-only, saturated)` (digest.md teaches one); in the JSON the qualifier
 // moves into `reason`, and the dictation block + correction hint both say so.
-export const COVERAGE_STATUSES = ["confirmed-clean", "coverage-limited", "deferred"];
+// ── `withheld-by-judgment` — A FAMILY NOBODY ASKED FOR, ON PURPOSE ───────────────────────────────
+//
+// The crowded-field doctrine tells the reading turn to stop widening once the readable list already
+// holds conflicts in the client's field: do not open scripts, neighbours, compounds or guessed owners
+// for this mark, and write which questions you did not ask and why. That is a DECISION, and it needs a
+// word of its own.
+//
+// It is not `confirmed-clean`: nobody searched it, and a clean over an unsearched family is the false
+// clean this ledger exists to make impossible. It is not `coverage-limited` either — that says the
+// engine tried and could not finish, which is a different fact and reads to a lawyer as a gap in the
+// work rather than a choice about where the work was best spent. And it is not `deferred`, which says
+// the provider could not express the question at all.
+//
+// So a fourth status, carrying the model's written reason. The clean-claim gates treat it exactly as
+// they treat the other two non-clean states: it can never stand in for a search.
+export const COVERAGE_STATUSES = ["confirmed-clean", "coverage-limited", "deferred", "withheld-by-judgment"];
 
 // — the seat-facing coverage form's file name, owned HERE with the rest of the coverage vocabulary
 // so the four places that need it (paths(), coverage-form-io, the gateway's repair routing and the
@@ -254,22 +269,37 @@ export const isCapabilityGapReason = (reason) => CAPABILITY_GAP_REASON_RE.test(S
  * @param capabilityGapAxes axes the plan-execution receipt says carry >=1 deterministic deferral
  * @param opts.fullyDeferred  the plan says EVERY entry on this axis is unsupported (fullyDeferredAxes) —
  *          then there is nothing on the axis a re-run could reach, whatever a row's prose says
+ * @param opts.heldUnits    ledgerUnitKey()s of rows this run already accepted as capability gaps (the
+ *          sticky set, matched through the coverage form's qid) — held whatever the seat wrote in the reason
  * @returns {{closeable: rows[], held: rows[]}} — `held` rows stay `deferred` and stay disclosed:
  *          the coverage floor keeps its right to hold on them (computeOpenFloors → envelope_note,
  *          the registerGap clamp stays armed). They are simply never re-run and never closed by time.
  * PURE.
  */
-export function splitDeferredByCloseability(rows, axis, capabilityGapAxes, { fullyDeferred = false } = {}) {
+export function splitDeferredByCloseability(rows, axis, capabilityGapAxes, { fullyDeferred = false, heldUnits = null } = {}) {
   const ax = String(axis ?? "").toLowerCase();
   const indicted = new Set([...(capabilityGapAxes ?? [])].map((a) => String(a).toLowerCase()));
   const owned = (rows ?? []).filter((r) => r && r.status === "deferred" && String(r.axis ?? "").toLowerCase() === ax);
   if (fullyDeferred) return { closeable: [], held: owned };
-  if (!indicted.has(ax)) return { closeable: owned, held: [] };
-  const held = owned.filter((r) => isCapabilityGapReason(r.reason));
-  const closeable = owned.filter((r) => !isCapabilityGapReason(r.reason));
-  return { closeable, held };
+  const sticky = (r) => Boolean(heldUnits?.has(ledgerUnitKey(r.axis, r.scope)));
+  if (!indicted.has(ax) && !owned.some(sticky)) return { closeable: owned, held: [] };
+  const isHeld = (r) => isCapabilityGapReason(r.reason) || sticky(r);
+  return { closeable: owned.filter((r) => !isHeld(r)), held: owned.filter(isHeld) };
 }
 
+/**
+ * One coverage unit's identity across the form and the ledger: its axis and its scope, the part of the
+ * form's `unit` after the first `/`, which is exactly what renderCoverageLedgerJsonFromForm writes as the
+ * ledger row's `scope`. Case and runs of whitespace do not distinguish two units. PURE.
+ */
+export const ledgerUnitKey = (axis, scope) =>
+  `${String(axis ?? "").trim().toLowerCase()}|${String(scope ?? "").replace(/\s+/g, " ").trim().toLowerCase()}`;
+export const formRowUnitKey = (r) => {
+  const unit = String(r?.unit ?? r?.axis ?? "");
+  const i = unit.indexOf("/");
+  return ledgerUnitKey(r?.axis, i >= 0 ? unit.slice(i + 1) : "");
+};
+
 // ── THE LEDGER AS A TABLE, WRITTEN ONCE ────────────────────────────────────────────────────────────
 //
 // Two dispatches hand a judgment seat the machine ledger as ROWS rather than as a path: the skeptic
@@ -403,7 +433,7 @@ export function parseCoverageLedgerFull(md) {
     // normalize-then-validate at the parse boundary (B): repair markdown/qualifier noise on the
     // left-of-slash axis; if that isn't a known token, scan the whole cell for a transposed axis.
     const axis = normalizeAxis(unit.split("/")[0], unit);
-    const m = cells[1].match(/coverage-limited|deferred|confirmed-clean/i);
+    const m = cells[1].match(/withheld-by-judgment|coverage-limited|deferred|confirmed-clean/i);
     if (!axis || !m) {
       if (axis && !m && REGISTER_AXES.includes(axis)) offEnum.push({ axis, unit, status: cells[1] });
       dropped.push(ln.trim().replace(/\s+/g, " ").slice(0, 120));

package/driver/coverage-union.mjs

@@ -102,10 +102,10 @@ export function unionCoverageForm(prior, submitted, input, { parkedIds = null }
   let settled = 0, carried = 0, parked = 0;
   for (const row of form.rows) {
     const p = findPrior(row), s = findSubmitted(row);
-    const sOk = s && rowIsSettled(s, row), pOk = p && rowIsSettled(p, row);
+    const sOk = s && rowIsSettled(s, row), pOk = p && rowIsSettled(p, row), dOk = rowIsSettled(row, row);
     let fields;
     if (sOk) fields = seatFields(s);
-    else if (pOk) fields = seatFields(p);
+    else if (pOk) fields = seatFields(p); else if (dOk) fields = seatFields(row);   // a judgment the driver row arrived with (a family the reading turn withheld)
     else {
       const sf = seatFields(s ?? {}), pf = seatFields(p ?? {});
       fields = { status: sf.status || pf.status, reason: sf.reason || pf.reason };