clearotron 0.4.1 → 0.5.0-beta.0

package/driver/record-carry.mjs

@@ -702,6 +702,61 @@ export function mintRecordCarryDoubts(artifact, { max = 25 } = {}) {
   return { doubts, minted: doubts.length, omitted: Math.max(0, all.length - doubts.length) };
 }
 
+/**
+ * THE RECORD-CARRY DOUBTS AGAIN, FROM A TRACE WRITTEN AGAIN after a repair. A doubt of this family names one record
+ * under a POSITIONAL id, and the closure step's verdicts are applied by id, so a closure recorded against an id must
+ * never move onto another record:
+ *   - a record still unreasoned keeps its doubt exactly as it stands: id, status and ending;
+ *   - a record newly unreasoned gets a new doubt, under an id past every one this family gave, stitched by `stitch` as
+ *     a fresh doubt is (in code; nothing is dispatched);
+ *   - a record the new trace POSITIVELY reasons, a row for it that is not unreasoned, loses its doubt;
+ *   - a record the new trace does not list at all keeps its doubt as it stands: an absence is not a ground.
+ * A trace that is missing or could not be computed (no readable band, among other causes) says nothing about any
+ * record, so it removes nothing and adds nothing: every doubt stands as the pass raised it (`unavailable: true`).
+ * Every other family's doubts stay exactly where they stood. The cap (`max`) limits only the new doubts: a record that
+ * keeps its doubt keeps it wherever the new trace lists it, or where it does not. Returns { doubts, fresh, dropped,
+ * minted, omitted, unavailable }: the ids of the new and the dropped doubts, the family's size, the records without a
+ * ground the cap left out, and whether the trace could be read at all. PURE.
+ */
+export function recordCarryDoubtsAgain(doubts, trace, { stitch = (ds) => ds, max = 25 } = {}) {
+  const FAMILY = /^doubt:record-carry:unreasoned:(\d+)$/;
+  const all = Array.isArray(doubts) ? doubts : [];
+  const inFamily = (d) => FAMILY.test(String(d?.id ?? ""));
+  const uriOf = (d) => String(d?.subject?.uris?.[0] ?? "").toLowerCase();
+  const old = all.filter(inFamily);
+  if (trace?.computable !== true) return { doubts: all, fresh: [], dropped: [], minted: old.length, omitted: 0, unavailable: true };
+  const oldByUri = new Map(old.filter((d) => uriOf(d)).map((d) => [uriOf(d), d]));
+  // Minted whole, then capped: a record that keeps its doubt keeps it wherever the new trace lists it, and the cap
+  // limits only the new doubts, filled in the trace's order up to what the kept ones leave.
+  const mint = mintRecordCarryDoubts(trace, { max: Infinity });
+  const unreasonedUris = new Set(mint.doubts.map(uriOf));
+  const listed = new Set((Array.isArray(trace?.rows) ? trace.rows : []).map((r) => String(r?.uri ?? "").toLowerCase()).filter(Boolean));
+  const reasoned = (uri) => listed.has(uri) && !unreasonedUris.has(uri);
+  const carried = old.filter((d) => !unreasonedUris.has(uriOf(d)) && !reasoned(uriOf(d)));   // not listed: kept as it stands
+  const keptCount = mint.doubts.filter((d) => oldByUri.has(uriOf(d))).length + carried.length;
+  let room = Math.max(0, max - keptCount);
+  let next = old.reduce((n, d) => Math.max(n, Number(FAMILY.exec(d.id)[1])), 0);
+  const family = [], fresh = [];
+  for (const d of mint.doubts) {
+    const prior = oldByUri.get(uriOf(d));
+    if (prior) family.push(prior);
+    else if (room > 0) { room--; const f = { ...d, id: `doubt:record-carry:unreasoned:${++next}` }; fresh.push(f); family.push(f); }
+  }
+  family.push(...carried);
+  const stitched = fresh.length ? new Map(stitch(fresh).map((d) => [d.id, d])) : new Map();
+  const members = family.map((d) => stitched.get(d.id) ?? d);
+  const keptIds = new Set(members.map((d) => d.id));
+  const out = [];
+  let placed = false;
+  for (const d of all) {
+    if (!inFamily(d)) { out.push(d); continue; }
+    if (!placed) { out.push(...members); placed = true; }
+  }
+  if (!placed) out.push(...members);
+  return { doubts: out, fresh: fresh.map((d) => d.id), dropped: old.filter((d) => !keptIds.has(d.id)).map((d) => d.id),
+    minted: members.length, omitted: Math.max(0, mint.doubts.length - (members.length - carried.length)), unavailable: false };
+}
+
 /**
  * The one-line reader answer to "where did this record stop, and why". Takes the artifact and a mark
  * text or uri; returns the matching rows. The acceptance question for — "does it say why 澜珀 did
@@ -915,12 +970,7 @@ export function statedDivergenceFindings({ reconciliation = null, carryRows = nu
   // So the carry rows are the population — they are where a stated drop is RECORDED — and the
   // reconciliation is demoted to optional corroboration. Measured on that delivery, the correct
   // population is 70 rows over 34 distinct marks, all `digest:reasoned-negative`, and it contains both.
-  const arrived = new Set(["finding", "findings-surface"]);
-  const population = carryRows.filter((r) => r?.uri
-    && r.reason_source === "step-stated"           // the sibling owns step-silent; step-structural is mechanical
-    && !arrived.has(r.reach));                     // arrived, or arrived somewhere visible, is not a divergence
-
-  // Kept for corroboration only. `ended` no longer gates anything; where the reconciliation DOES name a
+  // Kept for corroboration. `ended` gates nothing but one exclusion below; where the reconciliation DOES name a
   // position it agrees with, that is recorded on the row so a reader can weigh it.
   const ended = [];
   for (const bucket of ["top_slice", "residual"]) {
@@ -930,6 +980,20 @@ export function statedDivergenceFindings({ reconciliation = null, carryRows = nu
     }
   }
   const endedUris = new Set(ended.map((e) => e.uri));
+  const arrived = new Set(["finding", "findings-surface"]);
+  // PLACEMENT'S OWN SET-ASIDE IS NOT A LOST FINDING. A record placement set aside, by name or by its group's row,
+  // leaves the placement seam with the step's ground before the digest ever sees it: the ruled method's decision,
+  // recorded where it was made. Read as a stated drop it was listed as a divergence pointing at another artifact,
+  // and on a crowded band those rows buried the few this check is for. It stays in the population where the digest
+  // ended its position as a finding, because then the record did vanish: in the reconciliation, or in the finding
+  // rows the digest's own typed calls recorded, which the reconciliation's silence cannot erase.
+  const digestFound = new Set((Array.isArray(digestFindingUris) ? digestFindingUris : []).map(lc));
+  const placementSetAside = (r) => r.stopped_at === "placement" && r.reason === "placement:set-aside"
+    && !endedUris.has(lc(r.uri)) && !digestFound.has(lc(r.uri));
+  const population = carryRows.filter((r) => r?.uri
+    && r.reason_source === "step-stated"           // the sibling owns step-silent; step-structural is mechanical
+    && !arrived.has(r.reach)                       // arrived, or arrived somewhere visible, is not a divergence
+    && !placementSetAside(r));
   const byUri = new Map();
   for (const r of carryRows) if (r?.uri) byUri.set(lc(r.uri), r);
 

package/driver/record-discard.mjs

@@ -92,8 +92,13 @@ const clip = (s, n = 300) => {
  * not name cannot be distinguished between considered-and-not-selected and never reached at all. Those
  * rows carry `verdict: "discarded"` with `reason_source: "step-structural"` and a reason naming the
  * incompletion, so the fact survives; they are never silently folded into ordinary drops.
+ *
+ * A SKIPPED PASS DECIDED NOTHING. A resumed run skips a stage whose answer is on disk, and that answer is an
+ * earlier pass's. Where `prior` (the folded ledger) already holds that earlier pass's row for a record at this
+ * seam, the skipped pass writes none: under the winner rule an incompletion written over it erased every ground
+ * the step had given. A record no earlier pass spoke about is still recorded as not reached.
  */
-export function seamRows({ seam, stage, trigger = null, pass = 1, completed = true,
+export function seamRows({ seam, stage, trigger = null, pass = 1, completed = true, skipped = false, prior = null,
   saw = [], carried = [], reasonFor = null, evidence = "" } = {}) {
   if (!DISCARD_SEAMS.includes(seam)) return [];
   const carriedSet = new Set();
@@ -112,6 +117,7 @@ export function seamRows({ seam, stage, trigger = null, pass = 1, completed = tr
       continue;
     }
     if (!completed) {
+      if (skipped && prior?.byUri?.get?.(uri)?.[seam]) continue;
       rows.push({
         seam, stage, trigger, pass, uri, verdict: "discarded",
         reason: `${seam}:stage-incomplete`, reason_source: "step-structural",

package/driver/record-fold.mjs

@@ -153,6 +153,20 @@ export function modelRecordPath(runDir, findingsPath) {
   return readFold(runDir)?.map && existsSync(at) ? at : findingsPath;
 }
 
+/**
+ * The model's ordinal behind a finding of findings.json as it stands, given the fold state `readFold` returns.
+ * With no fold in force the file is the model's record, so the ordinal is its own. Under a fold a folded finding
+ * IS the object of the member the fold kept, so that member is the answer. Null when a fold is in force and its
+ * map does not name the finding: a caller then leaves it alone rather than guessing. PURE.
+ */
+export function keptModelOrdinal(state, ordinal) {
+  if (!state?.map) return ordinal;
+  const members = state.map.foldedToModel?.[String(ordinal)];
+  if (!Array.isArray(members) || !members.length) return null;
+  if (members.length === 1) return members[0];
+  return (state.merges ?? []).find((m) => members.includes(m?.kept))?.kept ?? null;
+}
+
 /** The fold as it stands, to put back if a pass that changed it is rolled back. Never throws. */
 export function snapshotFold(runDir) {
   const state = readFold(runDir);

package/driver/record-goods.mjs

@@ -77,12 +77,25 @@ export function recordGoods(body, { english = true } = {}) {
     }
   }
   if (out.length === 0 && Array.isArray(b?._raw?.classifications)) {
-    for (const c of b._raw.classifications) push([c?.nice_class], c?.goods_services_text, null, isEnglish(c?.goods_services_language) || (!tagged(c?.goods_services_language) && english));
+    for (const c of b._raw.classifications) {
+      const at = out.length;
+      push([c?.nice_class], c?.goods_services_text, null, isEnglish(c?.goods_services_language) || (!tagged(c?.goods_services_language) && english));
+      // The register's own flag, on the full record it serves (Signa, Retrieve Trademark, the classification
+      // object's `goods_services_text_truncated`): true is a cut, false is whole, and no flag establishes nothing.
+      if (out.length > at) {
+        if (c?.goods_services_text_truncated === true) out[at].cut = true;
+        else if (c?.goods_services_text_truncated !== false) out[at].unknown = true;
+      }
+    }
   }
   if (out.length === 0 && b.goodsAndServices != null) {
     const gs = b.goodsAndServices;
+    // One string is the register's own statement as this install's US index holds it, whole (uspto-local). A list
+    // is a register whose full-record operation this tree documents nowhere (EUIPO and the free tier): its goods
+    // are read, and their completeness is not established.
     if (typeof gs === "string") push([], gs, null, english);
     else if (Array.isArray(gs)) {
+      const from = out.length;
       for (const g of gs) {
         if (typeof g === "string") { push([], g, null, english); continue; }
         const d = g?.description;
@@ -91,11 +104,35 @@ export function recordGoods(body, { english = true } = {}) {
         push([g?.classNumber ?? g?.class ?? g?.niceClass ?? g?.nice_class], textOf(chosen ?? g?.text ?? g?.goods), null,
           Boolean(en) || (Array.isArray(d) ? !tagged(d[0]?.language) && english : english));
       }
+      for (let i = from; i < out.length; i++) out[i].unknown = true;
     }
   }
   return out;
 }
 
+/**
+ * WHAT A HELD RECORD'S GOODS REST ON: the operation its body came from, and whether that body supplies the goods
+ * field at all. PURE. `operation` is read off the body's shape, as `recordGoods` reads it:
+ *   · `record-text` — Clarivate's record text, the full record (its statements are whole: the accepted provenance);
+ *   · `retrieve` — Signa's Retrieve Trademark, the full record, each statement with the register's own flag;
+ *   · `bulk-register` — the register's own statement as this install's US index holds it, whole;
+ *   · `undocumented` — any other shape: its completeness is not established.
+ * `field` is `listed` (the field is there with goods), `empty` (there, listing none) or `none` (not there at
+ * all): a body whose goods field is missing, or that will not parse, is not one that lists no goods.
+ */
+export function recordGoodsProvenance(body) {
+  const b = Array.isArray(body) ? body[0] : body;
+  if (!b || typeof b !== "object") return { operation: "undocumented", field: "none" };
+  const said = (v) => String(textOf(v) ?? "").trim() !== "";
+  if (Array.isArray(b.goodsServices))
+    return { operation: "record-text", field: b.goodsServices.some((g) => said(g?.description) || said(g?.translation)) ? "listed" : "empty" };
+  if (Array.isArray(b?._raw?.classifications))
+    return { operation: "retrieve", field: b._raw.classifications.some((c) => said(c?.goods_services_text)) ? "listed" : "empty" };
+  if (typeof b.goodsAndServices === "string") return { operation: "bulk-register", field: b.goodsAndServices.trim() ? "listed" : "empty" };
+  if (b.goodsAndServices != null) return { operation: "undocumented", field: recordGoods(b).length ? "listed" : "empty" };
+  return { operation: "undocumented", field: "none" };
+}
+
 // THE RAW GOODS LIST SAYS NOTHING THE NORMALISED ONE DOES NOT. A Clarivate record holds its goods twice: as the
 // register wrote them (`_raw.goodsServices.intClassDescriptions`) and as the provider maps them, item for item,
 // into `goodsServices` beside it (providers/clarivate/src/core.js `normalizeGoodsServices`). On a crowded test
@@ -163,6 +200,59 @@ export function bandGoodsIndex(runDir) {
 /** The goods of one band row from an index, or null when the run holds none for it. PURE. */
 export const goodsFor = (index, record) => index?.get(normalizeRecordUri(record?.record_id)) ?? null;
 
+/**
+ * The goods a band row holds itself, where the register's search answer carries them: Signa sends each record's
+ * class statements on the search row (`raw.classifications`) and flags a statement it cut. Each statement is read as
+ * a held body's is (`recordGoods`) and marked `cut: true` where the register cut it, so a statement that stops early
+ * is never read as the whole of its class. null when the row holds none. PURE.
+ *
+ * WHOLE ONLY WHERE THE ANSWER SAYS SO. The search answer our request asks for is the register's default, which it
+ * documents as "the first 280 characters" of each statement (docs.signa.so, Search Trademarks, "Response options",
+ * `include`: "`full_goods_services` returns the full goods and services text instead of the first 280
+ * characters"); the request never asks for the full text. So a statement shorter than 280 characters is whole, a
+ * flagged one is cut, and an unflagged one of 280 characters or more is marked `unknown: true`: its completeness is
+ * not established, and missing words in it establish nothing.
+ */
+export const DEFAULT_ANSWER_CUT = 280;
+export function rowGoods(row) {
+  const classes = Array.isArray(row?.raw?.classifications) ? row.raw.classifications : null;
+  if (!classes) return null;
+  const english = untaggedIsEnglish(normalizeRecordUri(row?.record_id));
+  const out = [];
+  for (const c of classes) {
+    const [g] = recordGoods({ _raw: { classifications: [c] } }, { english });
+    if (!g) continue;
+    const { cut: _cut, unknown: _unknown, ...whole } = g;   // the row's own rule below, not the full record's
+    if (c?.goods_services_text_truncated === true) out.push({ ...whole, cut: true });
+    else if ([...String(c?.goods_services_text ?? "")].length >= DEFAULT_ANSWER_CUT) out.push({ ...whole, unknown: true });
+    else out.push(whole);
+  }
+  return out.length ? out : null;
+}
+
+/**
+ * Was a statement of these goods cut short by the register? A record whose statements match no word, while one of
+ * them stops where the register cut it, is unknown to the goods test, not a mismatch: the words cut off may be the
+ * client's. Only goods read off a band row carry the mark (`rowGoods`); a held body's statements are whole. PURE.
+ */
+export const statementCut = (goods) => (goods ?? []).some((g) => g?.cut === true);
+
+/** Is a statement of these goods one whose completeness is not established (`rowGoods`, `recordGoods`)? PURE. */
+export const completenessUnknown = (goods) => (goods ?? []).some((g) => g?.unknown === true);
+/** Could words cut off, or not shown, from these goods be the client's? Then a statement matching none is unknown. PURE. */
+const notWhole = (goods) => statementCut(goods) || completenessUnknown(goods);
+
+/** How many records rest on each kind of goods evidence: a held body, a row's whole statements, a row's statements cut short or not established whole, or none. PURE. */
+export function goodsEvidence(records, goods) {
+  const out = { held: 0, complete: 0, cut: 0, unknown: 0, none: 0 };
+  for (const r of Array.isArray(records) ? records : []) {
+    if (goods?.held?.(r)) { out.held++; continue; }
+    const g = goods ? goods.of(r) : null;
+    if (!g) out.none++; else if (statementCut(g)) out.cut++; else if (completenessUnknown(g)) out.unknown++; else out.complete++;
+  }
+  return out;
+}
+
 const fold = (s) => foldDiacritics(String(s ?? "")).toLowerCase();
 const escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
@@ -206,7 +296,7 @@ export function goodsWordCounter(words, { stems = false } = {}) {
     if (!res.length || !readable.length) return null;
     const text = fold(readable.map((g) => (g.alt ? `${g.text}\n${g.alt}` : g.text)).join("\n"));
     const n = res.filter((re) => re.test(text)).length;
-    return n === 0 && classUnread(goods) ? null : n;
+    return n === 0 && (classUnread(goods) || notWhole(goods)) ? null : n;
   };
 }
 
@@ -238,7 +328,7 @@ export function goodsWordsMatched(words, { stems = false } = {}) {
   return (goods) => {
     if (!list.length || !(goods ?? []).some((g) => g.en !== false)) return null;
     const hit = tests.filter(([, t]) => t(goods) === 1).map(([w]) => w);
-    return hit.length === 0 && classUnread(goods) ? null : hit;
+    return hit.length === 0 && (classUnread(goods) || notWhole(goods)) ? null : hit;
   };
 }
 
@@ -269,8 +359,12 @@ export function instructedOrder(P, job = null) {
  * search asked for beside the one the variants stage named. The client's markets come from the caller:
  * this module is loaded by the band tool server, which reads no account settings. IMPURE (reads the run).
  * Any part that cannot be read is simply absent, and the shape sorts without it.
+ *
+ * A record's goods are its held body's, and where the run holds no body, the statements its band row carries
+ * (`rowGoods`). `held` says which: a line's goods are "on file" only where a body is held, because that is the
+ * record `band_record` can open. `records` are the band's, so the shape tests goods whenever either is held.
  */
-export function bandShapeGoods(P) {
+export function bandShapeGoods(P, records = []) {
   let model = null;
   try { if (existsSync(P.variantManifestModel)) model = parseVariantManifestModel(readFileSync(P.variantManifestModel, "utf8")); } catch { model = null; }
   let searched = "";
@@ -285,7 +379,9 @@ export function bandShapeGoods(P) {
   const words = product ? model.product_words : Array.isArray(model?.goods_words) ? model.goods_words : [];
   const stems = true;   // the word list the shape groups on is matched as stems, whichever source it came from
   const hits = goodsWordCounter(words, { stems });
-  const goods = index.size ? { of: (r) => goodsFor(index, r), hits, matched: goodsWordsMatched(words, { stems }) } : null;
+  const held = (r) => goodsFor(index, r);
+  const rowsHold = Array.isArray(records) && records.some((r) => r && typeof r === "object" && rowGoods(r));
+  const goods = index.size || rowsHold ? { of: (r) => held(r) ?? rowGoods(r), held: (r) => held(r) != null, hits, matched: goodsWordsMatched(words, { stems }) } : null;
   const goodsTest = { source: product ? "product_words" : words.length ? "goods_words" : "none", words };
   return { goods, goodsTest, goodsWordCount: words.length, dominantTerm: searched || manifestDominant, manifestDominant };
 }

package/driver/register-plan.mjs

@@ -2155,6 +2155,95 @@ export function foldSupplementalEntries(plan, entries) {
   };
 }
 
+/**
+ * THE WAITING FAMILIES THE READING TURN WITHHELD, keyed by the question each one asks.
+ *
+ * A wider family waits in the plan until the reading turn asks for it, and the turn records each family it
+ * leaves unasked as withheld-by-judgment, with its reason (withheld-families.mjs). The fold above lets a
+ * question through when it matches a waiting family, because the turn's own ask of that question is what the
+ * family waits for. That rule cannot tell the turn's ask from anyone else's, and the blind frame comparison's
+ * re-sweep turns its requests into questions by code: its contains question on the mark is such a family, so
+ * it asked families the turn had withheld. This map is what lets the re-sweep tell them apart.
+ *
+ * A family is in it only when all of these hold, because each one missing is a way a question could inherit
+ * a judgment nobody made:
+ *   · it waits for the reading turn in this plan: a required row has no withholding to inherit;
+ *   · the turn's record names it, on its own axis, with a reason: a family nobody judged is still open;
+ *   · it is not released: a release replaces the withholding;
+ *   · no plan row that does not wait asks the same question: that row is the one that answers it, and the
+ *     fold's duplicate rule names it as the twin.
+ * `withheld` is the record as readWithheldFamilies returns it, `{ [qid]: { axis, reason } }`, and `released`
+ * the set releasedFamilyQids returns. The caller reads both, so this stays PURE.
+ * @returns {Map<string, {qid: string, reason: string}>} question key → the withheld family and its reason
+ */
+export function withheldFamilyTwins(plan, withheld = {}, released = new Set()) {
+  const entries = Array.isArray(plan?.entries) ? plan.entries : [];
+  const asked = new Set(entries.filter((e) => e && e.unsupported !== true && !awaitsReadingTurn(e.when))
+    .map((e) => entryQuestionKey(e, plan)).filter(Boolean));
+  const twins = new Map();
+  for (const e of entries) {
+    if (!e?.qid || e.unsupported === true || !awaitsReadingTurn(e.when) || released?.has?.(e.qid)) continue;
+    const w = withheld?.[e.qid];
+    const reason = String(w?.reason ?? "").trim();
+    if (!reason || (w?.axis != null && String(w.axis) !== String(e.axis ?? ""))) continue;
+    const key = entryQuestionKey(e, plan);
+    if (key && !asked.has(key) && !twins.has(key)) twins.set(key, { qid: e.qid, reason });
+  }
+  return twins;
+}
+
+/**
+ * WHAT A RE-SWEEP THAT ADDS NOTHING STILL OWES ITS AXIS: the axis's entries that have not landed. The executor reads
+ * an empty question list as every entry on the axis, so a fold that added nothing used to repeat every landed
+ * question and, with them, retry the ones still unanswered. These are that retry without the repeats: every entry
+ * on the axis the provider can express (`unsupported` is never sent), a family waiting for the reading turn only once
+ * the turn released it, less every entry the join of these bands counts as executed, a released family's block
+ * included. So it sends a required search that did not land, and also what the old re-send retried among the
+ * unlanded: an entry whose provider error spent its retry ladder (a real call, as before), a capability refusal not
+ * yet accepted as a gap (refused again without a call), and a fringe entry whose guard the executor still holds
+ * (no call). The dispatcher drops the capability gaps the run has already accepted. PURE.
+ * @param {object} plan  the frozen register plan
+ * @param {string} axis  the axis the re-sweep ran on
+ * @param {object} bandsByAxis  the run's register bands, as readRegisterBands returns them
+ * @param {Set<string>} released  the families the reading turn released (releasedFamilyQids)
+ */
+export function pendingRequiredQids(plan, axis, bandsByAxis = {}, released = new Set()) {
+  const landed = new Set(joinPlanToBands(plan, bandsByAxis, { released }).executed.map((x) => x.qid));
+  return (Array.isArray(plan?.entries) ? plan.entries : [])
+    .filter((e) => e?.qid && e.axis === axis && e.unsupported !== true && (!awaitsReadingTurn(e.when) || released?.has?.(e.qid))
+      && !landed.has(e.qid))
+    .map((e) => e.qid);
+}
+
+/**
+ * Refuse the minted entries that repeat a withheld family exactly, before they reach the fold. "Exactly" is
+ * the fold's own question identity (entryQuestionKey: offices resolved, classes, goods, owner, term form), so
+ * the same term asked in other classes, other offices or narrowed by goods is a different question and is
+ * kept. Each refusal is `withheld-by-judgment`, its twin is the family, and it carries the reason on the
+ * family's record, so the closure rule (close-verify.mjs, withheldAs) settles the slice by that judgment:
+ * the slice is never frozen into the plan and never runs, and the family stays waiting, so the reading turn
+ * can still release it.
+ *
+ * NOT A SCREEN IN THE FOLD ITSELF, deliberately. The fold is the funnel for the reading turn's own proposals
+ * as well, and the turn's ask of a family it once withheld is that turn reconsidering, which the waiting rule
+ * exists to let through. Only the re-sweep, which asks on nobody's judgment, calls this.
+ *
+ * Every other entry is KEPT for the fold, which screens it as before. An entry whose qid the plan already
+ * holds is kept too: the fold reads it as a re-proposal of a row that is already there. PURE.
+ * @returns {{ kept: object[], refused: {qid: string, term: string, kind: "withheld-by-judgment", twin: string, reason: string}[] }}
+ */
+export function refuseWithheldFamilies(entries, twins, plan) {
+  const inPlan = new Set((plan?.entries ?? []).map((e) => e?.qid));
+  const kept = [], refused = [];
+  for (const e of Array.isArray(entries) ? entries : []) {
+    const key = e?.qid && !inPlan.has(e.qid) ? entryQuestionKey(e, plan) : null;
+    const twin = key ? twins?.get?.(key) : undefined;
+    if (!twin) { kept.push(e); continue; }
+    refused.push({ qid: e.qid, term: String(e.term ?? e.terms?.[0] ?? ""), kind: "withheld-by-judgment", twin: twin.qid, reason: twin.reason });
+  }
+  return { kept, refused };
+}
+
 /**
  * The store decision (pure — the attach step does only IO around this): given the slug store's
  * latest plan (or null) and a fresh compile, decide reuse / extend / mint.

package/driver/registry-fidelity.mjs

@@ -105,6 +105,32 @@ let lastLedgerError = null;
 export const ledgerReadError = () => lastLedgerError;
 const noteLedger = (r) => { if (r.error) lastLedgerError = r.error; return r; };
 
+// A RECORD BODY THAT CARRIES NO RECORD IS NOT A RECORD. A body counts as the record only where some field beside
+// its identity and its plumbing holds a value: a mark, a status, an owner, a class list, goods, a date. An object
+// holding nothing else is a placeholder: it satisfies no evidence duty, and it never replaces a body that carries
+// the record. The normalising registers write their identity on every record, an empty one included: the provider,
+// the office, the numbers the request asked for, a status class of "unknown", the link minted from them, and the
+// underscored provenance and raw copy. None of those is the record. A value counts only where something in it holds
+// one, so an object of nulls, or a list of empty objects, is no content either.
+const RECORD_IDENTITY_KEYS = new Set(["uri", "record_id", "id", "guid", "serial", "serialNumber", "object", "provider", "office", "statusClass", "status_class",
+  "applicationNumber", "registrationNumber", "resolved_link", "officeUrl"]);
+const holdsValue = (v, depth = 0) => {
+  if (v == null) return false;
+  if (typeof v === "string") return Boolean(v.trim());
+  if (depth > 8) return true;
+  if (Array.isArray(v)) return v.some((x) => holdsValue(x, depth + 1));
+  if (typeof v === "object") return Object.values(v).some((x) => holdsValue(x, depth + 1));
+  return true;
+};
+/** Does this body carry the record's own content, rather than only an identity? PURE. */
+export function recordBodyHasContent(body) {
+  const b = Array.isArray(body) ? body[0] : body;
+  if (!b || typeof b !== "object" || Array.isArray(b)) return false;
+  return Object.entries(b).some(([k, v]) => !k.startsWith("_") && !RECORD_IDENTITY_KEYS.has(k) && holdsValue(v));
+}
+// A later copy wins, unless it is a placeholder and the record already holds one with content.
+const keepRecord = (map, uri, body) => { if (recordBodyHasContent(body) || !recordBodyHasContent(map.get(uri))) map.set(uri, body); };
+
 // Latest fetched body per record URI for the run. Never throws (a missing ledger → empty map).
 //
 // — NO DEFAULT PATH. It used to fall back to `ledgerPath("record")`, the box-global file. Now that
@@ -118,7 +144,7 @@ export function collectRecordBodies(recordLogPath, runPrefix) {
     try { row = JSON.parse(line); } catch { return; }
     if (!runPrefix || !rowMatchesRun(row, runPrefix)) return;
     const body = Array.isArray(row.body) ? row.body[0] : row.body;
-    if (row.target && body && typeof body === "object") map.set(String(row.target).toLowerCase(), body);
+    if (row.target && body && typeof body === "object") keepRecord(map, String(row.target).toLowerCase(), body);
   }));
   return map;
 }
@@ -128,12 +154,17 @@ export function collectRecordBodies(recordLogPath, runPrefix) {
 // provider calls); replaces the "was it on disk?" inference the report's `verified` label rested on.
 export function collectRecordReceipts(recordLogPath, runPrefix) {   // — no default; see above
   const map = new Map();
+  const real = new Set();   // the records whose receipt is from a body carrying the record, which a placeholder's never replaces
   noteLedger(forEachLedgerLine(recordLogPath, (line) => {
     let row;
     try { row = JSON.parse(line); } catch { return; }
     if (!runPrefix || !rowMatchesRun(row, runPrefix)) return;
     if (!row.target || !row.ts) return;
-    map.set(String(row.target).toLowerCase(), { fetched_at: String(row.ts), context: stripGatewayNs(row.sessionKey ?? "") || null });
+    const key = String(row.target).toLowerCase();
+    const full = recordBodyHasContent(row.body);
+    if (!full && real.has(key)) return;
+    if (full) real.add(key);
+    map.set(key, { fetched_at: String(row.ts), context: stripGatewayNs(row.sessionKey ?? "") || null });
   }));
   return map;
 }
@@ -229,7 +260,7 @@ export function assembleRunRecords(runDir, runPrefix,
   const fromRunDir = readRecordArtifacts(runDir);
   const fromLedger = collectRecordBodies(recordLogPath, runPrefix);
   const records = new Map(fromRunDir);
-  for (const [uri, body] of fromLedger) records.set(uri, body);
+  for (const [uri, body] of fromLedger) keepRecord(records, uri, body);
   // WP-receipts: receipts assemble the same way the records do — artifact-embedded ones (inherited run
   // dir) ∪ this-session ledger rows (fresh fetch wins) — so a re-assembled run dir keeps its proof.
   const receipts = new Map();

package/driver/remedy-accounting.mjs

@@ -42,19 +42,23 @@
 // re-stated: verifyRegisterDirectiveClose asks the identical question of the same blocks, and two
 // copies of a matcher is how two matchers drift apart.
 
-import { blockCollapsed, answeredAs } from "./close-verify.mjs";
+import { blockCollapsed, answeredAs, withheldAs } from "./close-verify.mjs";
 import { reopenKey } from "./frame-diff-model.mjs";
 
 export const REMEDY_ACCOUNTING_SCHEMA_VERSION = 1;
 
 /**
- * The five term classes. EXACTLY ONE per remedy term, decided in the fixed order in classifyRemedyTerm.
+ * The six term classes. EXACTLY ONE per remedy term, decided in the fixed order in classifyRemedyTerm.
  *
- *   found          — every slice landed and the register returned material (records, or a counted crowd
- *                    too large to enumerate). The term is answered.
+ *   found          — every slice that ran landed and the register returned material (records, or a
+ *                    counted crowd too large to enumerate). The term is answered.
  *   searched-empty — every slice landed and every one is a COUNTED zero: state `enumerated`, a finite
  *                    total_hits of 0, an empty records array. The executed query and its empty result
  *                    are both recorded on the row. This is the state that used to leave no trace.
+ *   withheld-by-judgment — a slice repeated a waiting family the reading turn withheld, so it was never
+ *                    asked, and every other slice landed with nothing material. Nothing was found and
+ *                    nothing is claimed clean: the term rests on the reading turn's recorded judgment,
+ *                    named on the slice it settles (`withheld_as`).
  *   not-dispatched — no slice was ever minted for this term, with the reason the mint or the remedy
  *                    derivation gave. The term was NOT searched, and now says so.
  *   dispatch-failed— a slice was minted but did not land as a usable executed block: unlanded, error,
@@ -64,7 +68,7 @@ export const REMEDY_ACCOUNTING_SCHEMA_VERSION = 1;
  *                    counted zero (an uncountable total, an unrecognised state), or the receipt offers
  *                    no mapping at all. NEVER guessed in either direction.
  */
-export const REMEDY_TERM_CLASSES = ["found", "searched-empty", "not-dispatched", "dispatch-failed", "unaccounted"];
+export const REMEDY_TERM_CLASSES = ["found", "searched-empty", "withheld-by-judgment", "not-dispatched", "dispatch-failed", "unaccounted"];
 
 /**
  * The two classes that mean "this term's search is ON THE RECORD". Deliberately NOT every class with a
@@ -73,6 +77,15 @@ export const REMEDY_TERM_CLASSES = ["found", "searched-empty", "not-dispatched",
  */
 export const ACCOUNTED_CLASSES = ["found", "searched-empty"];
 
+/**
+ * The classes that leave nothing open: a search on the record, or the reading turn's recorded judgment not
+ * to ask the question at all. A withheld family is a wider question the ruled method lets that turn leave
+ * unasked, on the record with its reason, so a term resting on one is neither a hole nor a doubt. It is
+ * still not a search, which is why ACCOUNTED_CLASSES stays as it is. The not-accounted list, the doubts and
+ * the closure read below all read this one.
+ */
+export const SETTLED_CLASSES = [...ACCOUNTED_CLASSES, "withheld-by-judgment"];
+
 const clip = (s, n = 240) => {
   const t = String(s ?? "").replace(/\s+/g, " ").trim();
   return t.length > n ? `${t.slice(0, n - 1)}…` : t;
@@ -138,10 +151,13 @@ function material(block) {
  *   2. ANY slice that did not land clean ⇒ `dispatch-failed`, naming the first such qid. Every slice
  *      must land, exactly as verifyRegisterDirectiveClose requires of a directive — one convention. A
  *      slice the FOLD refused as already-asked is read through the twin it duplicates first, because that
- *      slice cannot land and the twin is where its question was answered;
+ *      slice cannot land and the twin is where its question was answered. A slice refused as a family
+ *      the reading turn withheld is settled by that judgment (`withheldAs`) and is left out of rules 2-5:
+ *      it never ran, so it has no result to read either way;
  *   3. all landed, ANY slice material ⇒ `found`;
- *   4. all landed, EVERY slice a counted zero ⇒ `searched-empty`;
- *   5. otherwise ⇒ `unaccounted`, with the shape that defeated the join stated.
+ *   4. all landed with nothing material, and a slice withheld ⇒ `withheld-by-judgment`;
+ *   5. all landed, EVERY slice a counted zero ⇒ `searched-empty`;
+ *   6. otherwise ⇒ `unaccounted`, with the shape that defeated the join stated.
  * PURE.
  */
 export function classifyRemedyTerm(row, { blocksByQid = new Map(), executedQids = new Set(), foldRefusals = new Map() } = {}) {
@@ -159,20 +175,31 @@ export function classifyRemedyTerm(row, { blocksByQid = new Map(), executedQids
   // ONLY THE DUPLICATE KIND RESOLVES. An identity collision or a malformed term is a genuine fault and
   // stays `dispatch-failed`: nothing else asked those questions, so nothing else answers them.
   const landsAs = new Map(qids.map((q) => [q, answeredAs(q, foldRefusals)]));   // one rule with the directive check
+  // — A SLICE REFUSED AS A FAMILY THE READING TURN WITHHELD IS SETTLED, NOT READ.
+  //
+  // Its twin never ran: the reading turn decided not to ask that family and recorded why, and the re-sweep
+  // refused to ask it on the turn's behalf. So there is no result to read, and reading the slice as one that
+  // failed to land would record a dispatch failure, and mint a doubt, over a decision the run had made on
+  // purpose. It is settled by the same rule the directive check uses (`withheldAs`), it keeps its own row
+  // saying which family it repeats, and it carries no count, no state and no executed flag of its own.
+  const settledBy = new Map(qids.map((q) => [q, withheldAs(q, foldRefusals)]).filter(([, w]) => w));
   const blockFor = (q) => blocksByQid.get(landsAs.get(q) ?? q);
   const ranAs = (q) => executedQids.has(landsAs.get(q) ?? q);
   const slices = qids.map((q) => {
+    const settled = settledBy.get(q);
+    if (settled) return { ...sliceRow(q, null, false), refused_at_fold: "withheld-by-judgment", withheld_as: settled.family };
     const via = landsAs.get(q);
     const slice = sliceRow(q, blockFor(q), ranAs(q));
     return via && via !== q ? { ...slice, answered_by: via, refused_at_fold: "duplicate-question" } : slice;
   });
+  const asked = qids.filter((q) => !settledBy.has(q));
   if (!qids.length) {
     const reason = String(row?.dispatch_reason ?? "").trim();
     return reason
       ? { class: "not-dispatched", basis: "no-slice-minted", reason: clip(reason, 300), slices }
       : { class: "unaccounted", basis: "no-mapping", reason: "the receipt records no slice and no reason for this term — the join cannot say whether it was searched", slices };
   }
-  for (const q of qids) {
+  for (const q of asked) {
     const b = blockFor(q);
     if (sliceLanded(b, ranAs(q))) continue;
     const why = !ranAs(q) ? "slice-not-landed"
@@ -182,8 +209,11 @@ export function classifyRemedyTerm(row, { blocksByQid = new Map(), executedQids
             : "collapsed-slice";
     return { class: "dispatch-failed", basis: why, reason: `${why}:${q}${b?.reason ? ` — ${clip(b.reason, 200)}` : ""}`, slices };
   }
-  const blocks = qids.map((q) => blockFor(q));
+  const blocks = asked.map((q) => blockFor(q));
   if (blocks.some(material)) return { class: "found", basis: "band-block", reason: null, slices };
+  // Nothing material came back, and part of the term was never asked by the turn's decision: a counted zero
+  // beside a question nobody asked is not a clean result for the term, so it is not `searched-empty`.
+  if (settledBy.size && blocks.every(countedZero)) return { class: "withheld-by-judgment", basis: "reading-turn-record", reason: null, slices };
   if (blocks.every(countedZero)) return { class: "searched-empty", basis: "counted-zero", reason: null, slices };
   const odd = blocks.find((b) => !countedZero(b));
   return {
@@ -240,9 +270,10 @@ export function accountRemedyTerms({ terms = [], blocksByQid = new Map(), execut
     totals,
     by_directive: byDirective,
     // the two lists a reader is owed, kept APART on purpose (see the zero-semantics note in the header):
-    // a term that ran and found nothing is EVIDENCE; a term that never ran is a hole.
+    // a term that ran and found nothing is EVIDENCE; a term that never ran is a hole. A term the reading
+    // turn's judgment settled is neither, and is in neither list: its row says which family it rests on.
     searched_empty: rows.filter((r) => r.class === "searched-empty"),
-    not_accounted: rows.filter((r) => !ACCOUNTED_CLASSES.includes(r.class)),
+    not_accounted: rows.filter((r) => !SETTLED_CLASSES.includes(r.class)),
     out_of_scope: (Array.isArray(outOfScope) ? outOfScope : []).map((o) => ({
       directive: String(o?.directive ?? ""), layer: String(o?.layer ?? ""),
       reason: clip(o?.reason ?? "source-channel directive — swept by a prose byte-diff on the common-law findings, so it has no term unit and no per-query record to account", 300),
@@ -269,6 +300,11 @@ export function accountRemedyTerms({ terms = [], blocksByQid = new Map(), execut
  * `accounting` may be null (the ledger did not build) — then this returns the caller's own prior answer
  * untouched, because a join that could not run is not evidence of a gap. PURE.
  *
+ * A term settled by the reading turn's recorded judgment does not hold the gap open (SETTLED_CLASSES): the
+ * re-sweep did not ask a question that turn had decided against, and holding a CLEAR on that would turn a
+ * recorded decision into an unfinished search. It closes nothing by itself either: the directive must still
+ * be verified-closed, and every slice that did run must have landed.
+ *
  * @returns {{domClosed: boolean, blockedBy: {term, directive, class, reason}[]}}
  */
 export function domClosedOverAccounted({ directives = [], swept = [], accounting = null, reopenKeyOf = reopenKey } = {}) {
@@ -283,7 +319,7 @@ export function domClosedOverAccounted({ directives = [], swept = [], accounting
   if (!closedOnADominant) return { domClosed: false, blockedBy: [] };
   if (!accounting || accounting.computable !== true) return { domClosed: true, blockedBy: [] };
   const blockedBy = (accounting.rows ?? [])
-    .filter((r) => domKeys.has(r.directive) && !ACCOUNTED_CLASSES.includes(r.class))
+    .filter((r) => domKeys.has(r.directive) && !SETTLED_CLASSES.includes(r.class))
     .map((r) => ({ term: r.term, directive: r.directive, class: r.class, reason: r.reason }));
   return { domClosed: blockedBy.length === 0, blockedBy };
 }
@@ -292,7 +328,7 @@ export function domClosedOverAccounted({ directives = [], swept = [], accounting
 // AD-4 house rule: every field is written on EVERY row, so "no term went unaccounted"
 // (unaccounted:0) and "the ledger could not run" (unaccounted:null) differ by VALUE, never by field
 // presence.
-export const REMEDY_ACCOUNTING_EVENT_FIELDS = ["terms", "found", "searched_empty", "not_dispatched",
+export const REMEDY_ACCOUNTING_EVENT_FIELDS = ["terms", "found", "searched_empty", "withheld_by_judgment", "not_dispatched",
   "dispatch_failed", "unaccounted"];
 
 export function remedyAccountingEvent({ trigger = null, artifact = null, reason = null } = {}) {
@@ -313,6 +349,8 @@ export function remedyAccountingEvent({ trigger = null, artifact = null, reason
  *   doubt:remedy-accounting:unaccounted:N     — the join cannot say either way
  * A `searched-empty` term mints NOTHING: it is answered, and its query and empty result ride the
  * artifact and the receipt. Minting a doubt for it would turn a completed search into an open question.
+ * A `withheld-by-judgment` term mints nothing either: it rests on the reading turn's recorded decision not
+ * to ask, and a doubt would re-open that decision as a question nobody had answered.
  *
  * The frozen doubt-record shape, status "open"; stitchDoubts and the doubt-closure stage decide endings
  * exactly as for every other doubt family, and an OPEN one shipping is the system working. Never gates,