@clien-ai/mcp 0.12.0 → 0.12.1

package/dist/tools/report-digest.js

@@ -50,8 +50,10 @@ import { collapseWhitespace, safeInline, safeId, clipReceiptQuote, containsSpan,
 import { canonicalContentType, contentTypeDeviationLine, contentTypeProvenanceLine, } from './content-type-display.js';
 import { readFinalHypothesisState } from './hypothesis-final.js';
 import { readRobustnessCounts } from '../hypothesis-semantics.js';
-import { resolveSourceReceipt } from './receipt-children.js';
-import { resolveSupportedMarketSizing } from './market-sizing-proof.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
@@ -307,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;
         }
@@ -322,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.
  *
@@ -1012,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)` : ''}`);
         }
@@ -1051,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
@@ -1593,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.
  *
@@ -1755,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).
@@ -2011,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
@@ -2103,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