@clien-ai/mcp 0.10.2 → 0.10.4

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 === 'GROUNDED') {
+        provenance = ' · Stored grade: GROUNDED — receipt unavailable; do not cite';
     }
-    else if (rawState === 'NO_RECEIPT' && attestedSourceId) {
-        provenance = ` · ${ATTESTED_LABEL} → ${attestedSourceId} (NOT a receipt)`;
+    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)
+function attestedWindow(receipt) {
+    if (receipt?.kind !== 'attested')
         return '';
-    const quote = collapseWhitespace(str(rawQuote) ?? '');
-    if (!quote)
-        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'));
@@ -1057,6 +1120,87 @@ function renderRobustness(reportData, channel) {
     return (`${header}\n${lines.join('\n')}` +
         capNote(shown.length, withRobustness.length, channel, 'report_data.hypothesisResults'));
 }
+// ---------------------------------------------------------------------------
+// Model-authored framing — prose side of the proof separator (FUL-570)
+// ---------------------------------------------------------------------------
+/** Defensive ceiling for one model-authored framing value read from raw report_data. */
+const MODEL_FRAMING_TEXT_MAX = 400;
+/** Runaway backstop for assumptions / risks; normal briefs carry only a handful. */
+const MODEL_FRAMING_LIST_CAP = 10;
+export const MODEL_FRAMING_HEADING = '## Model-authored report framing — not evidence or findings';
+function framingList(raw) {
+    return asArray(raw)
+        .map((value) => safeInline(value, MODEL_FRAMING_TEXT_MAX))
+        .filter((value) => Boolean(value));
+}
+function renderPersonasSynthesis(reportData) {
+    const synthesis = asRecord(reportData.personasSynthesis);
+    if (!synthesis)
+        return '';
+    const headline = safeInline(synthesis.headline, MODEL_FRAMING_TEXT_MAX);
+    const body = safeInline(synthesis.body, MODEL_FRAMING_TEXT_MAX);
+    // The producer treats the pair atomically: a headline without its justification is not a
+    // degraded synthesis, it is an assertion with the reasoning removed. Preserve that rule on
+    // the raw-passthrough path too.
+    if (!headline || !body)
+        return '';
+    return ('### Persona-roster synthesis — model-authored, not evidence\n\n' +
+        `**${headline}**\n\n${body}`);
+}
+function renderResearchBrief(reportData) {
+    const brief = asRecord(reportData.researchBrief);
+    if (!brief)
+        return '';
+    const lines = [];
+    const targetMarket = safeInline(brief.targetMarket, MODEL_FRAMING_TEXT_MAX);
+    const valueProposition = safeInline(brief.valueProposition, MODEL_FRAMING_TEXT_MAX);
+    const competitiveLandscape = safeInline(brief.competitiveLandscape, MODEL_FRAMING_TEXT_MAX);
+    if (targetMarket)
+        lines.push(`- Target market: ${targetMarket}`);
+    if (valueProposition)
+        lines.push(`- Value proposition: ${valueProposition}`);
+    const assumptions = framingList(brief.assumptions);
+    if (assumptions.length > 0) {
+        lines.push('- Assumptions to test:');
+        lines.push(...assumptions
+            .slice(0, MODEL_FRAMING_LIST_CAP)
+            .map((assumption) => `  - ${assumption}`));
+        if (assumptions.length > MODEL_FRAMING_LIST_CAP) {
+            lines.push(`  - … ${assumptions.length - MODEL_FRAMING_LIST_CAP} more in report_data`);
+        }
+    }
+    if (competitiveLandscape) {
+        lines.push(`- Competitive landscape: ${competitiveLandscape}`);
+    }
+    const risks = framingList(brief.keyRisks);
+    if (risks.length > 0) {
+        lines.push('- Key risks:');
+        lines.push(...risks.slice(0, MODEL_FRAMING_LIST_CAP).map((risk) => `  - ${risk}`));
+        if (risks.length > MODEL_FRAMING_LIST_CAP) {
+            lines.push(`  - … ${risks.length - MODEL_FRAMING_LIST_CAP} more in report_data`);
+        }
+    }
+    if (lines.length === 0)
+        return '';
+    return '### Research brief — model-generated framing, not findings\n\n' + lines.join('\n');
+}
+/**
+ * The approved model-authored context block.
+ *
+ * `productName` and `problemStatement` remain typed but are deliberately not repeated: the
+ * former is already the report title and the latter restates the caller's idea. Only the five
+ * actionable framing fields approved in FUL-570 render here. This block is composed ABOVE the
+ * proof separator and labels itself twice; no line can be mistaken for a graded finding.
+ */
+function renderModelFraming(reportData) {
+    const data = asRecord(reportData);
+    if (!data)
+        return '';
+    const sections = [renderPersonasSynthesis(data), renderResearchBrief(data)].filter(Boolean);
+    if (sections.length === 0)
+        return '';
+    return `${MODEL_FRAMING_HEADING}\n\n${sections.join('\n\n')}`;
+}
 /**
  * The rendered budget for the run-level verdict rationale.
  *
@@ -1140,6 +1284,64 @@ const NO_TRUST_DATA = `${DIGEST_HEADING}\n\n` +
     'verified against a source: there is no claim registry, no receipts, no QA flags, and no ' +
     'anti-sycophancy readout to check it against. Treat every figure, quote, and verdict above as ' +
     'UNVERIFIED — do not cite anything from it as source-checked.';
+export const COMPETITOR_SOURCE_QUALITY_HEADING = '### Competitor source quality — code-derived flags';
+const MARKDOWN_LINK_NAME = /^\[([^\]\n]+)\]\([^)\n]+\)$/;
+const PARTIAL_MARKDOWN_LINK_NAME = /\[[^\]\n]*\]\(/;
+const URL_LIKE_NAME = /(?:\bhttps?:\/\/|\bwww\.)/i;
+/**
+ * Render an identifier, never a link. A competitor name is model-authored and can
+ * itself contain Markdown link syntax or a raw URL even when the separate `url`
+ * field is withheld. An exact Markdown link keeps only its label; other URL-like
+ * names fail closed to a placeholder. Remaining Markdown punctuation, including
+ * reference-link brackets and dots that Markdown may autolink, is removed.
+ */
+function competitorIdentifier(raw) {
+    const flattened = safeInline(raw, CLAIM_TEXT_MAX);
+    if (!flattened)
+        return '(unnamed competitor)';
+    const markdownLink = MARKDOWN_LINK_NAME.exec(flattened);
+    const candidate = markdownLink?.[1] ?? flattened;
+    if ((!markdownLink && PARTIAL_MARKDOWN_LINK_NAME.test(flattened)) ||
+        URL_LIKE_NAME.test(candidate)) {
+        return '(competitor name withheld: URL-like)';
+    }
+    const plain = collapseWhitespace(candidate.replace(/[^\p{L}\p{N}&'’+\- ]/gu, ' '));
+    return plain || '(unnamed competitor)';
+}
+/**
+ * FUL-587's compact disclosure. The aggregate and the decision to mark a row are code-derived
+ * from the exact canonical `marketing_seo` token. Only the flagged rows are named; positioning,
+ * notes, url and threat level remain model-authored prose and never cross the proof separator.
+ *
+ * The competitor name is the approved row identifier, not a prose block. It is flattened and
+ * capped before rendering, so a stored name cannot mint a digest row or heading of its own.
+ */
+function renderCompetitorSourceQuality(reportData) {
+    const competitors = asArray(reportData.competitors);
+    if (competitors.length === 0)
+        return '';
+    const readable = competitors
+        .map(asRecord)
+        .filter((competitor) => competitor !== null);
+    const unreadableCount = competitors.length - readable.length;
+    const flagged = readable.filter((competitor) => canonicalContentType(competitor.contentType) === 'marketing_seo');
+    const shown = flagged.slice(0, LIST_RENDER_CAP);
+    const lines = shown.map((competitor) => `- ⚠️ ${competitorIdentifier(competitor.name)} — \`marketing_seo\``);
+    const aggregate = `${flagged.length} of ${readable.length} competitor rows are flagged \`marketing_seo\`. ` +
+        'The mark is a source-quality classification used by synthesis filters, not a claim-level ' +
+        'grounding verdict. Check reportClaims[] states and receipts: a competitor’s own page may ' +
+        'ground a claim about itself only after span verification. Unmarked rows are not certified ' +
+        'as grounding evidence by this summary.' +
+        (unreadableCount > 0
+            ? ` ${unreadableCount} additional competitor array ${unreadableCount === 1 ? 'entry was' : 'entries were'} unreadable and could not be classified; do not treat that gap as clean.`
+            : '');
+    const cap = flagged.length > shown.length
+        ? `\n\n_Only ${shown.length} of ${flagged.length} flagged rows are named here; read report_data.competitors[] for the full structured list._`
+        : '';
+    return (`${COMPETITOR_SOURCE_QUALITY_HEADING}\n\n${aggregate}` +
+        (lines.length > 0 ? `\n\n${lines.join('\n')}` : '') +
+        cap);
+}
 /**
  * Build the trust digest appended to `get_report`'s text.
  *
@@ -1155,6 +1357,7 @@ export function buildTrustDigest(reportData, channel) {
     const sections = [
         renderPersonaSpine(data, channel),
         renderReportSpine(data, channel),
+        renderCompetitorSourceQuality(data),
         renderReceiptPools(data, channel),
         renderPersonas(data, channel),
         renderSycophancy(data, channel),
@@ -1231,17 +1434,19 @@ function renderReportGaps(reportData) {
  * a field can reach a caller through one tool and not the others while every test stays
  * green. FUL-510's `verdictSummary` is the field that made the seam worth naming.
  *
- * The order is the contract. Report prose first (the run's markdown, then its own stored
- * verdict rationale), then `---`, then the machine-checked digest LAST — because the
- * digest's authority rule is that the last such section in the message is the real one,
- * and anything above the separator is prose that may resemble it.
+ * The order is the contract. Report prose first (the run's markdown, then the explicitly
+ * labelled model-authored framing and its own stored verdict rationale), then `---`, then
+ * the machine-checked digest LAST — because the digest's authority rule is that the last
+ * such section in the message is the real one, and anything above the separator is prose
+ * that may resemble it.
  */
 export function composeReportText(reportMarkdown, reportData, channel) {
     const rationale = renderVerdictRationale(reportData);
+    const framing = renderModelFraming(reportData);
     // FUL-586: the completeness banner goes FIRST — before the prose it is a caveat about.
     const gaps = renderReportGaps(reportData);
     return (`${gaps ? `${gaps}\n\n---\n\n` : ''}` +
-        `${reportMarkdown}${rationale ? `\n\n${rationale}` : ''}` +
+        `${reportMarkdown}${framing ? `\n\n${framing}` : ''}${rationale ? `\n\n${rationale}` : ''}` +
         `\n\n---\n\n${buildTrustDigest(reportData, channel)}`);
 }
 //# sourceMappingURL=report-digest.js.map