@clien-ai/mcp 0.11.0 → 0.12.1

package/dist/tools/report-digest.js

@@ -48,8 +48,12 @@
  */
 import { collapseWhitespace, safeInline, safeId, clipReceiptQuote, containsSpan, hasVisibleContent, RECEIPT_QUOTE_MAX, } from './render-safety.js';
 import { canonicalContentType, contentTypeDeviationLine, contentTypeProvenanceLine, } from './content-type-display.js';
-import { resolveSourceReceipt } from './receipt-children.js';
-import { resolveSupportedMarketSizing } from './market-sizing-proof.js';
+import { readFinalHypothesisState } from './hypothesis-final.js';
+import { readRobustnessCounts } from '../hypothesis-semantics.js';
+import { parseReceiptId, resolveSourceReceipt } from './receipt-children.js';
+import { resolveMarketSignals } from './market-signals.js';
+import { MCP_OVERVIEW_REF_CAP, MCP_OVERVIEW_SPAN_CAP, REPORT_PORTRAIT_PATHS, sanitizeMcpMarkdownTitle, sanitizeMcpReportTitle, } from '../types/report.js';
+import { readSemanticTheme } from '../types/semantic-theme.js';
 /**
  * Max claims rendered per spine. Above this the digest states how many were
  * dropped and where the full list lives — never a silent cut. Sized so a typical
@@ -185,6 +189,8 @@ const UNSOURCED_LABEL = 'unsourced';
 const HYPOTHESIS_LABEL = 'hypothesis';
 const SCOPE_CAVEAT_LABEL = '⚠️ scope caveat — persona support from OUTSIDE its credibility domain; directional, NOT grounded';
 const EVIDENCE_READING_LABEL = 'rests on';
+/** FUL-358 — the reliability continuation line's label. */
+const RELIABILITY_LABEL = 'confidence in this verdict';
 /**
  * The marker on a receipt-CHILD line, and the pool sentence that explains it (FUL-685 / T8).
  *
@@ -303,12 +309,18 @@ function capNote(shown, total, channel, path) {
         return '';
     return `\n_(showing ${shown} of ${total} — the remaining ${total - shown} are in \`${channel}.${path}\`)_`;
 }
+/** Honest overflow note for overview entries omitted before their public allowlist is evaluated. */
+function overviewCapNote(truncated, cap, noun) {
+    if (!truncated)
+        return '';
+    return `\n_(showing at most ${cap} stored ${noun} — additional entries were omitted before public allowlisting)_`;
+}
 /** Return the normalized URL only when it is a safe, non-credentialed web receipt. */
 function safeReceiptUrl(raw) {
-    if (typeof raw !== 'string' || !raw.trim())
+    if (typeof raw !== 'string' || !/^https?:\/\//i.test(raw))
         return null;
     try {
-        const url = new URL(raw.trim());
+        const url = new URL(raw);
         if ((url.protocol !== 'http:' && url.protocol !== 'https:') || url.username || url.password) {
             return null;
         }
@@ -318,6 +330,112 @@ function safeReceiptUrl(raw) {
         return null;
     }
 }
+const OVERVIEW_ASSERTION_MAX = 320;
+function overviewReceiptSupportsClaim(claim, receipt) {
+    if (claim.length > OVERVIEW_ASSERTION_MAX || receipt.length > OVERVIEW_ASSERTION_MAX)
+        return false;
+    const normalize = (value) => value
+        .normalize('NFC')
+        .replace(/\s+/g, ' ')
+        .trim();
+    const normalizedClaim = normalize(claim);
+    return normalizedClaim !== '' && normalizedClaim === normalize(receipt);
+}
+function resolveOverviewRef(ref, claimSpan, reportEvidence, forumThreads) {
+    const record = asRecord(ref);
+    const kind = str(record?.kind);
+    if (kind === 'report_evidence') {
+        const sourceId = str(record?.sourceId);
+        const match = sourceId ? /^RRCP-s(0|[1-9]\d*)$/.exec(sourceId) : null;
+        if (!match)
+            return null;
+        const source = asRecord(reportEvidence[Number(match[1])]);
+        const href = safeReceiptUrl(source?.url);
+        const quote = str(source?.quote);
+        if (!source || !href || !quote || !overviewReceiptSupportsClaim(claimSpan, quote))
+            return null;
+        return `${sourceId} -> ${href}`;
+    }
+    if (kind === 'forum_receipt') {
+        const receiptId = safeId(record?.receiptId);
+        if (!receiptId || !parseReceiptId(receiptId))
+            return null;
+        const matches = forumThreads.flatMap((rawThread) => {
+            const thread = asRecord(rawThread);
+            return asArray(thread?.receipts).flatMap((rawReceipt) => {
+                const receipt = asRecord(rawReceipt);
+                const excerpt = str(receipt?.excerpt);
+                if (str(receipt?.receiptId) !== receiptId ||
+                    !excerpt ||
+                    !hasVisibleContent(excerpt) ||
+                    !overviewReceiptSupportsClaim(claimSpan, excerpt))
+                    return [];
+                const href = safeReceiptUrl(thread?.url);
+                return [`${receiptId}${href
+                        ? ` -> ${href}`
+                        : ` -> cached excerpt: "${safeInline(excerpt, OVERVIEW_ASSERTION_MAX) ?? '[unavailable]'}"`}`];
+            });
+        });
+        return matches.length === 1 ? (matches[0] ?? null) : null;
+    }
+    // A hypothesis is reasoning context, not an external receipt. Interview refs are private.
+    return null;
+}
+function renderOverviewTrust(data) {
+    const reportEvidence = asArray(data.reportEvidence);
+    const forum = asRecord(data.forumResearch);
+    const forumThreads = asArray(forum?.threads);
+    const sections = ['marketOverview', 'communityOverview'].flatMap((key) => {
+        const overview = asRecord(data[key]);
+        const overviewText = str(overview?.text);
+        if (!overview || !overviewText || !hasVisibleContent(overviewText))
+            return [];
+        const rawClaims = asArray(overview.claimSpans);
+        const claimsTruncated = overview.claimSpansTruncated === true || rawClaims.length > MCP_OVERVIEW_SPAN_CAP;
+        const ranges = rawClaims.slice(0, MCP_OVERVIEW_SPAN_CAP).flatMap((rawClaim, claimIndex) => {
+            const claim = asRecord(rawClaim);
+            const span = str(claim?.span);
+            if (!span)
+                return [];
+            const start = overviewText.indexOf(span);
+            if (start < 0 || overviewText.indexOf(span, start + 1) >= 0)
+                return [];
+            return [{ start, end: start + span.length, span, claim, claimIndex }];
+        }).sort((a, b) => a.start - b.start);
+        const lines = [];
+        let cursor = 0;
+        for (const range of ranges) {
+            if (range.start < cursor)
+                continue;
+            const uncovered = overviewText.slice(cursor, range.start);
+            if (/[\p{L}\p{N}]/u.test(uncovered))
+                lines.push(`- Unsourced: "${safeInline(uncovered)}"`);
+            if (str(range.claim?.claimType) === 'inference') {
+                lines.push(`- Inferred: "${safeInline(range.span)}"`);
+                cursor = range.end;
+                continue;
+            }
+            const rawRefs = asArray(range.claim?.evidenceRefs);
+            const refsTruncated = range.claim?.evidenceRefsTruncated === true || rawRefs.length > MCP_OVERVIEW_REF_CAP;
+            const refs = [...new Set(rawRefs.slice(0, MCP_OVERVIEW_REF_CAP)
+                    .map((ref) => resolveOverviewRef(ref, range.span, reportEvidence, forumThreads))
+                    .filter((ref) => Boolean(ref)))];
+            const line = refs.length > 0
+                ? `- Cited (${refs.length}): "${safeInline(range.span, OVERVIEW_ASSERTION_MAX)}" — ${refs.join('; ')}`
+                : `- Unsourced: "${safeInline(range.span)}"`;
+            lines.push(line + overviewCapNote(refsTruncated, MCP_OVERVIEW_REF_CAP, 'evidence-reference positions'));
+            cursor = range.end;
+        }
+        const trailing = overviewText.slice(cursor);
+        if (/[\p{L}\p{N}]/u.test(trailing))
+            lines.push(`- Unsourced: "${safeInline(trailing)}"`);
+        if (lines.length === 0)
+            return [];
+        const heading = key === 'marketOverview' ? 'Market overview trust' : 'Community overview trust';
+        return [`### ${heading}\n${lines.join('\n')}${overviewCapNote(claimsTruncated, MCP_OVERVIEW_SPAN_CAP, 'claim-span positions')}`];
+    });
+    return sections.join('\n\n');
+}
 /**
  * Resolve the single, persona-owned presentation grant behind a GROUNDED claim.
  *
@@ -694,7 +812,26 @@ function renderReportSpine(reportData, channel) {
     const attestedNote = attested > 0 ? ` (of which ${attested} ${ATTESTED_LABEL})` : '';
     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` +
+    // FUL-358 — SAY WHICH POPULATION THE HEADLINE COUNTED.
+    //
+    // The prose below has always explained that a `summary` claim usually restates a `market` or
+    // `competitor` one and "must not be counted as a second independent finding" — while the
+    // headline directly above it counted exactly that. The report markdown in the SAME tool
+    // result scopes its own tally to the market+competitor spine and names it
+    // (`of N market & competitor claims`), so the two numbers arrived side by side looking like
+    // one of them was an arithmetic error. Both are defensible; only one said what it counted.
+    //
+    // The tally still covers every claim — this section is the audit surface, and a graded
+    // summary claim must be visible in it. What is added is the split, so a reader can reconcile
+    // the two headlines instead of choosing between them.
+    const summaryClaims = rows.filter(({ claim }) => asRecord(claim)?.section === 'summary').length;
+    const spineClaims = claims.length - summaryClaims;
+    const populationNote = `\nDENOMINATOR: ${claims.length} = ${spineClaims} market & competitor claim(s) + ` +
+        `${summaryClaims} executive-summary restatement(s). The report markdown above tallies the ` +
+        `${spineClaims} market & competitor claims ONLY, and names that scope; this section tallies ` +
+        'all three sections because it is the audit surface. The two headlines are the same run ' +
+        'counted over two populations, not a discrepancy.';
+    return (`### Report claim spine — ${tallyLine(tally, claims.length)}${attestedNote}${populationNote}\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 ' +
         'the executive summary, graded against the same evidence — so a grounded `summary` claim ' +
@@ -989,8 +1126,14 @@ function renderPersonas(reportData, channel) {
         const seniority = safeInline(priors?.seniority, 80);
         const careerPath = safeInline(priors?.careerPath, 80);
         const provenance = safeInline(persona?.identityProvenance, 200);
+        const hasFrozenPortrait = REPORT_PORTRAIT_PATHS.includes(persona?.portrait);
         const bits = [];
         bits.push(`${plural(sources.length, 'receipt')}`);
+        // State availability, not the path: a raw drift payload must never interpolate an arbitrary
+        // remote URL or an identifier-bearing decoration into agent-visible report text.
+        bits.push(hasFrozenPortrait
+            ? 'frozen portrait decoration available'
+            : 'initials fallback');
         if (insufficient) {
             bits.push(`⚠️ insufficientEvidence${sourcesFound !== null ? ` (only ${sourcesFound} real posts found)` : ''}`);
         }
@@ -1028,6 +1171,58 @@ function renderPersonas(reportData, channel) {
     return (`${header}\n${lines.join('\n')}` +
         capNote(shown.length, personas.length, channel, 'report_data.personas'));
 }
+/**
+ * A literal full-report Community summary. Internal pain-point counts/examples stay available in
+ * structured report_data; they are deliberately not promoted into a user-facing `Threads` column.
+ */
+function renderCommunityPatterns(reportData, channel) {
+    const threads = asArray(asRecord(reportData.forumResearch)?.threads).filter((rawThread) => safeInline(asRecord(rawThread)?.title, MODEL_FRAMING_TEXT_MAX) !== null);
+    if (threads.length === 0)
+        return '';
+    const shown = threads.slice(0, LIST_RENDER_CAP);
+    const lines = shown.map((rawThread) => {
+        const thread = asRecord(rawThread);
+        const sentiment = safeInline(thread?.sentimentSummary, MODEL_FRAMING_TEXT_MAX);
+        const title = safeInline(thread?.title, MODEL_FRAMING_TEXT_MAX) ?? 'Untitled discussion';
+        const theme = readSemanticTheme(thread?.theme, title);
+        const href = safeReceiptUrl(thread?.url);
+        return [
+            `- Theme: ${theme ?? 'not recorded'}`,
+            `  Sentiment: ${sentiment ?? 'not recorded'}`,
+            `  Discussion: ${title}${href ? ` — ${href}` : ''}`,
+        ].join('\n');
+    });
+    return (`### Community patterns — ${plural(threads.length, 'discussion')}\n` +
+        'Themes are producer-authored semantic labels; Discussion preserves the original source title.\n' +
+        lines.join('\n') +
+        capNote(shown.length, threads.length, channel, 'report_data.forumResearch.threads'));
+}
+/**
+ * Current agent Markdown already owns the literal Community rows. Detect only its code-owned,
+ * three-line row grammar so full-report tools do not append the same evidence a second time.
+ * Legacy Markdown lacks this grammar and still receives the compatibility projection above.
+ */
+function hasCurrentCommunityPatternRows(reportMarkdown, reportData) {
+    const expectedRows = asArray(asRecord(reportData.forumResearch)?.threads).filter((rawThread) => safeInline(asRecord(rawThread)?.title, MODEL_FRAMING_TEXT_MAX) !== null).length;
+    if (expectedRows === 0)
+        return false;
+    const lines = reportMarkdown.split('\n');
+    const heading = lines.indexOf('### Relevant Discussions');
+    if (heading < 0)
+        return false;
+    const nextSection = lines.findIndex((line, index) => index > heading && /^#{2,3}\s/u.test(line));
+    const end = nextSection < 0 ? lines.length : nextSection;
+    let foundRows = 0;
+    for (let index = heading + 1; index + 2 < end; index += 1) {
+        if (lines[index]?.startsWith('- **Theme:** ') &&
+            lines[index + 1]?.startsWith('  - **Sentiment:** ') &&
+            lines[index + 2]?.startsWith('  - **Discussion:** ')) {
+            foundRows += 1;
+            index += 2;
+        }
+    }
+    return foundRows === expectedRows;
+}
 /**
  * The anti-sycophancy readout — deterministically computed from the interviews,
  * not model-opined, which is exactly why it belongs in the text: it is the one
@@ -1127,18 +1322,61 @@ function renderSycophancy(reportData, channel) {
  * FUL-263 — before anything rendered them, which is that file's whole premise — so its
  * assertions bit on this change with no fixture edit.
  */
-function hypothesisDetail(result) {
+function hypothesisDetail(result, includeScopeCaveat = true) {
     const statement = safeInline(result?.statement, HYPOTHESIS_STATEMENT_MAX);
     const evidenceReading = safeInline(result?.evidenceReading, HYPOTHESIS_NOTE_MAX);
     return ((statement ? `\n    ${HYPOTHESIS_LABEL}: "${statement}"` : '') +
-        scopeCaveatDetail(result) +
+        (includeScopeCaveat ? scopeCaveatDetail(result) : '') +
+        reliabilityDetail(result) +
         (evidenceReading ? `\n    ${EVIDENCE_READING_LABEL}: ${evidenceReading}` : ''));
 }
+/**
+ * The FUL-358 reliability line — how much to trust this verdict, and how much evidence is
+ * behind it.
+ *
+ * ## Why this section renders a reliability at all, having settled not to render `confidence`
+ *
+ * FUL-614 deliberately withheld the numeric `confidence`: it was model-assigned, and printing
+ * it beside the code-derived survival count invited a reader to average two things that are not
+ * comparable. That reasoning holds and this does not contradict it — `final.confidence` is
+ * itself CODE-DERIVED, from the evidence the row carries and from what these very re-asks did.
+ * It is the same KIND of value as the survival count beside it, which is exactly what the
+ * withheld number was not. The retired numeric field stays withheld.
+ *
+ * Values come from a closed enum, so they cannot forge a line and need no `safeInline`; an
+ * unrecognised value emits nothing rather than being quoted through. A legacy row has no block
+ * and emits nothing — its numeric `confidence` is a different measure and is not restated here.
+ */
+function reliabilityDetail(result) {
+    const final = readFinalHypothesisState(result);
+    if (!final.fromContract)
+        return '';
+    const { confidence, sufficiency, confidenceBasis: basis } = final;
+    const reliability = confidence
+        ? `\`${confidence}\``
+        : basis === 'withheld_no_evidence'
+            ? 'WITHHELD — the run attached no evidence to this hypothesis'
+            : null;
+    if (!reliability && !sufficiency)
+        return '';
+    const parts = [
+        reliability ? `${RELIABILITY_LABEL}: ${reliability}` : null,
+        sufficiency ? `evidence ${sufficiency}` : null,
+    ].filter(Boolean);
+    return `\n    ${parts.join('; ')} (reliability of the verdict, NOT the probability the hypothesis is true)`;
+}
 /** 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}"` : '';
 }
+/** A present, non-null value records an attempted re-test even when its shape is unreadable. */
+function hasRawRobustnessAttempt(result) {
+    return (result !== null &&
+        Object.prototype.hasOwnProperty.call(result, 'robustness') &&
+        result.robustness !== null &&
+        result.robustness !== undefined);
+}
 /**
  * Scope caveats for hypotheses that do not have a robustness row (FUL-626).
  *
@@ -1157,7 +1395,7 @@ function scopeCaveatDetail(result) {
 function renderUnretestedScopeCaveats(reportData) {
     const lines = asArray(reportData.hypothesisResults).flatMap((raw) => {
         const result = asRecord(raw);
-        if (!result || asRecord(result.robustness) !== null)
+        if (!result || hasRawRobustnessAttempt(result))
             return [];
         const detail = scopeCaveatDetail(result);
         if (!detail)
@@ -1340,13 +1578,16 @@ function renderRobustness(reportData, channel) {
     const results = asArray(reportData.hypothesisResults);
     if (results.length === 0)
         return '';
-    const withRobustness = results.filter((raw) => asRecord(asRecord(raw)?.robustness) !== null);
-    if (withRobustness.length === 0) {
+    const renderable = results.filter((raw) => {
+        const result = asRecord(raw);
+        return hasRawRobustnessAttempt(result) || readFinalHypothesisState(result).fromContract;
+    });
+    if (renderable.length === 0) {
         return ('### Hypothesis robustness — NOT RE-TESTED on this run\n' +
             'No verdict was re-asked under a reworded framing, so no verdict above carries a survival ' +
             'count. Treat each as a single-shot answer.');
     }
-    const shown = withRobustness.slice(0, LIST_RENDER_CAP);
+    const shown = renderable.slice(0, LIST_RENDER_CAP);
     const lines = shown.map((raw) => {
         const result = asRecord(raw);
         // FUL-253: a `- ` row whose whole point is the ⚠️ FLIPPED warning. A newline
@@ -1356,43 +1597,62 @@ function renderRobustness(reportData, channel) {
         const id = renderId(result?.hypothesisId);
         const status = safeInline(result?.status, 40) ?? 'unknown';
         const robustness = asRecord(result?.robustness);
-        const survived = num(robustness?.survived);
-        const total = num(robustness?.total);
-        const flipped = tribool(robustness?.flipped);
-        const downgraded = safeInline(robustness?.downgradedStatus, 40);
-        const count = survived !== null && total !== null ? `held ${survived}/${total} framings` : 'survival count unavailable';
+        const counts = readRobustnessCounts(robustness);
+        const reading = readFinalHypothesisState(result);
+        const outcome = reading.robustness;
+        const effectiveVerdict = reading.verdict ?? status;
+        const count = counts ? `held ${counts.survived}/${counts.total} framings` : 'survival count unavailable';
         // Appended to EVERY branch, not just the flipped one. A held verdict is the row a
         // reader is most likely to act on unexamined, so it is the last one that should be
         // identified by an id alone.
-        const detail = hypothesisDetail(result);
-        if (flipped === true) {
+        // A single-shot row's caveat stays in the dedicated un-retested-caveats block below rather
+        // than being duplicated here. Its statement, reliability and evidence reading still belong
+        // on this final-state row.
+        const detail = hypothesisDetail(result, outcome !== 'not_retested');
+        if (outcome === 'not_retested') {
+            return `- ${id}: final verdict \`${effectiveVerdict}\` — NOT RE-TESTED under rephrasing; treat this verdict as a single-shot answer.${detail}`;
+        }
+        if (outcome === 'flipped') {
+            const verdictInstruction = effectiveVerdict === status
+                ? `The final verdict remains \`${effectiveVerdict}\`; the flip lowers its reliability.`
+                : `The verdict to act on is \`${effectiveVerdict}\`, NOT \`${status}\`.`;
             return (`- ${id}: reported \`${status}\` — ⚠️ FLIPPED under rephrasing (${count}). ` +
-                `The verdict to act on is \`${downgraded ?? 'weaker than reported — downgrade unavailable'}\`, NOT \`${status}\`.` +
+                verdictInstruction +
                 detail);
         }
         // An unreadable `flipped` is NOT "held" — say so rather than printing the
         // verdict as if it had survived re-asking.
-        if (flipped === null) {
-            return `- ${id}: reported \`${status}\` — ⚠️ flip status UNREADABLE (${count}); treat this verdict as un-retested.${detail}`;
+        if (outcome === null) {
+            const weakerVerdict = effectiveVerdict !== status
+                ? ` The verdict to act on is \`${effectiveVerdict}\`, NOT \`${status}\`.`
+                : '';
+            return `- ${id}: reported \`${status}\` — ⚠️ flip status UNREADABLE (${count}); the robustness outcome could not be read safely, so do not rely on it.${weakerVerdict}${detail}`;
         }
-        return `- ${id}: \`${status}\` — ${count}${detail}`;
+        return `- ${id}: \`${effectiveVerdict}\` — ${count}${detail}`;
     });
-    const flippedCount = withRobustness.filter((raw) => bool(asRecord(asRecord(raw)?.robustness)?.flipped)).length;
-    const unreadableFlips = withRobustness.filter((raw) => tribool(asRecord(asRecord(raw)?.robustness)?.flipped) === null).length;
+    const outcomes = results.map((raw) => {
+        const result = asRecord(raw);
+        return readFinalHypothesisState(result).robustness;
+    });
+    const flippedCount = outcomes.filter((outcome) => outcome === 'flipped').length;
+    const unreadableFlips = outcomes.filter((outcome) => outcome === null).length;
     // The un-retested hypotheses are counted against the FULL result set, not just
     // the re-tested subset: a bare "no verdict flipped" over a partially-tested run
     // reads as "every verdict survived", when most may never have been re-asked.
-    const untested = results.length - withRobustness.length;
+    const untested = outcomes.filter((outcome) => outcome === 'not_retested').length;
+    const retested = results.length - untested;
     const untestedNote = untested > 0
-        ? ` (${withRobustness.length}/${results.length} verdicts re-tested; the other ${untested} were NOT re-asked — treat those as single-shot)`
+        ? ` (${retested}/${results.length} verdicts re-tested; the other ${untested} were NOT re-asked — treat those as single-shot)`
         : '';
-    const header = flippedCount > 0
-        ? `### Hypothesis robustness — ⚠️ ${flippedCount} verdict(s) flipped under rephrasing${untestedNote}`
-        : unreadableFlips > 0
-            ? `### Hypothesis robustness — ⚠️ flip status UNREADABLE for ${unreadableFlips} verdict(s) (not a clean result)${untestedNote}`
-            : `### Hypothesis robustness — no re-tested verdict flipped${untestedNote}`;
+    const header = untested === results.length
+        ? '### Hypothesis robustness — NOT RE-TESTED on this run'
+        : flippedCount > 0
+            ? `### Hypothesis robustness — ⚠️ ${flippedCount} verdict(s) flipped under rephrasing${untestedNote}`
+            : unreadableFlips > 0
+                ? `### Hypothesis robustness — ⚠️ flip status UNREADABLE for ${unreadableFlips} verdict(s) (not a clean result)${untestedNote}`
+                : `### Hypothesis robustness — no re-tested verdict flipped${untestedNote}`;
     return (`${header}\n${lines.join('\n')}` +
-        capNote(shown.length, withRobustness.length, channel, 'report_data.hypothesisResults'));
+        capNote(shown.length, renderable.length, channel, 'report_data.hypothesisResults'));
 }
 // ---------------------------------------------------------------------------
 // Model-authored framing — prose side of the proof separator (FUL-570)
@@ -1505,6 +1765,109 @@ function renderInsightCrossReferences(reportData) {
     return ('## Insight source cross-references — model-authored findings, code-resolved destinations\n\n' +
         rows.join('\n'));
 }
+function resolveCrossCuttingEvidence(reportData, ref) {
+    if (ref.kind === 'report_evidence') {
+        const sourceId = safeId(ref.sourceId);
+        const match = sourceId ? /^RRCP-s(0|[1-9]\d*)$/.exec(sourceId) : null;
+        const source = match ? asRecord(asArray(reportData.reportEvidence)[Number(match[1])]) : null;
+        if (!source)
+            return null;
+        const label = safeInline(source.platform, MODEL_FRAMING_TEXT_MAX) || 'Web source';
+        const href = safeReceiptUrl(source.url);
+        const quote = safeInline(source.quote, RECEIPT_QUOTE_MAX);
+        if (!href)
+            return null;
+        return `${label}${href ? ` — ${href}` : ''}${quote ? `\n    > ${quote}` : ''}`;
+    }
+    if (ref.kind === 'forum_receipt') {
+        const receiptId = safeId(ref.receiptId);
+        if (!receiptId)
+            return null;
+        const matches = asArray(asRecord(reportData.forumResearch)?.threads).flatMap((threadRaw) => {
+            const thread = asRecord(threadRaw);
+            return asArray(thread?.receipts).flatMap((receiptRaw) => {
+                const receipt = asRecord(receiptRaw);
+                return safeId(receipt?.receiptId) === receiptId ? [{ thread, receipt }] : [];
+            });
+        });
+        if (matches.length !== 1)
+            return null;
+        const match = matches[0];
+        const label = safeInline(match.thread?.platform, MODEL_FRAMING_TEXT_MAX) || 'Community source';
+        const href = safeReceiptUrl(match.thread?.url);
+        const quote = safeInline(match.receipt?.excerpt, RECEIPT_QUOTE_MAX);
+        if (!quote)
+            return null;
+        return `${label}${href ? ` — ${href}` : ''}${quote ? `\n    > ${quote}` : ''}`;
+    }
+    if (ref.kind === 'interview_quote_v2') {
+        const interviewId = safeId(ref.interviewId);
+        const quoteId = safeId(ref.quoteId);
+        if (!interviewId || !quoteId)
+            return null;
+        const matches = asArray(reportData.interviewHighlights).flatMap((highlightRaw) => {
+            const highlight = asRecord(highlightRaw);
+            const evidence = asRecord(highlight?.evidenceReference);
+            if (safeId(evidence?.interviewId) !== interviewId)
+                return [];
+            return asArray(evidence?.quotes).flatMap((quoteRaw) => {
+                const quote = asRecord(quoteRaw);
+                return safeId(quote?.quoteId) === quoteId ? [{ highlight, quote }] : [];
+            });
+        });
+        if (matches.length !== 1)
+            return null;
+        const match = matches[0];
+        const persona = safeInline(match.highlight?.personaName, MODEL_FRAMING_TEXT_MAX) || 'Persona';
+        const quote = safeInline(match.quote?.text, RECEIPT_QUOTE_MAX);
+        return quote ? `Synthetic interview · ${persona}\n    > ${quote}` : null;
+    }
+    return null;
+}
+function renderCrossCuttingFindings(reportData) {
+    if (!Object.prototype.hasOwnProperty.call(reportData, 'crossCuttingFindings'))
+        return '';
+    const rows = asArray(reportData.crossCuttingFindings).slice(0, 5).flatMap((rawFinding) => {
+        const finding = asRecord(rawFinding);
+        const claim = safeInline(finding?.claim, MODEL_FRAMING_TEXT_MAX);
+        const why = safeInline(finding?.whyItMatters, MODEL_FRAMING_TEXT_MAX);
+        const confidence = safeInline(finding?.confidence, 12);
+        if (!claim || !why || !confidence || !['low', 'medium', 'high'].includes(confidence))
+            return [];
+        const rawRefs = asArray(finding?.evidenceRefs).slice(0, 8);
+        const resolvedRefs = rawRefs.flatMap((rawRef) => {
+            const ref = asRecord(rawRef);
+            const rendered = ref ? resolveCrossCuttingEvidence(reportData, ref) : null;
+            return ref && rendered ? [{ ref, rendered }] : [];
+        });
+        const methods = new Set(resolvedRefs.flatMap(({ ref }) => ref.kind === 'report_evidence' ? ['web']
+            : ref.kind === 'forum_receipt' ? ['forum']
+                : ref.kind === 'interview_quote_v2' ? ['interview'] : []));
+        const uniqueRefs = new Set(resolvedRefs.map(({ ref }) => JSON.stringify(ref)));
+        if (rawRefs.length < 2 || resolvedRefs.length !== rawRefs.length || uniqueRefs.size < 2 || methods.size < 2)
+            return [];
+        const evidence = resolvedRefs.map(({ rendered }) => `  - Evidence: ${rendered}`);
+        return [[
+                `- ${claim}`,
+                `  - Why it matters: ${why}`,
+                `  - Confidence: ${confidence}`,
+                ...evidence,
+            ].join('\n')];
+    });
+    return rows.length > 0
+        ? `## Cross-cutting findings\n\n${rows.join('\n')}`
+        : '## Cross-cutting findings\n\nNo cross-cutting finding met the evidence bar.';
+}
+function removeLegacyInsightOutput(markdown) {
+    return markdown
+        .replace(/^## (?:Key )?Insights(?: \(legacy\))?\s*\n[\s\S]*?(?=^## |$(?![\s\S]))/gm, '')
+        .replace(/^## Cross-cutting findings\s*\n[\s\S]*?(?=^## |$(?![\s\S]))/gm, '')
+        .replace(/\n{3,}/g, '\n\n')
+        .trimEnd();
+}
+function labelLegacyInsightOutput(markdown) {
+    return markdown.replace(/^## (?:Key )?Insights$/gm, '## Insights (legacy)');
+}
 /**
  * The approved model-authored context block.
  *
@@ -1667,48 +2030,26 @@ function renderMarketSizing(reportData) {
     const market = asRecord(asRecord(reportData.webResearch)?.marketData);
     if (!market)
         return '';
-    const raw = asArray(market.marketSizing);
     const reportClaims = asArray(reportData.reportClaims).map(asRecord).filter((v) => v !== null);
     const reportEvidence = asArray(reportData.reportEvidence);
-    const supported = resolveSupportedMarketSizing(raw, reportClaims, reportEvidence);
-    const labels = { tam: 'TAM', sam: 'SAM', som: 'SOM' };
-    const scopes = ['tam', 'sam', 'som'];
-    const lines = scopes.map((scope) => {
-        const contenders = supported.map(asRecord).filter((entry) => entry?.scope === scope);
-        if (contenders.length !== 1)
-            return `- ${labels[scope]}: — (Not established)`;
-        const entry = contenders[0];
-        const value = num(entry.value);
-        const currency = safeInline(entry.currency, 3);
-        const period = safeInline(entry.period, 60);
-        const geography = safeInline(entry.geography, 120);
-        const audience = safeInline(entry.audience, 160);
-        if (!value || !currency?.match(/^[A-Z]{3}$/) || !period || !geography || !audience) {
-            return `- ${labels[scope]}: — (Not established)`;
-        }
-        if (entry.evidenceState === 'source_stated') {
-            return `- ${labels[scope]}: ${currency} ${value} [Cited] — ${geography}; ${audience}; ${period}`;
-        }
-        const derivation = asRecord(entry.derivation);
-        const inputs = asArray(derivation?.inputs).map(asRecord);
-        const formula = safeInline(derivation?.formula, 240);
-        if (entry.evidenceState !== 'derived' || derivation?.operation !== 'multiply' || !formula || inputs.length < 2 || inputs.some((input) => !input)) {
-            return `- ${labels[scope]}: — (Not established)`;
-        }
-        const validInputs = inputs.filter((input) => input !== null);
-        const sameBoundary = validInputs.every((input) => input.kind === 'ratio_assumption' || (input.period === entry.period && input.geography === entry.geography && input.audience === entry.audience));
-        const inputValues = validInputs.map((input) => num(input.value));
-        const oneCurrency = validInputs.filter((input) => input.kind === 'currency' && input.currency === currency).length === 1;
-        const product = inputValues.every((input) => input !== null)
-            ? inputValues.reduce((total, input) => total * input, 1)
-            : Number.NaN;
-        if (!sameBoundary || !oneCurrency || !Number.isFinite(product) || Math.abs(product - value) > Math.max(0.01, value * 1e-9)) {
-            return `- ${labels[scope]}: — (Not established)`;
-        }
-        const assumptions = asArray(derivation.assumptions).map((item) => safeInline(item, 160)).filter(Boolean);
-        return `- ${labels[scope]}: ${currency} ${value} [Estimate / Inferred] — ${geography}; ${audience}; ${period}; method: ${formula}${assumptions.length ? `; assumptions: ${assumptions.join('; ')}` : ''}`;
+    const signals = resolveMarketSignals(market.marketSignals, asArray(market.marketSizing), reportClaims, reportEvidence);
+    if (signals.length === 0)
+        return '### Market signals\nNo cited market signals were established.';
+    const lines = signals.map((signal) => {
+        const context = safeInline(signal.context, 360) ?? 'Context unavailable';
+        const sources = (signal.sources ?? (signal.source ? [signal.source] : []))
+            .map((source) => safeInline(source.url, 240))
+            .filter((url) => Boolean(url));
+        const citations = sources.length > 0 ? ` ← ${sources.join(', ')}` : '';
+        if (signal.kind !== 'size')
+            return `- ${signal.label}: ${context} [Cited]${citations}`;
+        const formula = safeInline(signal.formula, 240);
+        const assumptions = (signal.assumptions ?? []).map((item) => safeInline(item, 160)).filter(Boolean);
+        return `- ${signal.label}: ${signal.currency} ${signal.value} — ${context}` +
+            (formula ? ` [Estimate / Inferred]; method: ${formula}${assumptions.length ? `; assumptions: ${assumptions.join('; ')}` : ''}` : ' [Cited]') +
+            citations;
     });
-    return `### TAM / SAM / SOM — typed sizing\n${lines.join('\n')}`;
+    return `### Market signals\n${lines.join('\n')}`;
 }
 /**
  * The Reddit community-evidence rail's typed outcome (FUL-685 / T8, D6).
@@ -1923,6 +2264,7 @@ export function buildTrustDigest(reportData, channel) {
     const sections = [
         renderPersonaSpine(data, channel),
         renderReportSpine(data, channel),
+        renderOverviewTrust(data),
         renderMarketSizing(data),
         renderCompetitorSourceQuality(data),
         // FUL-685: immediately above the pool the accepted rows land in, so a reader meets the
@@ -2015,11 +2357,67 @@ export function composeReportText(reportMarkdown, reportData, channel) {
     const rationale = renderVerdictRationale(reportData);
     const framing = renderModelFraming(reportData);
     const data = asRecord(reportData);
-    const insightReferences = data ? renderInsightCrossReferences(data) : '';
+    const markdownTitle = reportMarkdown.startsWith('# ')
+        ? reportMarkdown.slice(2, reportMarkdown.indexOf('\n') >= 0 ? reportMarkdown.indexOf('\n') : undefined)
+        : undefined;
+    const safeTitle = data?.reportTitle === undefined
+        ? normalizeLegacyMcpHeading(markdownTitle)
+        : escapeMcpMarkdownHeading(sanitizeMcpReportTitle(data.reportTitle));
+    const titledReportMarkdown = reportMarkdown.startsWith('# ')
+        ? `# ${safeTitle}${reportMarkdown.includes('\n') ? reportMarkdown.slice(reportMarkdown.indexOf('\n')) : ''}`
+        : reportMarkdown;
+    const hasCrossCutting = Boolean(data && Object.prototype.hasOwnProperty.call(data, 'crossCuttingFindings'));
+    const safeReportMarkdown = hasCrossCutting
+        ? removeLegacyInsightOutput(titledReportMarkdown)
+        : labelLegacyInsightOutput(titledReportMarkdown);
+    const insightReferences = data && !hasCrossCutting ? renderInsightCrossReferences(data) : '';
+    const crossCutting = data && hasCrossCutting ? renderCrossCuttingFindings(data) : '';
+    // Community themes, sentiment, and source titles are producer/source-authored framing, not
+    // machine-checked claims. Keep them above the authority separator while preserving the literal
+    // Theme → Sentiment → Discussion contract for every full-report caller.
+    const communityPatterns = data && !hasCurrentCommunityPatternRows(safeReportMarkdown, data)
+        ? renderCommunityPatterns(data, channel)
+        : '';
     // 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}${insightReferences ? `\n\n${insightReferences}` : ''}${framing ? `\n\n${framing}` : ''}${rationale ? `\n\n${rationale}` : ''}` +
+        `${safeReportMarkdown}${insightReferences ? `\n\n${insightReferences}` : ''}${crossCutting ? `\n\n${crossCutting}` : ''}${communityPatterns ? `\n\n${communityPatterns}` : ''}${framing ? `\n\n${framing}` : ''}${rationale ? `\n\n${rationale}` : ''}` +
         `\n\n---\n\n${buildTrustDigest(reportData, channel)}`);
 }
+/** Keep a model-authored structured title inert when replacing the report Markdown H1. */
+function escapeMcpMarkdownHeading(value) {
+    if (/(?:\b[a-z][a-z0-9+.-]{1,31}:\/\/|\bwww\.|[^\s@]+@[^\s@]+)/i.test(value)) {
+        const longestRun = (value.match(/`+/g) ?? []).reduce((n, run) => Math.max(n, run.length), 0);
+        const fence = '`'.repeat(longestRun + 1);
+        const pad = value.startsWith('`') || value.endsWith('`') ? ' ' : '';
+        return `${fence}${pad}${value}${pad}${fence}`;
+    }
+    return value
+        .replace(/[\\`*_[\]~&]/g, '\\$&')
+        .replace(/<(?=[a-zA-Z/?!])/g, '\\<')
+        .replace(/#+$/, (run) => run.replace(/#/g, '\\#'));
+}
+/** Normalize producer-escaped legacy H1 text before applying the current inert-heading rules. */
+function normalizeLegacyMcpHeading(value) {
+    if (typeof value !== 'string')
+        return 'Report';
+    const serialized = value
+        .replace(/[\p{Cc}\p{Cf}]/gu, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!serialized)
+        return 'Report';
+    const openingFence = /^`+/.exec(serialized)?.[0];
+    const closingFence = /`+$/.exec(serialized)?.[0];
+    if (openingFence && closingFence?.length === openingFence.length && serialized.length >= openingFence.length * 2) {
+        const inner = serialized.slice(openingFence.length, -openingFence.length);
+        const innerRuns = inner.match(/`+/g) ?? [];
+        if (innerRuns.every((run) => run.length < openingFence.length)) {
+            const visible = /^ .* $/.test(inner) && /\S/.test(inner) ? inner.slice(1, -1) : inner;
+            return sanitizeMcpMarkdownTitle(visible) === visible ? serialized : 'Report';
+        }
+    }
+    const plain = serialized.replace(/\\([\\`*_[\]~&<#])/g, '$1');
+    return escapeMcpMarkdownHeading(sanitizeMcpMarkdownTitle(plain));
+}
 //# sourceMappingURL=report-digest.js.map