@clien-ai/mcp 0.13.0 → 0.13.2

package/dist/types/report.js

@@ -12,7 +12,7 @@
  * — see how research.ts handles it.
  */
 import { z } from 'zod';
-import { CONFIDENCE_BASES, CONFIDENCE_LEVELS, EVIDENCE_SUFFICIENCY_LEVELS, HYPOTHESIS_PRIORITIES, HYPOTHESIS_SEMANTICS_VERSION, ROBUSTNESS_OUTCOMES, VERDICT_STATUSES, hasCoherentRobustnessWorking, normalizeFinalHypothesisState, readRobustnessCounts, robustnessWorkingContradictsSummary, } from '../hypothesis-semantics.js';
+import { CONFIDENCE_BASES, CONFIDENCE_LEVELS, EVIDENCE_SUFFICIENCY_LEVELS, HYPOTHESIS_PRIORITIES, HYPOTHESIS_SEMANTICS_VERSION, LEGACY_HYPOTHESIS_SEMANTICS_VERSION, ROBUSTNESS_OUTCOMES, VERDICT_STATUSES, finalClauseCoverageMatchesIntegrity, hasCoherentRobustnessWorking, hypothesisWebReceiptAuthenticates, normalizeFinalHypothesisState, readRobustnessCounts, reportClaimNeedsIndependentMarketAuthority, robustnessWorkingContradictsSummary, sourceAuthenticatesMarketEconomics, } from '../hypothesis-semantics.js';
 // ⚠️ A types module importing from `tools/` reads backwards, and it is deliberate.
 // `content-type-display.ts` imports NOTHING — it is the package's content-type vocabulary, which
 // happens to live beside the two renderers that were its first callers, and the FUL-341 coupling
@@ -21,6 +21,7 @@ import { CONFIDENCE_BASES, CONFIDENCE_LEVELS, EVIDENCE_SUFFICIENCY_LEVELS, HYPOT
 import { CONTENT_TYPE_EXCLUSIONS, CONTENT_TYPE_STATES } from '../tools/content-type-display.js';
 import { parseReceiptId } from '../tools/receipt-children.js';
 import { readSemanticTheme } from './semantic-theme.js';
+import { isDisplaySuitableExcerpt } from '../lib/excerpt-suitability.js';
 export { CONFIDENCE_BASES, CONFIDENCE_LEVELS, EVIDENCE_SUFFICIENCY_LEVELS, HYPOTHESIS_SEMANTICS_VERSION, ROBUSTNESS_OUTCOMES, VERDICT_STATUSES, } from '../hypothesis-semantics.js';
 /**
  * A competitor discovered during the research run.
@@ -264,13 +265,14 @@ export const RobustnessResultSchema = z
  */
 export const FinalHypothesisStateSchema = z
     .object({
-    version: z.literal(HYPOTHESIS_SEMANTICS_VERSION).describe('Which semantics contract this block was written under.'),
+    version: z.union([z.literal(1), z.literal(HYPOTHESIS_SEMANTICS_VERSION)]).describe('Which semantics contract this block was written under.'),
     verdict: z.enum(VERDICT_STATUSES).describe('The EFFECTIVE verdict every surface shows. A robustness downgrade is applied only when it makes a strictly weaker claim, so a malformed re-ask block can never upgrade a row.'),
     originalVerdict: z.enum(VERDICT_STATUSES).describe('The synthesiser\'s own verdict, preserved for audit even when the row was downgraded.'),
     confidence: z.enum(CONFIDENCE_LEVELS).optional().describe('How reliable the final verdict is. ABSENT means withheld — see confidenceBasis. Never a probability that the hypothesis is true.'),
     confidenceBasis: z.enum(CONFIDENCE_BASES).describe('Why confidence says what it says: read off the evidence, recomputed after the verdict flipped under rephrasing, or withheld because the run attached no evidence.'),
     sufficiency: z.enum(EVIDENCE_SUFFICIENCY_LEVELS).describe('How much evidence sits behind the verdict, across how many research methods. A coverage axis, independent of which way the verdict pointed.'),
     robustness: z.enum(ROBUSTNESS_OUTCOMES).describe('What the robustness pass did: held, flipped, or never re-asked. `not_retested` is explicit — it is not the same as held.'),
+    clauseCoverage: z.enum(['complete', 'uncovered', 'contradicted', 'invalid']).optional(),
     priority: z.enum(HYPOTHESIS_PRIORITIES).optional().catch(undefined).describe('The product priority of the underlying hypothesis, for ranking what to go and ask about first.'),
 })
     .passthrough();
@@ -289,6 +291,8 @@ export const EvidenceSchema = z
     summary: z.string(),
     details: z.string().optional(),
     url: z.string().optional(),
+    nominationId: z.string().regex(/^wh2:[a-f0-9]{16}$/).optional(),
+    receipt: z.object({ sourceId: z.string(), quoteSpan: z.string() }).optional(),
 })
     .passthrough();
 /**
@@ -305,6 +309,20 @@ export const HypothesisResultSchema = z
     confidence: z.number().describe('Legacy numeric confidence stored on either the retired 0-1 or 0-100 scale. Preserve and label it as legacy; never compare it with final.confidence, rank on it, or trend it.'),
     supportingEvidence: z.array(EvidenceSchema).optional(),
     contradictingEvidence: z.array(EvidenceSchema).optional(),
+    clauseCoverage: z.array(z.object({
+        clauseId: z.string(),
+        status: z.enum(['supported', 'contradicted', 'uncovered']),
+        evidenceRefs: z.array(z.object({ side: z.enum(['supporting', 'contradicting']), index: z.number().int().min(0) })),
+    })).optional(),
+    clauseIntegrity: z.object({
+        outcome: z.enum(['complete', 'uncovered', 'contradicted', 'invalid']),
+        clauses: z.array(z.object({
+            clauseId: z.string(),
+            text: z.string(),
+            status: z.enum(['supported', 'contradicted', 'uncovered']),
+            evidenceRefs: z.array(z.object({ side: z.enum(['supporting', 'contradicting']), index: z.number().int().min(0) })),
+        })),
+    }).optional(),
     robustness: RobustnessResultSchema.optional().describe('Robustness re-ask survival count for this verdict (absent on legacy reports / when not re-tested).'),
     scopeCaveat: z.string().optional().describe('Belief-adjacent scope-mismatch note (FUL-102): present when this hypothesis\'s persona support came from a persona speaking outside its credibility domain. Treat such support as directional, not grounded.'),
     final: FinalHypothesisStateSchema.optional().describe('THE effective result (FUL-358) — verdict, reliability, evidence sufficiency and robustness outcome, reconciled once and read by every surface. Prefer `final.verdict` over `status` and `final.confidence` over the numeric `confidence` above. Absent on legacy reports, where the numeric `confidence` is the retired measure.'),
@@ -447,7 +465,7 @@ export const InsightSchema = z
  * way), but every OTHER typed field on that report loses its typing too. Which is why
  * this list grows in the SAME change as the agent's, never "when someone notices".
  */
-export const OPEN_QUESTION_STATUSES = ['never_asked', 'nobody_answered', 'voices_disagreed'];
+export const OPEN_QUESTION_STATUSES = ['never_asked', 'nobody_answered', 'voices_disagreed', 'clause_uncovered'];
 /**
  * One thing the run did not settle. MIRROR of the agent's `OpenQuestionSchema`
  * (`agent/src/types.ts`); key set pinned by the coupling test.
@@ -468,6 +486,7 @@ export const OpenQuestionSchema = z
     status: z
         .enum(OPEN_QUESTION_STATUSES)
         .describe('WHY it is still open: never_asked (the run never touched it), nobody_answered (put to personas, none took a position), voices_disagreed (the personas split).'),
+    clauseId: z.string().optional().describe('Stable clause ID for clause_uncovered provenance.'),
     // Lenient `z.number()` against the agent's `z.number().int().min(0)`, deliberately.
     // This is the one field on the row the app is willing to degrade: its parser clamps a
     // count the run's own persona roster cannot support down to 0 and renders the
@@ -478,7 +497,12 @@ export const OpenQuestionSchema = z
         .number()
         .describe('How many DISTINCT personas were PUT this hypothesis — an interview counts when it returned a finding on it OR when the persona\'s brief claimed it, because a persona who was asked and said nothing was still asked. 0 for never_asked by construction; for nobody_answered it is what makes the row specific ("3 were asked; none took a position") rather than a vague claim of silence.'),
 })
-    .passthrough();
+    .passthrough()
+    .superRefine((row, ctx) => {
+    if (row.status === 'clause_uncovered' && !row.clauseId) {
+        ctx.addIssue({ code: 'custom', path: ['clauseId'], message: 'Uncovered clauses require a clause ID' });
+    }
+});
 /**
  * Persona identity priors (Exa Rail M5b, FUL-150 / U10). The demographic shape of
  * a persona's role — an explicit seniority RUNG + a career trajectory — force-filled
@@ -641,7 +665,7 @@ export const ReportClaimSchema = z
  */
 export const ReportEvidenceSchema = z
     .object({
-    section: ReportClaimSectionSchema,
+    section: z.enum([...REPORT_CLAIM_SECTIONS, 'hypothesis']),
     url: z.string().describe('Live URL the highlight was collected from.'),
     platform: z.string().describe('The host the highlight came from.'),
     quote: z.string().describe('Verbatim cached excerpt (≤600 chars) so a market/competitor figure renders even if the URL later 404s.'),
@@ -666,6 +690,8 @@ export const ReportEvidenceSchema = z
         ' Stamped from the source by code, never model-emitted. ABSENT means UNCLASSIFIED: the ' +
         'source type is genuinely unknown, NOT checked and found benign. ' +
         CONTENT_TYPE_EXCLUSIONS),
+    publisherSubjectRelationship: z.enum(['independent', 'self', 'unknown']).optional(),
+    marketEconomicsAuthority: z.enum(['independent', 'commercial_report_seller', 'unknown']).optional(),
 })
     .passthrough();
 /**
@@ -837,6 +863,12 @@ export const MethodologyNoteSchema = z
     totalTokensUsed: z.number(),
     jobDurationSeconds: z.number(),
     saturation: SaturationNoteSchema.optional(),
+    evidenceOutcome: z
+        .object({ code: z.literal('bounded_search_no_admissible_evidence') })
+        .strict()
+        .optional()
+        .catch(undefined)
+        .describe('Bounded acquisition completed without admissible external evidence.'),
     // FUL-685 (T8 / D6). `.catch(undefined)` and not merely `.optional()`: a malformed or
     // unrecognised value must degrade THIS FIELD to unrecorded, never reject an otherwise valid
     // legacy report — the same fail-soft-per-field posture `personasSynthesis` takes.
@@ -928,6 +960,7 @@ export const ReportOverviewSchema = z.object({
  */
 export const ResearchReportDataSchema = z
     .object({
+    hypothesisSemanticsVersion: z.number().optional(),
     competitors: z.array(CompetitorSchema).optional(),
     hypotheses: z.array(z.unknown()).optional(),
     /**
@@ -1122,20 +1155,101 @@ export function projectReportDataForMcp(raw) {
         value.replace(/[\p{C}\p{Z}\p{Default_Ignorable_Code_Point}]/gu, '').length > 0;
     const hasHighlights = Object.prototype.hasOwnProperty.call(record, 'interviewHighlights');
     const hasHypothesisResults = Object.prototype.hasOwnProperty.call(record, 'hypothesisResults');
+    const hasClaims = Object.prototype.hasOwnProperty.call(record, 'claims');
+    const hasReportClaims = Object.prototype.hasOwnProperty.call(record, 'reportClaims');
+    const hasReportEvidence = Object.prototype.hasOwnProperty.call(record, 'reportEvidence');
     const hasReportTitle = Object.prototype.hasOwnProperty.call(record, 'reportTitle');
     const hasOverview = Object.prototype.hasOwnProperty.call(record, 'marketOverview') ||
         Object.prototype.hasOwnProperty.call(record, 'communityOverview');
     const hasCrossCutting = Object.prototype.hasOwnProperty.call(record, 'crossCuttingFindings');
     const hasPersonas = Object.prototype.hasOwnProperty.call(record, 'personas');
     const hasForumResearch = Object.prototype.hasOwnProperty.call(record, 'forumResearch');
+    const hasHypothesisSemanticsVersion = Object.prototype.hasOwnProperty.call(record, 'hypothesisSemanticsVersion');
     const methodology = record.methodology;
     const hasRedditNote = methodology !== null &&
         typeof methodology === 'object' &&
         !Array.isArray(methodology) &&
         Object.prototype.hasOwnProperty.call(methodology, 'redditRetrieval');
-    if (!hasHighlights && !hasRedditNote && !hasHypothesisResults && !hasOverview && !hasReportTitle && !hasCrossCutting && !hasPersonas && !hasForumResearch)
+    if (!hasHighlights && !hasRedditNote && !hasHypothesisResults && !hasClaims && !hasReportClaims && !hasReportEvidence && !hasOverview && !hasReportTitle && !hasCrossCutting && !hasPersonas && !hasForumResearch && !hasHypothesisSemanticsVersion)
         return raw;
     const projected = { ...record };
+    // Source excerpts are immutable evidence in storage, but every MCP channel is a display
+    // surface. Rebuild only the containers which can carry verbatim source text, preserving safe
+    // strings byte-for-byte and omitting an unsafe exact receipt rather than repairing its text.
+    const projectReceipts = (value) => {
+        if (!Array.isArray(value))
+            return undefined;
+        const safeReceipts = [];
+        for (const rawReceipt of value) {
+            const receipt = asProjectionRecord(rawReceipt);
+            if (!receipt || typeof receipt.excerpt !== 'string')
+                return undefined;
+            if (isDisplaySuitableExcerpt(receipt.excerpt))
+                safeReceipts.push({ ...receipt });
+        }
+        return safeReceipts;
+    };
+    const projectSource = (rawSource) => {
+        const source = asProjectionRecord(rawSource);
+        if (!source)
+            return rawSource;
+        const next = { ...source };
+        if (Object.prototype.hasOwnProperty.call(source, 'quote')) {
+            if (typeof source.quote === 'string' && !isDisplaySuitableExcerpt(source.quote)) {
+                // `undefined` is absent on the JSON wire but remains distinguishable from a historical
+                // source which never had a quote, so renderers can downgrade the dependent receipt.
+                next.quote = undefined;
+            }
+            else if (typeof source.quote !== 'string') {
+                delete next.quote;
+            }
+        }
+        if (Object.prototype.hasOwnProperty.call(source, 'receipts')) {
+            const receipts = projectReceipts(source.receipts);
+            if (receipts === undefined)
+                delete next.receipts;
+            else
+                next.receipts = receipts;
+        }
+        return next;
+    };
+    if (hasReportEvidence) {
+        projected.reportEvidence = Array.isArray(record.reportEvidence)
+            ? record.reportEvidence.map(projectSource)
+            : [];
+    }
+    const reportEvidence = Array.isArray(projected.reportEvidence) ? projected.reportEvidence : [];
+    const rejectedMarketEconomics = (Array.isArray(record.reportClaims) ? record.reportClaims : [])
+        .some((rawClaim) => {
+        const claim = asProjectionRecord(rawClaim);
+        if (!claim || !reportClaimNeedsIndependentMarketAuthority(claim.section, claim.text))
+            return false;
+        const state = claim.state;
+        const attestation = asProjectionRecord(claim.attestation);
+        const sourceId = state === 'GROUNDED'
+            ? claim.sourceId
+            : state === 'NO_RECEIPT' && hasProjectionVisibleContent(attestation?.quote)
+                ? attestation?.sourceId
+                : null;
+        const match = typeof sourceId === 'string' ? /^RRCP-s(0|[1-9]\d*)$/.exec(sourceId) : null;
+        const source = match ? asProjectionRecord(reportEvidence[Number(match[1])]) : null;
+        return Boolean(source && !sourceAuthenticatesMarketEconomics(source));
+    });
+    if (rejectedMarketEconomics)
+        delete projected.recommendations;
+    let clauseSemanticsFailure = false;
+    const outerVersion = record.hypothesisSemanticsVersion;
+    const outerVersionPresent = hasHypothesisSemanticsVersion;
+    const rawHypothesisRows = Array.isArray(record.hypothesisResults) ? record.hypothesisResults : [];
+    const rawRowsClaimV2 = rawHypothesisRows.some((rawRow) => {
+        const row = asProjectionRecord(rawRow);
+        return asProjectionRecord(row?.final)?.version === HYPOTHESIS_SEMANTICS_VERSION ||
+            (row !== null && Object.prototype.hasOwnProperty.call(row, 'clauseIntegrity'));
+    });
+    const requiresClauseIntegrity = rawRowsClaimV2 || (outerVersionPresent && outerVersion !== LEGACY_HYPOTHESIS_SEMANTICS_VERSION);
+    if (requiresClauseIntegrity && rawHypothesisRows.length === 0) {
+        clauseSemanticsFailure = true;
+    }
     if (hasReportTitle)
         projected.reportTitle = sanitizeMcpReportTitle(record.reportTitle);
     // Validate the frozen decoration before either the typed parse or raw schema-drift exit.
@@ -1147,6 +1261,10 @@ export function projectReportDataForMcp(raw) {
             if (!persona)
                 return rawPersona;
             const nextPersona = { ...persona };
+            if (Array.isArray(persona.sources))
+                nextPersona.sources = persona.sources.map(projectSource);
+            else if (Object.prototype.hasOwnProperty.call(persona, 'sources'))
+                delete nextPersona.sources;
             const portrait = ReportPortraitSchema.safeParse(persona.portrait);
             if (portrait.success)
                 nextPersona.portrait = portrait.data;
@@ -1174,6 +1292,19 @@ export function projectReportDataForMcp(raw) {
                     if (!thread)
                         return rawThread;
                     const nextThread = { ...thread };
+                    if (Array.isArray(thread.relevantQuotes)) {
+                        nextThread.relevantQuotes = thread.relevantQuotes.filter(isDisplaySuitableExcerpt);
+                    }
+                    else if (Object.prototype.hasOwnProperty.call(thread, 'relevantQuotes')) {
+                        delete nextThread.relevantQuotes;
+                    }
+                    if (Object.prototype.hasOwnProperty.call(thread, 'receipts')) {
+                        const receipts = projectReceipts(thread.receipts);
+                        if (receipts === undefined)
+                            delete nextThread.receipts;
+                        else
+                            nextThread.receipts = receipts;
+                    }
                     const theme = typeof thread.title === 'string'
                         ? readSemanticTheme(thread.theme, thread.title)
                         : null;
@@ -1195,6 +1326,105 @@ export function projectReportDataForMcp(raw) {
             delete projected.forumResearch;
         }
     }
+    const projectionSupportsSpan = (excerpt, span) => {
+        if (!isDisplaySuitableExcerpt(excerpt))
+            return false;
+        if (span === undefined || span === null)
+            return true;
+        if (typeof span !== 'string')
+            return false;
+        const normalize = (value) => value
+            .normalize('NFC')
+            .replace(/\s+/gu, ' ')
+            .trim()
+            .toLocaleLowerCase('en-US');
+        const normalizedSpan = normalize(span);
+        return normalizedSpan.length > 0 && normalize(excerpt).includes(normalizedSpan);
+    };
+    const omitClaimReceipt = (claim) => {
+        const next = { ...claim };
+        delete next.sourceId;
+        delete next.receiptId;
+        delete next.quoteSpan;
+        delete next.attestation;
+        return next;
+    };
+    if (hasReportClaims) {
+        projected.reportClaims = Array.isArray(record.reportClaims)
+            ? record.reportClaims.map((rawClaim) => {
+                const claim = asProjectionRecord(rawClaim);
+                if (!claim)
+                    return rawClaim;
+                if (claim.state === 'GROUNDED') {
+                    const hasSourceId = Object.prototype.hasOwnProperty.call(claim, 'sourceId');
+                    const match = typeof claim.sourceId === 'string'
+                        ? /^RRCP-s(0|[1-9]\d*)$/.exec(claim.sourceId)
+                        : null;
+                    const rawSource = match
+                        ? asProjectionRecord(Array.isArray(record.reportEvidence)
+                            ? record.reportEvidence[Number(match[1])]
+                            : undefined)
+                        : null;
+                    if (!hasSourceId && Object.prototype.hasOwnProperty.call(claim, 'quoteSpan')) {
+                        return omitClaimReceipt(claim);
+                    }
+                    if (hasSourceId && (!rawSource || !projectionSupportsSpan(rawSource.quote, claim.quoteSpan))) {
+                        return omitClaimReceipt(claim);
+                    }
+                }
+                else if (claim.state === 'NO_RECEIPT') {
+                    const attestation = asProjectionRecord(claim.attestation);
+                    if (attestation && !isDisplaySuitableExcerpt(attestation.quote)) {
+                        const next = { ...claim };
+                        delete next.attestation;
+                        return next;
+                    }
+                }
+                return { ...claim };
+            })
+            : [];
+    }
+    if (Object.prototype.hasOwnProperty.call(record, 'claims')) {
+        projected.claims = Array.isArray(record.claims)
+            ? record.claims.map((rawClaim) => {
+                const claim = asProjectionRecord(rawClaim);
+                if (!claim || claim.state !== 'GROUNDED')
+                    return rawClaim;
+                const hasSourceId = Object.prototype.hasOwnProperty.call(claim, 'sourceId');
+                const match = typeof claim.sourceId === 'string'
+                    ? /^RCP-p(0|[1-9]\d*)-s(0|[1-9]\d*)$/.exec(claim.sourceId)
+                    : null;
+                const personas = Array.isArray(record.personas) ? record.personas : [];
+                const persona = match ? asProjectionRecord(personas[Number(match[1])]) : null;
+                const sources = Array.isArray(persona?.sources) ? persona.sources : [];
+                const source = match ? asProjectionRecord(sources[Number(match[2])]) : null;
+                if (!hasSourceId && Object.prototype.hasOwnProperty.call(claim, 'quoteSpan')) {
+                    return omitClaimReceipt(claim);
+                }
+                if (hasSourceId && !source)
+                    return omitClaimReceipt(claim);
+                if (!source)
+                    return { ...claim };
+                const receipts = Array.isArray(source.receipts) ? source.receipts : [];
+                const hasReceiptId = Object.prototype.hasOwnProperty.call(claim, 'receiptId');
+                if (hasReceiptId) {
+                    const matches = receipts.filter((rawReceipt) => asProjectionRecord(rawReceipt)?.receiptId === claim.receiptId);
+                    const receipt = matches.length === 1 ? asProjectionRecord(matches[0]) : null;
+                    return receipt && projectionSupportsSpan(receipt.excerpt, claim.quoteSpan)
+                        ? { ...claim }
+                        : omitClaimReceipt(claim);
+                }
+                if (typeof source.quote === 'string' &&
+                    !projectionSupportsSpan(source.quote, claim.quoteSpan)) {
+                    return omitClaimReceipt(claim);
+                }
+                if (claim.quoteSpan !== undefined && typeof source.quote !== 'string') {
+                    return omitClaimReceipt(claim);
+                }
+                return { ...claim };
+            })
+            : [];
+    }
     const projectOverviewRef = (rawRef) => {
         if (rawRef === null || typeof rawRef !== 'object' || Array.isArray(rawRef))
             return null;
@@ -1243,6 +1473,32 @@ export function projectReportDataForMcp(raw) {
                 const safeRef = projectOverviewRef(rawRef);
                 if (!safeRef)
                     continue;
+                if (safeRef.kind === 'report_evidence') {
+                    const match = typeof safeRef.sourceId === 'string'
+                        ? /^RRCP-s(0|[1-9]\d*)$/.exec(safeRef.sourceId)
+                        : null;
+                    const source = match
+                        ? asProjectionRecord(Array.isArray(projected.reportEvidence)
+                            ? projected.reportEvidence[Number(match[1])]
+                            : undefined)
+                        : null;
+                    if (!source || !projectionSupportsSpan(source.quote, claim.span))
+                        continue;
+                }
+                if (safeRef.kind === 'forum_receipt') {
+                    const matches = (Array.isArray(asProjectionRecord(projected.forumResearch)?.threads)
+                        ? asProjectionRecord(projected.forumResearch).threads
+                        : []).flatMap((rawThread) => {
+                        const thread = asProjectionRecord(rawThread);
+                        return (Array.isArray(thread?.receipts) ? thread.receipts : []).filter((rawReceipt) => {
+                            const receipt = asProjectionRecord(rawReceipt);
+                            return receipt !== null && receipt.receiptId === safeRef.receiptId &&
+                                projectionSupportsSpan(receipt.excerpt, claim.span);
+                        });
+                    });
+                    if (matches.length !== 1)
+                        continue;
+                }
                 const refKey = safeRef.kind === 'report_evidence'
                     ? `${safeRef.kind}:${safeRef.sourceId}`
                     : safeRef.kind === 'forum_receipt'
@@ -1258,13 +1514,13 @@ export function projectReportDataForMcp(raw) {
             return [{
                     span: claim.span,
                     claimType: claim.claimType,
-                    evidenceRefsTruncated: rawEvidenceRefs.length > MCP_OVERVIEW_REF_CAP,
+                    evidenceRefsTruncated: claim.evidenceRefsTruncated === true || rawEvidenceRefs.length > MCP_OVERVIEW_REF_CAP,
                     evidenceRefs,
                 }];
         });
         projected[key] = {
             text: overviewRecord.text,
-            claimSpansTruncated: overviewRecord.claimSpans.length > MCP_OVERVIEW_SPAN_CAP,
+            claimSpansTruncated: overviewRecord.claimSpansTruncated === true || overviewRecord.claimSpans.length > MCP_OVERVIEW_SPAN_CAP,
             claimSpans,
         };
     }
@@ -1285,22 +1541,24 @@ export function projectReportDataForMcp(raw) {
         const resolvesCrossCuttingRef = (ref) => {
             if (ref.kind === 'report_evidence') {
                 const match = /^RRCP-s(0|[1-9]\d*)$/.exec(ref.sourceId ?? '');
-                const source = match && asProjectionRecord(Array.isArray(record.reportEvidence)
-                    ? record.reportEvidence[Number(match[1])]
+                const source = match && asProjectionRecord(Array.isArray(projected.reportEvidence)
+                    ? projected.reportEvidence[Number(match[1])]
                     : undefined);
                 return Boolean(source &&
                     safeProjectionUrl(source.url) &&
+                    (!Object.prototype.hasOwnProperty.call(source, 'quote') ||
+                        isDisplaySuitableExcerpt(source.quote)) &&
                     (source.section === 'market' || source.section === 'competitor' || source.section === 'summary'));
             }
             if (ref.kind === 'forum_receipt') {
-                const matches = (Array.isArray(asProjectionRecord(record.forumResearch)?.threads)
-                    ? asProjectionRecord(record.forumResearch).threads
+                const matches = (Array.isArray(asProjectionRecord(projected.forumResearch)?.threads)
+                    ? asProjectionRecord(projected.forumResearch).threads
                     : []).flatMap((rawThread) => {
                     const thread = asProjectionRecord(rawThread);
                     return (Array.isArray(thread?.receipts) ? thread.receipts : []).filter((rawReceipt) => {
                         const receipt = asProjectionRecord(rawReceipt);
                         return Boolean(receipt && receipt.receiptId === ref.receiptId &&
-                            hasProjectionVisibleContent(receipt.excerpt));
+                            isDisplaySuitableExcerpt(receipt.excerpt));
                     });
                 });
                 return matches.length === 1;
@@ -1357,18 +1615,110 @@ export function projectReportDataForMcp(raw) {
     }
     if (hasHypothesisResults && Array.isArray(record.hypothesisResults)) {
         projected.hypothesisResults = record.hypothesisResults.map((rawRow) => {
-            if (rawRow === null || typeof rawRow !== 'object' || Array.isArray(rawRow))
+            if (rawRow === null || typeof rawRow !== 'object' || Array.isArray(rawRow)) {
+                if (requiresClauseIntegrity)
+                    clauseSemanticsFailure = true;
                 return rawRow;
+            }
             const row = rawRow;
             const safeRow = { ...row };
             let changed = false;
-            if (Object.prototype.hasOwnProperty.call(row, 'final')) {
-                const normalized = normalizeFinalHypothesisState(row);
+            let evidenceSemanticsFailure = false;
+            const integrityClauses = asProjectionRecord(row.clauseIntegrity)?.clauses;
+            for (const key of ['supportingEvidence', 'contradictingEvidence']) {
+                if (!Array.isArray(row[key])) {
+                    if (Object.prototype.hasOwnProperty.call(row, key)) {
+                        // A schema-drift fallback must not forward a malformed evidence container whose
+                        // nested shape bypasses the per-item raw nomination scrub below.
+                        delete safeRow[key];
+                        changed = true;
+                    }
+                    continue;
+                }
+                const side = key === 'supportingEvidence' ? 'supporting' : 'contradicting';
+                safeRow[key] = row[key].flatMap((rawEvidence, evidenceIndex) => {
+                    const evidence = asProjectionRecord(rawEvidence);
+                    if (!evidence) {
+                        // Dropping the item also invalidates index-based clause refs; preserving the old
+                        // working could make the next evidence row inherit a removed row's authority.
+                        evidenceSemanticsFailure = true;
+                        return [];
+                    }
+                    const safeEvidence = { ...evidence };
+                    // These are model-owned nomination fields on every evidence shape, even when `source`
+                    // is absent, malformed, or lies about the method. They never cross the MCP boundary.
+                    delete safeEvidence.url;
+                    delete safeEvidence.nominationId;
+                    if (evidence.source !== 'web_research') {
+                        // Only web evidence can carry a producer-granted report receipt. A model-authored
+                        // pointer on any other method is inert and must not cross either MCP exit.
+                        delete safeEvidence.receipt;
+                    }
+                    else if (Object.prototype.hasOwnProperty.call(evidence, 'receipt')) {
+                        const linkedClauses = Array.isArray(integrityClauses)
+                            ? integrityClauses.flatMap((rawClause) => {
+                                const clause = asProjectionRecord(rawClause);
+                                const text = typeof clause?.text === 'string' ? clause.text : null;
+                                const refs = Array.isArray(clause?.evidenceRefs) ? clause.evidenceRefs : [];
+                                const linked = refs.some((rawRef) => {
+                                    const ref = asProjectionRecord(rawRef);
+                                    return ref?.side === side && ref.index === evidenceIndex;
+                                });
+                                return linked && text ? [text] : [];
+                            })
+                            : [];
+                        const authenticatesEveryLinkedClause = linkedClauses.length > 0 && linkedClauses.every((text) => hypothesisWebReceiptAuthenticates(evidence, text, row.category, record));
+                        if (!authenticatesEveryLinkedClause) {
+                            delete safeEvidence.receipt;
+                            // An unreferenced receipt is inert model decoration. A referenced one is the
+                            // producer-owned basis of clauseIntegrity, so rejecting it invalidates that working.
+                            if (linkedClauses.length > 0)
+                                evidenceSemanticsFailure = true;
+                        }
+                    }
+                    return [safeEvidence];
+                });
+                changed = true;
+            }
+            // A rejected source/span cannot leave a sibling producer-owned coverage block claiming that
+            // same evidence completed a clause. Preserve the row and evidence prose, but remove the
+            // unauthenticated working and force the final block through the current fail-closed state.
+            if (evidenceSemanticsFailure) {
+                delete safeRow.clauseIntegrity;
+                changed = true;
+            }
+            const finalVersion = asProjectionRecord(row.final)?.version;
+            const rowClaimsCurrentSemantics = finalVersion === HYPOTHESIS_SEMANTICS_VERSION ||
+                Object.prototype.hasOwnProperty.call(row, 'clauseIntegrity');
+            const clauseIntegrityMismatch = finalVersion === HYPOTHESIS_SEMANTICS_VERSION &&
+                !finalClauseCoverageMatchesIntegrity(safeRow, record);
+            const semanticsMismatch = (rowClaimsCurrentSemantics && outerVersion !== HYPOTHESIS_SEMANTICS_VERSION) || (outerVersionPresent && (outerVersion === HYPOTHESIS_SEMANTICS_VERSION
+                ? finalVersion !== HYPOTHESIS_SEMANTICS_VERSION
+                : outerVersion === LEGACY_HYPOTHESIS_SEMANTICS_VERSION
+                    ? finalVersion !== undefined && finalVersion !== LEGACY_HYPOTHESIS_SEMANTICS_VERSION
+                    : true));
+            if (clauseIntegrityMismatch || semanticsMismatch) {
+                delete safeRow.clauseIntegrity;
+                changed = true;
+            }
+            if (Object.prototype.hasOwnProperty.call(row, 'final') || semanticsMismatch) {
+                const rowForNormalization = semanticsMismatch || clauseIntegrityMismatch
+                    ? { ...safeRow, final: { version: HYPOTHESIS_SEMANTICS_VERSION } }
+                    : safeRow;
+                const normalized = normalizeFinalHypothesisState(rowForNormalization);
+                if (semanticsMismatch ||
+                    clauseIntegrityMismatch ||
+                    normalized?.clauseCoverage === 'invalid' ||
+                    (normalized?.clauseCoverage !== undefined &&
+                        normalized.clauseCoverage !== 'complete' &&
+                        normalized.originalVerdict !== normalized.verdict) ||
+                    (requiresClauseIntegrity && normalized === null))
+                    clauseSemanticsFailure = true;
                 if (normalized)
                     safeRow.final = normalized;
                 else
                     delete safeRow.final;
-                changed = safeRow.final !== row.final;
+                changed ||= safeRow.final !== row.final;
             }
             const rawRobustness = row.robustness;
             const robustnessRecord = rawRobustness !== null &&
@@ -1415,6 +1765,11 @@ export function projectReportDataForMcp(raw) {
             return safeRow;
         });
     }
+    if (clauseSemanticsFailure) {
+        projected.executiveSummary = 'This run did not establish every material part of at least one hypothesis. Treat the affected hypotheses as unresolved.';
+        projected.verdictSummary = projected.executiveSummary;
+        delete projected.recommendations;
+    }
     // ⚠️ FUL-685 — THE REDDIT NOTE IS PROJECTED HERE FOR THE SAME REASON `researchTaskId` IS:
     // `prepareReportDataForMcp` returns this projection UNPARSED when the full schema drifts, so a
     // field stripped only by `RedditRetrievalNoteSchema` would come straight back on that path — and