@clien-ai/mcp 0.10.3 → 0.10.5

package/dist/tools/report-digest.js

@@ -217,23 +217,6 @@ function renderId(raw, absent = '(no id)') {
         return absent;
     return safeId(raw) ?? '(unrenderable id)';
 }
-/**
- * What a GROUNDED claim says when its receipt pointer did not render.
- *
- * The same absent-vs-unrenderable split as `renderId`, and here it changes what
- * the reader should DO. "no receipt id — unresolvable" tells an agent the claim
- * is grounded in something the report failed to record, which is a defect in the
- * run. A pointer that exists but is unrenderable is a defect in the POINTER: the
- * receipt is in `structuredContent` / `_meta` and can still be resolved there.
- * Printing the first for the second sends the agent to re-run research it does
- * not need.
- */
-function groundedWithoutReceipt(rawSourceId) {
-    const absent = rawSourceId === undefined || rawSourceId === null || String(rawSourceId).trim() === '';
-    return absent
-        ? ' · GROUNDED but no receipt id — unresolvable'
-        : ' · GROUNDED, receipt id present but unrenderable — resolve it from the raw report data';
-}
 function num(value) {
     return typeof value === 'number' && Number.isFinite(value) ? value : null;
 }
@@ -273,12 +256,61 @@ function capNote(shown, total, channel, path) {
         return '';
     return `\n_(showing ${shown} of ${total} — the remaining ${total - shown} are in \`${channel}.${path}\`)_`;
 }
-function tallyStates(claims) {
+/** Return the normalized URL only when it is a safe, non-credentialed web receipt. */
+function safeReceiptUrl(raw) {
+    if (typeof raw !== 'string' || !raw.trim())
+        return null;
+    try {
+        const url = new URL(raw.trim());
+        if ((url.protocol !== 'http:' && url.protocol !== 'https:') || url.username || url.password) {
+            return null;
+        }
+        return url.href;
+    }
+    catch {
+        return null;
+    }
+}
+/** Resolve the single, persona-owned presentation grant behind a GROUNDED claim. */
+function resolvePersonaReceipt(rawClaim, personas) {
+    const claim = asRecord(rawClaim);
+    if (str(claim?.state) !== 'GROUNDED')
+        return null;
+    const personaIndex = personas.findIndex((_, index) => str(claim?.personaId) === `persona-${index}`);
+    if (personaIndex < 0)
+        return null;
+    const sources = asArray(asRecord(personas[personaIndex])?.sources);
+    const sourceIndex = sources.findIndex((_, index) => str(claim?.sourceId) === `RCP-p${personaIndex}-s${index}`);
+    if (sourceIndex < 0)
+        return null;
+    const source = asRecord(sources[sourceIndex]);
+    const href = safeReceiptUrl(source?.url);
+    if (!source || !href)
+        return null;
+    return {
+        sourceId: `RCP-p${personaIndex}-s${sourceIndex}`,
+        href,
+        quote: collapseWhitespace(str(source.quote) ?? ''),
+        source,
+    };
+}
+function resolvePersonaRows(reportData) {
+    const personas = asArray(reportData.personas);
+    return asArray(reportData.claims).map((claim) => ({
+        claim,
+        receipt: resolvePersonaReceipt(claim, personas),
+    }));
+}
+function tallyPersonaStates(rows) {
     const tally = { grounded: 0, speculation: 0, noReceipt: 0, other: 0 };
-    for (const raw of claims) {
+    for (const { claim: raw, receipt } of rows) {
         const state = str(asRecord(raw)?.state);
-        if (state === 'GROUNDED')
-            tally.grounded += 1;
+        if (state === 'GROUNDED') {
+            if (receipt)
+                tally.grounded += 1;
+            else
+                tally.noReceipt += 1;
+        }
         else if (state === 'SPECULATION')
             tally.speculation += 1;
         else if (state === 'NO_RECEIPT')
@@ -308,7 +340,7 @@ function tallyLine(tally, total) {
  * itself is what an agent pattern-matches on — a digest that says "this claim has
  * a receipt" without printing `RCP-p0-s2` leaves the agent unable to follow it.
  */
-function renderPersonaClaim(raw) {
+function renderPersonaClaim(raw, resolvedReceipt) {
     const claim = asRecord(raw);
     if (!claim)
         return '- (unreadable claim entry)';
@@ -323,92 +355,103 @@ function renderPersonaClaim(raw) {
     //
     // The GROUNDED gates keep reading the RAW `str()` value: flattening trims, so
     // gating on the flattened one would newly admit `" GROUNDED "` as grounded and
-    // put the row's badge at odds with `tallyStates`, which reads raw. Flattening
+    // put the row's badge at odds with `tallyPersonaStates`, which reads raw. Flattening
     // is for the RENDER; it must not widen what counts as a receipt.
     const rawState = str(claim.state);
-    const state = safeInline(claim.state, 40) ?? 'UNKNOWN_STATE';
+    const storedState = safeInline(claim.state, 40) ?? 'UNKNOWN_STATE';
+    const state = rawState === 'GROUNDED' && !resolvedReceipt ? 'NO_RECEIPT' : storedState;
     const id = renderId(claim.id);
     const personaId = safeId(claim.personaId);
     const sourceId = safeId(claim.sourceId);
     const text = safeInline(claim.text, CLAIM_TEXT_MAX);
     // Gated on `state`, not on `sourceId` presence — see `renderReportClaim` for
     // why a pointer on a non-GROUNDED claim must never render as a receipt.
-    let receipt = '';
-    if (rawState === 'GROUNDED') {
-        receipt = sourceId ? ` ← ${sourceId}` : groundedWithoutReceipt(claim.sourceId);
+    let provenance = '';
+    if (resolvedReceipt) {
+        provenance = ` ← ${resolvedReceipt.sourceId}`;
+    }
+    else if (rawState === 'GROUNDED') {
+        provenance = ' · Stored grade: GROUNDED — receipt unavailable; do not cite';
     }
     else if (sourceId) {
-        receipt = ` (carries ${sourceId}, which does NOT grant grounding — state is ${state})`;
+        provenance = ` (carries ${sourceId}, which does NOT grant grounding — state is ${storedState})`;
     }
     const who = personaId ? ` (${personaId})` : '';
     const body = text ? ` — "${text}"` : '';
-    return `- [${state}] ${id}${who}${receipt}${body}`;
+    return `- [${state}] ${id}${who}${provenance}${body}`;
 }
 /**
- * One report-spine claim line. Differs from the persona one in two ways that
- * matter to a reader: it carries a `section` (market/competitor) instead of a
- * persona, and a NO_RECEIPT claim has TWO distinct provenance readings that must
- * be told apart — "Cited" (a page was read and independently vouched, no exact
- * span pinned) versus plain model knowledge (recalled, unverified).
- *
- * ⚠️ THE WORD IS THE ONE FROM `MODEL_ATTESTED_BADGE_LABEL` (FUL-416), lower-cased.
- * This digest is the THIRD mirror of that label inside the MCP package — the tool
- * advert in `registry.ts` is the other two — and it is the one that renders into
- * the payload an agent actually READS. When the re-map first landed it was missed:
- * the advert promised a claim "marked \"Inferred\"" while this line still emitted
- * `model-attested`, so an agent keying on the advert's word would have found
- * nothing, and the same server described one tier two different ways.
- *
- * Neither reading is grounding. The attestation's `sourceId` is printed under an
- * explicit `cited →` label rather than the bare `←` used for real receipts, so
- * the two can never be skim-read as the same thing. That distinction matters MORE now
- * that the word itself is shared with a span-verified receipt.
- *
- * FUL-615: an attested claim now also carries the WINDOW the judge read, clipped to
- * `RECEIPT_QUOTE_MAX` on a labelled continuation line. `cited` was the one provenance
- * tier on this surface whose supporting text reached no agent-visible channel at all —
- * a GROUNDED claim's span is readable as the `RCP-` excerpt it steers, but an attested
- * claim's pointer resolves into `reportEvidence`, whose rows deliberately carry no quote
- * (FUL-560). So the tier a reader is asked to weigh ("stronger than recall, still NOT a
- * receipt") was the one tier they could not see for themselves.
- *
- * ⚠️ THE ABSENCE OF A QUOTE USED TO BE HALF THE SEPARATION, and this change spends it.
- * What replaces it is `ATTESTED_WINDOW_LABEL` — see its doc for why a bare indented
- * quote would have made an attested row read as a grounded one.
- *
- * DIGEST COST, in the idiom `RECEIPT_QUOTE_MAX`'s own doc sets, because a digest an
- * agent truncates is a digest it does not read. Bounded by construction: this spine
- * renders at most `CLAIM_RENDER_CAP` (40) rows and only attested ones get a window, so
- * the worst case is 40 × (200 + ~40 for the label, indent, quotes and newline) ≈ 9.6 KB.
- * Today it is 0 on every prod report — the A2 grantor writes no attestations yet.
+ * Resolve the one presentation grant behind either report-level Cited treatment.
+ *
+ * A stored GROUNDED grade and a model-attestation marker are both untrusted report JSON, not proof
+ * by themselves. Either earns its presentation only when its canonical pointer indexes the exact
+ * `reportEvidence` pool and the target has a non-credentialed HTTP(S) destination. An attestation
+ * additionally needs its nonblank captured window. Keeping this as one resolver lets the row,
+ * tally, pointer and window consume the same answer instead of minting orphan citations.
  */
-function renderReportClaim(raw) {
+function resolveReportReceipt(rawClaim, reportEvidence) {
+    const claim = asRecord(rawClaim);
+    const rawState = str(claim?.state);
+    let kind;
+    let sourceId = '';
+    let quote = '';
+    if (rawState === 'GROUNDED') {
+        kind = 'grounded';
+        sourceId = typeof claim?.sourceId === 'string' ? claim.sourceId.trim() : '';
+    }
+    else if (rawState === 'NO_RECEIPT') {
+        kind = 'attested';
+        const attestation = asRecord(claim?.attestation);
+        sourceId = typeof attestation?.sourceId === 'string' ? attestation.sourceId.trim() : '';
+        quote = typeof attestation?.quote === 'string' ? collapseWhitespace(attestation.quote) : '';
+        if (!quote)
+            return null;
+    }
+    else {
+        return null;
+    }
+    if (!sourceId)
+        return null;
+    const parsed = /^RRCP-s(0|[1-9]\d*)$/.exec(sourceId);
+    if (!parsed)
+        return null;
+    const sourceIndex = Number(parsed[1]);
+    if (!Number.isSafeInteger(sourceIndex))
+        return null;
+    const source = asRecord(reportEvidence[sourceIndex]);
+    if (!source || !safeReceiptUrl(source.url))
+        return null;
+    return { kind, sourceId, quote };
+}
+function renderReportClaim(raw, receipt) {
     const claim = asRecord(raw);
     if (!claim)
         return '- (unreadable claim entry)';
     // FUL-253: same guard and same raw-gate split as `renderPersonaClaim` — this
     // spine's rows are the ones a forged `[GROUNDED] … ← RRCP-s0` would hide in.
     const rawState = str(claim.state);
-    const state = safeInline(claim.state, 40) ?? 'UNKNOWN_STATE';
+    const storedState = safeInline(claim.state, 40) ?? 'UNKNOWN_STATE';
+    const state = rawState === 'GROUNDED' && receipt?.kind !== 'grounded'
+        ? 'NO_RECEIPT'
+        : storedState;
     const id = renderId(claim.id);
     const section = safeInline(claim.section, 40);
     const sourceId = safeId(claim.sourceId);
     const text = safeInline(claim.text, CLAIM_TEXT_MAX);
-    const attestation = asRecord(claim.attestation);
-    const attestedSourceId = safeId(attestation?.sourceId);
-    // The bare `←` arrow means RECEIPT, so it is gated on `state`, NOT on the mere
-    // presence of a `sourceId`. Keying on presence would render an explicitly
-    // unsupported claim with the same marker a span-verified one gets: the schema
-    // types `state` and `sourceId` independently and `.passthrough()`s unknown
-    // shapes, and `getReport` hands the RAW payload through when Zod rejects it, so
-    // `{ state: 'NO_RECEIPT', sourceId: 'RRCP-s0' }` genuinely reaches this code.
-    // An agent following that arrow would treat a NO_RECEIPT figure as source-checked.
+    // The bare `←` arrow means RECEIPT, so raw state and pointer presence are both
+    // insufficient. The shared resolver must also find the exact evidence row and a
+    // safe destination; otherwise even a stored GROUNDED grade degrades to neutral
+    // audit copy. `getReport` hands RAW payload through after schema drift, so every
+    // one of those checks is a render-boundary responsibility.
     let provenance = '';
-    if (rawState === 'GROUNDED') {
-        provenance = sourceId ? ` ← ${sourceId}` : groundedWithoutReceipt(claim.sourceId);
+    if (receipt?.kind === 'grounded') {
+        provenance = ` ← ${receipt.sourceId}`;
     }
-    else if (rawState === 'NO_RECEIPT' && attestedSourceId) {
-        provenance = ` · ${ATTESTED_LABEL} → ${attestedSourceId} (NOT a receipt)`;
+    else if (rawState === 'GROUNDED') {
+        provenance = ' · Stored grade: GROUNDED — receipt unavailable; do not cite';
+    }
+    else if (receipt?.kind === 'attested') {
+        provenance = ` · ${ATTESTED_LABEL} → ${receipt.sourceId} (NOT a receipt)`;
     }
     else if (rawState === 'NO_RECEIPT') {
         provenance = ` · ${UNSOURCED_LABEL} — from model knowledge, unverified`;
@@ -416,11 +459,11 @@ function renderReportClaim(raw) {
     // A pointer on a non-grounded claim is shown but explicitly disarmed, so it is
     // neither hidden from the reader nor readable as grounding.
     if (rawState !== 'GROUNDED' && sourceId) {
-        provenance += ` (carries ${sourceId}, which does NOT grant grounding — state is ${state})`;
+        provenance += ` (carries ${sourceId}, which does NOT grant grounding — state is ${storedState})`;
     }
     const where = section ? ` (${section})` : '';
     const body = text ? ` — "${text}"` : '';
-    return `- [${state}] ${id}${where}${provenance}${body}${attestedWindow(rawState, attestedSourceId, attestation?.quote)}`;
+    return `- [${state}] ${id}${where}${provenance}${body}${attestedWindow(receipt)}`;
 }
 /**
  * The attested claim's window: the captured snapshot text an independent judge read
@@ -445,31 +488,48 @@ function renderReportClaim(raw) {
  * budget of its own, for the reason that constant's doc gives: an agent reading the
  * same source text clipped two different ways has to wonder which is the real wording.
  */
-function attestedWindow(rawState, attestedSourceId, rawQuote) {
-    if (rawState !== 'NO_RECEIPT' || !attestedSourceId)
-        return '';
-    const quote = collapseWhitespace(str(rawQuote) ?? '');
-    if (!quote)
+function attestedWindow(receipt) {
+    if (receipt?.kind !== 'attested')
         return '';
-    return `\n    ${ATTESTED_WINDOW_LABEL}: "${clipReceiptQuote(quote, [], RECEIPT_QUOTE_MAX)}"`;
+    return `\n    ${ATTESTED_WINDOW_LABEL}: "${clipReceiptQuote(receipt.quote, [], RECEIPT_QUOTE_MAX)}"`;
+}
+function tallyReportStates(rows) {
+    const tally = { grounded: 0, speculation: 0, noReceipt: 0, other: 0 };
+    for (const { claim: raw, receipt } of rows) {
+        const state = str(asRecord(raw)?.state);
+        if (state === 'GROUNDED') {
+            if (receipt?.kind === 'grounded')
+                tally.grounded += 1;
+            else
+                tally.noReceipt += 1;
+        }
+        else if (state === 'SPECULATION')
+            tally.speculation += 1;
+        else if (state === 'NO_RECEIPT')
+            tally.noReceipt += 1;
+        else
+            tally.other += 1;
+    }
+    return tally;
 }
 function renderPersonaSpine(reportData, channel) {
-    const claims = asArray(reportData.claims);
-    if (claims.length === 0) {
+    const rows = resolvePersonaRows(reportData);
+    if (rows.length === 0) {
         return ('### Persona claim spine — NOT PRESENT on this run\n' +
             'No persona claim registry was produced, so NOTHING in the persona/interview prose above ' +
             'has been machine-checked. Absent is not clean: treat those statements as unverified.');
     }
-    const tally = tallyStates(claims);
-    const shown = claims.slice(0, CLAIM_RENDER_CAP);
-    const lines = shown.map(renderPersonaClaim);
-    return (`### Persona claim spine — ${tallyLine(tally, claims.length)}\n` +
+    const tally = tallyPersonaStates(rows);
+    const shown = rows.slice(0, CLAIM_RENDER_CAP);
+    const lines = shown.map(({ claim, receipt }) => renderPersonaClaim(claim, receipt));
+    return (`### Persona claim spine — ${tallyLine(tally, rows.length)}\n` +
         'A GROUNDED claim\'s receipt id (`RCP-p{i}-s{j}`) indexes `personas[i].sources[j]` — the cached ' +
-        'forum post its quote span was code-verified against. NO_RECEIPT can mean a bad claim OR merely ' +
+        'forum post its quote span was code-verified against. A stored GROUNDED grade whose canonical, ' +
+        'persona-owned safe receipt is unavailable is rendered and counted NO_RECEIPT. NO_RECEIPT can mean a bad claim OR merely ' +
         'sparse evidence: check that persona\'s `insufficientEvidence` / `sourcesFound` below before ' +
         'discounting it. Anything not GROUNDED is unverified.\n' +
         `${lines.join('\n')}` +
-        capNote(shown.length, claims.length, channel, 'report_data.claims'));
+        capNote(shown.length, rows.length, channel, 'report_data.claims'));
 }
 function renderReportSpine(reportData, channel) {
     const claims = asArray(reportData.reportClaims);
@@ -479,14 +539,16 @@ function renderReportSpine(reportData, channel) {
             'executive-summary assertion in the prose above has been machine-checked. Treat every such ' +
             'figure as unverified.');
     }
-    const tally = tallyStates(claims);
-    const attested = claims.filter((raw) => {
-        const claim = asRecord(raw);
-        return str(claim?.state) === 'NO_RECEIPT' && str(asRecord(claim?.attestation)?.sourceId) !== null;
-    }).length;
+    const reportEvidence = asArray(reportData.reportEvidence);
+    const rows = claims.map((claim) => ({
+        claim,
+        receipt: resolveReportReceipt(claim, reportEvidence),
+    }));
+    const tally = tallyReportStates(rows);
+    const attested = rows.filter(({ receipt }) => receipt?.kind === 'attested').length;
     const attestedNote = attested > 0 ? ` (of which ${attested} ${ATTESTED_LABEL})` : '';
-    const shown = claims.slice(0, CLAIM_RENDER_CAP);
-    const lines = shown.map(renderReportClaim);
+    const shown = rows.slice(0, CLAIM_RENDER_CAP);
+    const lines = shown.map(({ claim, receipt }) => renderReportClaim(claim, receipt));
     return (`### Report claim spine — ${tallyLine(tally, claims.length)}${attestedNote}\n` +
         'A SEPARATE pool from the persona spine — the two never cross. Sections are `market` (sizing/' +
         'trend figures), `competitor` (profile facts) and `summary` (an assertion quoted VERBATIM from ' +
@@ -497,8 +559,9 @@ function renderReportSpine(reportData, channel) {
         'supporting page an independent check vouched for, but no exact span was pinned — stronger than ' +
         `recall, still NOT a receipt. The \`${ATTESTED_WINDOW_LABEL}\` line beneath such a row is that page's ` +
         'text as we captured it: read it as the context the judge weighed, never as a span checked against ' +
-        'the claim. Unmarked NO_RECEIPT is recalled model knowledge, unverified. ' +
-        'Key on the state, never on whether a source id is present.\n' +
+        'the claim. Unmarked NO_RECEIPT is recalled model knowledge, unverified. A stored GROUNDED grade ' +
+        'whose receipt is unavailable is shown as neutral audit context and counted NO_RECEIPT. ' +
+        'Key on the rendered state and receipt arrow, never on stored state or source-id presence alone.\n' +
         `${lines.join('\n')}` +
         capNote(shown.length, claims.length, channel, 'report_data.reportClaims'));
 }
@@ -506,9 +569,9 @@ function renderReportSpine(reportData, channel) {
  * The verified spans each persona receipt has to be able to SHOW, keyed by the
  * receipt id its claims point at (FUL-252).
  *
- * Gated on `state === 'GROUNDED'`, matching `renderPersonaClaim`'s own gate and for
- * the same reason: only a GROUNDED claim's span earned a badge, so only a GROUNDED
- * claim's span is what the excerpt owes the reader. Keying on the mere presence of
+ * Gated on the same resolved receipt as `renderPersonaClaim`: only a GROUNDED claim
+ * with a canonical, persona-owned safe receipt earned a badge, so only that claim's
+ * span is what the excerpt owes the reader. Keying on the mere presence of
  * `quoteSpan` would let a SPECULATION claim steer the window — pushing the excerpt
  * away from the sentence a real receipt was verified against, in favour of one no
  * check ever ran on. `getReport` hands the RAW payload through when Zod rejects it,
@@ -518,21 +581,20 @@ function renderReportSpine(reportData, channel) {
  * has no visible badge, so windowing a quote to support it would spend the excerpt
  * on a claim the agent cannot see, at the cost of one it can.
  */
-function collectVerifiedSpans(reportData) {
+function collectVerifiedSpans(rows) {
     const spans = new Map();
-    for (const raw of asArray(reportData.claims).slice(0, CLAIM_RENDER_CAP)) {
+    for (const { claim: raw, receipt } of rows.slice(0, CLAIM_RENDER_CAP)) {
         const claim = asRecord(raw);
-        if (!claim || str(claim.state) !== 'GROUNDED')
+        if (!claim || !receipt)
             continue;
-        const sourceId = str(claim.sourceId);
         const span = str(claim.quoteSpan);
-        if (!sourceId || !span)
+        if (!span)
             continue;
-        const existing = spans.get(sourceId);
+        const existing = spans.get(receipt.sourceId);
         if (existing)
             existing.push(span);
         else
-            spans.set(sourceId, [span]);
+            spans.set(receipt.sourceId, [span]);
     }
     return spans;
 }
@@ -561,54 +623,55 @@ function collectVerifiedSpans(reportData) {
  * from them — `publishedDate`, the figure's actual recency (FUL-148).
  */
 function renderReceiptPools(reportData, channel) {
-    const personas = asArray(reportData.personas);
     const reportEvidence = asArray(reportData.reportEvidence);
-    const spansByReceipt = collectVerifiedSpans(reportData);
+    const personaRows = resolvePersonaRows(reportData).slice(0, CLAIM_RENDER_CAP);
+    const spansByReceipt = collectVerifiedSpans(personaRows);
+    const personaReceiptById = new Map();
+    for (const { receipt } of personaRows) {
+        if (receipt)
+            personaReceiptById.set(receipt.sourceId, receipt);
+    }
     const personaReceipts = [];
-    personas.forEach((rawPersona, i) => {
-        const sources = asArray(asRecord(rawPersona)?.sources);
-        sources.forEach((rawSource, j) => {
-            const source = asRecord(rawSource);
-            // FUL-253: the quote below was already flattened — these two were not, and
-            // they sit on the SAME `- RCP-…` line, so a newline in either forges the
-            // receipt row the comment below says a forged quote would.
-            const platform = safeInline(source?.platform, 40) ?? 'unknown platform';
-            const url = safeInline(source?.url, 200) ?? '(no url)';
-            // Indented under its own receipt line so the pool still scans as a list of
-            // pointers; a receipt with no cached quote simply has no second line, which
-            // is itself worth seeing — it is a pointer that grounds nothing until fetched.
-            //
-            // `collapseWhitespace` is a FORGERY GUARD, not formatting: this pool is a
-            // list of `- RCP-i-j — …` lines, and a quote containing a newline plus a
-            // convincing `- RCP-` prefix would add an entry pointing at a source nobody
-            // retrieved. A whitespace-only quote also collapses to '' here and correctly
-            // renders as a bare pointer rather than as `""` — "the source said nothing".
-            //
-            // FUL-252: WHICH `RECEIPT_QUOTE_MAX` characters is chosen by the spans of the
-            // GROUNDED claims pointing at THIS receipt, not by the quote's head. Passing
-            // the receipt's own id is the whole wiring — `RCP-p{i}-s{j}` is the pointer
-            // `renderPersonaClaim` prints, so the two sides of the arrow are built from
-            // the same expression and cannot drift into windowing the wrong receipt.
-            const receiptId = `RCP-p${i}-s${j}`;
-            const quote = collapseWhitespace(str(source?.quote) ?? '');
-            const clipped = clipReceiptQuote(quote, spansByReceipt.get(receiptId) ?? [], RECEIPT_QUOTE_MAX);
-            const quoteLine = quote ? `\n    "${clipped}"` : '';
-            // FUL-560: the source type, stated ONCE for the pool (in the header below) and inline only
-            // on a row that breaks the stated rule. This pool is the one place in the package where the
-            // type is a near-constant: `stampEvidenceMetadata` (agent-side) prunes every non-`user_voice`
-            // source out of `persona.sources`, so a per-row line here would print the same word down
-            // forty rows and bury the one that mattered. The header carries the claim; this carries the
-            // exception, in the shared wording.
-            //
-            // ⚠️ ABSENT AND NON-CANONICAL ARE BOTH DEVIATIONS. `canonicalContentType` fails closed, so a
-            // legacy untyped receipt (M0a predates plenty of stored runs) and a token from a newer
-            // producer both land here rather than being silently absorbed by the header's claim — which
-            // would be exactly the "silence reads as reassurance" fail-open this change exists to close.
-            const personaType = canonicalContentType(source?.contentType);
-            const deviationLine = personaType === 'user_voice' ? '' : contentTypeDeviationLine(source?.contentType);
-            personaReceipts.push(`- ${receiptId} — ${platform} — ${url}${quoteLine}${deviationLine}`);
-        });
-    });
+    for (const [receiptId, receipt] of personaReceiptById) {
+        const source = receipt.source;
+        // FUL-253: the quote below was already flattened — these two were not, and
+        // they sit on the SAME `- RCP-…` line, so a newline in either forges the
+        // receipt row the comment below says a forged quote would.
+        const platform = safeInline(source?.platform, 40) ?? 'unknown platform';
+        const url = safeInline(receipt.href, 200) ?? '(no url)';
+        // Indented under its own receipt line so the pool still scans as a list of
+        // pointers; a receipt with no cached quote simply has no second line, which
+        // is itself worth seeing — it is a pointer that grounds nothing until fetched.
+        //
+        // `collapseWhitespace` is a FORGERY GUARD, not formatting: this pool is a
+        // list of `- RCP-i-j — …` lines, and a quote containing a newline plus a
+        // convincing `- RCP-` prefix would add an entry pointing at a source nobody
+        // retrieved. A whitespace-only quote also collapses to '' here and correctly
+        // renders as a bare pointer rather than as `""` — "the source said nothing".
+        //
+        // FUL-252: WHICH `RECEIPT_QUOTE_MAX` characters is chosen by the spans of the
+        // GROUNDED claims pointing at THIS receipt, not by the quote's head. Passing
+        // the receipt's own id is the whole wiring — `RCP-p{i}-s{j}` is the pointer
+        // `renderPersonaClaim` prints, so the two sides of the arrow are built from
+        // the same expression and cannot drift into windowing the wrong receipt.
+        const quote = receipt.quote;
+        const clipped = clipReceiptQuote(quote, spansByReceipt.get(receiptId) ?? [], RECEIPT_QUOTE_MAX);
+        const quoteLine = quote ? `\n    "${clipped}"` : '';
+        // FUL-560: the source type, stated ONCE for the pool (in the header below) and inline only
+        // on a row that breaks the stated rule. This pool is the one place in the package where the
+        // type is a near-constant: `stampEvidenceMetadata` (agent-side) prunes every non-`user_voice`
+        // source out of `persona.sources`, so a per-row line here would print the same word down
+        // forty rows and bury the one that mattered. The header carries the claim; this carries the
+        // exception, in the shared wording.
+        //
+        // ⚠️ ABSENT AND NON-CANONICAL ARE BOTH DEVIATIONS. `canonicalContentType` fails closed, so a
+        // legacy untyped receipt (M0a predates plenty of stored runs) and a token from a newer
+        // producer both land here rather than being silently absorbed by the header's claim — which
+        // would be exactly the "silence reads as reassurance" fail-open this change exists to close.
+        const personaType = canonicalContentType(source?.contentType);
+        const deviationLine = personaType === 'user_voice' ? '' : contentTypeDeviationLine(source?.contentType);
+        personaReceipts.push(`- ${receiptId} — ${platform} — ${url}${quoteLine}${deviationLine}`);
+    }
     const evidenceReceipts = reportEvidence.map((raw, n) => {
         const source = asRecord(raw);
         // FUL-253: every field on this row is scraped-page metadata, and the row is
@@ -640,13 +703,13 @@ function renderReceiptPools(reportData, channel) {
     });
     if (personaReceipts.length === 0 && evidenceReceipts.length === 0) {
         return ('### Receipt pools — EMPTY\n' +
-            'No cached sources were attached to this run, so no claim above can be followed to a source. ' +
-            'Any receipt id referenced in the prose is unresolvable.');
+            'No visible claim resolves to a canonical, persona-owned safe receipt and no report evidence ' +
+            'was attached to this run. Any receipt id referenced in the prose is unresolvable.');
     }
     const sections = ['### Receipt pools'];
     if (personaReceipts.length > 0) {
         const shown = personaReceipts.slice(0, CLAIM_RENDER_CAP);
-        sections.push(`**Persona receipts** (${plural(personaReceipts.length, 'cached forum post')}) — the target of an \`RCP-\` pointer. ` +
+        sections.push(`**Persona receipts** (${plural(personaReceipts.length, 'cached forum post')}) — safe targets of the visible \`RCP-\` pointers above. ` +
             'Every receipt here is a first-hand `user_voice` post unless its own row says otherwise:\n' +
             shown.join('\n') +
             capNote(shown.length, personaReceipts.length, channel, 'report_data.personas[].sources'));
@@ -838,12 +901,48 @@ function renderSycophancy(reportData, channel) {
  */
 function hypothesisDetail(result) {
     const statement = safeInline(result?.statement, HYPOTHESIS_STATEMENT_MAX);
-    const scopeCaveat = safeInline(result?.scopeCaveat, HYPOTHESIS_NOTE_MAX);
     const evidenceReading = safeInline(result?.evidenceReading, HYPOTHESIS_NOTE_MAX);
     return ((statement ? `\n    ${HYPOTHESIS_LABEL}: "${statement}"` : '') +
-        (scopeCaveat ? `\n    ${SCOPE_CAVEAT_LABEL}: "${scopeCaveat}"` : '') +
+        scopeCaveatDetail(result) +
         (evidenceReading ? `\n    ${EVIDENCE_READING_LABEL}: ${evidenceReading}` : ''));
 }
+/** The exact quoted/labelled FUL-614 shape, shared by robust and caveat-only rows. */
+function scopeCaveatDetail(result) {
+    const scopeCaveat = safeInline(result?.scopeCaveat, HYPOTHESIS_NOTE_MAX);
+    return scopeCaveat ? `\n    ${SCOPE_CAVEAT_LABEL}: "${scopeCaveat}"` : '';
+}
+/**
+ * Scope caveats for hypotheses that do not have a robustness row (FUL-626).
+ *
+ * A caveat already rides on {@link hypothesisDetail} when the verdict was re-tested. This separate
+ * block covers only the other half so existing robustness rows stay byte-identical and a
+ * caveat-only fact never sits under a heading that claims robustness. Values are MODEL-WRITTEN,
+ * therefore quoted, labelled and passed through `safeInline` before entering a `- ` row.
+ *
+ * Deliberately no `LIST_RENDER_CAP`: the acceptance contract is that every nonblank caveat reaches
+ * `content`, and silently dropping the 26th trust qualification would be worse than a larger
+ * digest. The measured production rate was 26/371 rows (7%) on 2026-08-24, each value is bounded by
+ * `HYPOTHESIS_NOTE_MAX`, and ordinary runs carry only 5-8 hypotheses. The full result array remains
+ * the natural runaway bound, while version-skewed/malformed rows fail closed through `asArray`,
+ * `asRecord`, `renderId` and `safeInline`.
+ */
+function renderUnretestedScopeCaveats(reportData) {
+    const lines = asArray(reportData.hypothesisResults).flatMap((raw) => {
+        const result = asRecord(raw);
+        if (!result || asRecord(result.robustness) !== null)
+            return [];
+        const detail = scopeCaveatDetail(result);
+        if (!detail)
+            return [];
+        return [`- ${renderId(result.hypothesisId)}${detail}`];
+    });
+    if (lines.length === 0)
+        return '';
+    return ('### Scope caveats on hypotheses not re-tested\n' +
+        'These model-written qualifications apply to single-shot verdicts above; they are not ' +
+        'robustness results.\n' +
+        lines.join('\n'));
+}
 /**
  * What a persona name that arrived unreadable renders as (FUL-616).
  *
@@ -1298,6 +1397,7 @@ export function buildTrustDigest(reportData, channel) {
         renderReceiptPools(data, channel),
         renderPersonas(data, channel),
         renderSycophancy(data, channel),
+        renderUnretestedScopeCaveats(data),
         renderRobustness(data, channel),
     ].filter((section) => section.length > 0);
     return `${DIGEST_HEADING}\n\n${sections.join('\n\n')}`;