noteconnection 1.8.0 → 1.9.0

package/dist/src/learning/answerReleaseReview.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.reviewAnswerRelease = reviewAnswerRelease;
+const graphAnswerCoverage_1 = require("./graphAnswerCoverage");
+const graphAnswerFacts_1 = require("./graphAnswerFacts");
 const ragPublicText_1 = require("./ragPublicText");
+const ragEvidenceQuality_1 = require("./ragEvidenceQuality");
+const answerTaskPlan_1 = require("./answerTaskPlan");
 const INTERNAL_DIAGNOSTIC_FRAGMENTS = [
     'No scoped knowledge points matched',
     'retrieval_candidates_below_threshold',
@@ -41,8 +45,6 @@ const STRUCTURED_UNIT_ALIASES = {
     年: 'year',
 };
 const STRUCTURED_FACT_PATTERN = /(-?\d{1,4}(?:,\d{3})*(?:\.\d+)?)(?:\s*(kg\/m(?:³|3)|gpa|mpa|kpa|pa|km\/h|m\/s|km|cm|mm|ml|mb|gb|tb|kw|mw|%|percent|percentage|years?|yrs?|yr|year|°c|℃|℉|年))?/giu;
-const ANSWER_RELEASE_PUBLIC_CHAR_LIMIT = 900;
-const ANSWER_RELEASE_SENTENCE_BUDGET = 6;
 const DEFINITION_EVIDENCE_HIGHLIGHT_LIMIT = 2;
 const RAG_CLAIM_CITATION_SUPPORT_MIN_FEATURES = 2;
 const RAG_CLAIM_CITATION_SUPPORT_MIN_COVERAGE = 0.78;
@@ -95,6 +97,31 @@ const STRUCTURED_ANCHOR_STOPWORDS = new Set([
     '和',
     '的',
 ]);
+const QUERY_SUBJECT_STOPWORDS = new Set([
+    'a',
+    'an',
+    'the',
+    'and',
+    'are',
+    'be',
+    'definition',
+    'define',
+    'does',
+    'how',
+    'is',
+    'meaning',
+    'of',
+    'what',
+    'which',
+    'who',
+    'with',
+    '我',
+    '应该',
+    '通过',
+    '哪些',
+    '知识点',
+    '学习',
+]);
 const POLARITY_SENTENCE_SPLIT_PATTERN = /[.!?\u3002\uFF01\uFF1F;\n\r]+/u;
 const ENGLISH_POLARITY_NEGATION_PATTERN = /\b(?:not|never|no|none|cannot|is not|are not|was not|were not|do not|does not|did not|can not|could not|should not|would not|will not)\b/i;
 const CHINESE_POLARITY_NEGATION_PATTERN = /不是|并非|并不|没有|不能|无法/u;
@@ -108,12 +135,38 @@ const STATE_FRAME_SKIP_VALUE_PATTERN = /\b(?:prerequisite|before|after|depends?\
 function normalizeWhitespace(value) {
     return String(value || '').replace(/\s+/g, ' ').trim();
 }
+function normalizePublicAnswerSurface(value) {
+    return (0, answerTaskPlan_1.formatDisplayMathBlocks)(String(value || '')
+        .replace(/\r\n?/gu, '\n')
+        .replace(/[ \t]+\n/gu, '\n')
+        .replace(/\n{3,}/gu, '\n\n')
+        .trim());
+}
+function isCompoundLearningDefinitionQuery(message) {
+    const normalized = normalizeWhitespace(String(message || '')).toLowerCase();
+    return isDefinitionIntentQuery(normalized)
+        && (/\b(?:learn|learning|study|knowledge\s+points?)\b/u.test(normalized)
+            || /学习|知识点|学哪些|通过哪些/u.test(normalized));
+}
 function escapeRegExp(value) {
     return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 function containsCjk(value) {
     return /[\u3400-\u9fff]/u.test(String(value || ''));
 }
+function useChineseAnswerLanguage(context, additionalSignals = []) {
+    if (context.answerLanguage === 'zh') {
+        return true;
+    }
+    if (context.answerLanguage === 'en') {
+        return false;
+    }
+    return containsCjk([
+        context.message,
+        context.draftAnswer,
+        ...additionalSignals,
+    ].filter(Boolean).join(' '));
+}
 function resolveScopeLabel(scope) {
     if (scope.workspaceId) {
         return String(scope.workspaceId).trim();
@@ -129,11 +182,11 @@ function resolveScopeLabel(scope) {
     }
     return '';
 }
-function buildFriendlyScopeFailureHint(scope) {
+function buildFriendlyScopeFailureHint(scope, useChinese) {
     const scopeLabel = resolveScopeLabel(scope);
     const readinessStatus = String(scope.readiness?.status || '').trim();
     const missReason = String(scope.missDiagnostics?.reason || '').trim();
-    if (containsCjk(scopeLabel) || containsCjk(scope.missDiagnostics?.query || '')) {
+    if (useChinese) {
         if (readinessStatus === 'empty_store') {
             return scopeLabel
                 ? `当前范围“${scopeLabel}”还没有可检索知识。`
@@ -192,10 +245,11 @@ function buildFriendlyScopeFailureHint(scope) {
         ? `I could not ground the answer inside the current scope "${scopeLabel}".`
         : 'I could not ground the answer inside the current scope.';
 }
-function buildAbstentionAnswer(message, scope) {
-    const normalizedMessage = normalizeWhitespace(message);
-    const hint = buildFriendlyScopeFailureHint(scope);
-    if (containsCjk(normalizedMessage)) {
+function buildAbstentionAnswer(context) {
+    const normalizedMessage = normalizeWhitespace(context.message);
+    const useChinese = useChineseAnswerLanguage(context);
+    const hint = buildFriendlyScopeFailureHint(context.usedScope, useChinese);
+    if (useChinese) {
         return normalizeWhitespace(normalizedMessage
             ? `${hint} 我暂时不能对“${normalizedMessage}”给出有依据的回答。请换个说法、放宽范围，或补充相关笔记。`
             : `${hint} 请换个说法、放宽范围，或补充相关笔记。`);
@@ -205,6 +259,20 @@ function buildAbstentionAnswer(message, scope) {
         : `${hint} Refine the wording, widen the scope, or add the missing note.`);
 }
 function buildGroundedRevisionAnswer(context) {
+    const conflictPlanClaims = (context.graphAnswerPlan?.claims || [])
+        .filter((claim) => claim.required)
+        .map((claim) => String(claim.statement || '').trim())
+        .filter(Boolean);
+    const hasConflictEvidence = context.ragSufficiencyReview?.degradationState === 'conflict'
+        || (context.ragSufficiencyReview?.reasons || []).some((reason) => String(reason || '').includes('conflict_evidence_present'));
+    if (hasConflictEvidence && conflictPlanClaims.length > 1) {
+        const useChinese = useChineseAnswerLanguage(context, conflictPlanClaims);
+        const sentences = [];
+        conflictPlanClaims.forEach((claim) => appendRevisionAnswerSentence(sentences, claim, useChinese));
+        if (sentences.length > 0) {
+            return sentences.join(useChinese ? '' : ' ');
+        }
+    }
     const ragGroundedAnswer = buildRagGroundedRevisionAnswer(context);
     if (ragGroundedAnswer) {
         return ragGroundedAnswer;
@@ -223,12 +291,11 @@ function buildGroundedRevisionAnswer(context) {
     const baseAnswer = summary && title && !summaryAlreadyCarriesTitle
         ? `${title}: ${summary}`
         : (summary || title || normalizeWhitespace(context.draftAnswer));
-    const useChinese = containsCjk([
-        context.message,
+    const useChinese = useChineseAnswerLanguage(context, [
         title,
         summary,
         context.graphContext?.anchorTitle || '',
-    ].join(' '));
+    ]);
     return expandAnswerWithGraphContext(baseAnswer, context, useChinese);
 }
 function stripTerminalSentencePunctuation(value) {
@@ -322,41 +389,12 @@ function removeLeadingEvidenceTitle(value, title) {
     const escapedTitle = escapeRegExp(normalizedTitle);
     return normalizeWhitespace(normalized.replace(new RegExp(`^#{0,6}\\s*${escapedTitle}\\s*[:：-]?\\s*`, 'iu'), ''));
 }
-function isPublicEvidenceClauseBoundary(value, index) {
-    const char = value[index];
-    if (char === '\n' || char === '\r' || char === ';' || char === '；') {
-        return true;
-    }
-    if (char === '.' && /\d/u.test(value[index - 1] || '') && /\d/u.test(value[index + 1] || '')) {
-        return false;
-    }
-    return /[.!?。！？]/u.test(char);
-}
-function splitPublicEvidenceClauses(value) {
-    const source = String(value || '');
-    if (!source) {
-        return [];
-    }
-    const clauses = [];
-    let start = 0;
-    for (let index = 0; index < source.length; index += 1) {
-        if (!isPublicEvidenceClauseBoundary(source, index)) {
-            continue;
-        }
-        clauses.push(source.slice(start, index));
-        start = index + 1;
-    }
-    if (start < source.length) {
-        clauses.push(source.slice(start));
-    }
-    return clauses;
-}
 function selectPublicEvidenceClause(snippet, title) {
     const cleaned = removeLeadingEvidenceTitle(stripMarkdownScaffolding(snippet), title);
     if (!cleaned) {
         return '';
     }
-    const clauses = splitPublicEvidenceClauses(cleaned)
+    const clauses = (0, ragEvidenceQuality_1.segmentRagEvidenceClauses)(cleaned)
         .map((clause) => normalizeWhitespace(clause))
         .map((clause) => (0, ragPublicText_1.naturalizeRagPublicEvidenceClause)(clause))
         .filter((clause) => (clause.length >= 8
@@ -365,9 +403,66 @@ function selectPublicEvidenceClause(snippet, title) {
         && !isPromptArtifactClause(clause)
         && !/^[:：\-–—]+$/u.test(clause)));
     const selected = clauses[0] || cleaned;
-    return selected.length > 120
-        ? `${selected.slice(0, 118).trim()}...`
-        : selected;
+    if (!hasBalancedPublicMathDelimiters(selected)) {
+        return '';
+    }
+    return selectCompletePublicEvidenceBoundary(selected);
+}
+const PUBLIC_EVIDENCE_MAX_CHARS = 480;
+const PUBLIC_EVIDENCE_HARD_MAX_CHARS = 720;
+function hasBalancedPublicMathDelimiters(value) {
+    const source = String(value || '');
+    const displayMathCount = (source.match(/(?<!\\)\$\$/gu) || []).length;
+    if (displayMathCount % 2 !== 0) {
+        return false;
+    }
+    const inlineSource = source.replace(/(?<!\\)\$\$/gu, '');
+    const inlineMathCount = (inlineSource.match(/(?<!\\)\$/gu) || []).length;
+    return inlineMathCount % 2 === 0;
+}
+function selectCompletePublicEvidenceBoundary(value) {
+    const normalized = normalizeWhitespace(value);
+    if (normalized.length <= PUBLIC_EVIDENCE_MAX_CHARS) {
+        return normalized;
+    }
+    let inlineMathOpen = false;
+    let displayMathOpen = false;
+    const boundaries = [];
+    for (let index = 0; index < normalized.length; index += 1) {
+        const character = normalized[index];
+        if (character === '\\') {
+            index += 1;
+            continue;
+        }
+        if (character === '$') {
+            if (normalized[index + 1] === '$') {
+                displayMathOpen = !displayMathOpen;
+                index += 1;
+            }
+            else if (!displayMathOpen) {
+                inlineMathOpen = !inlineMathOpen;
+            }
+            continue;
+        }
+        if (!inlineMathOpen
+            && !displayMathOpen
+            && /[.!?\u3002\uFF01\uFF1F]/u.test(character)
+            && !(character === '.'
+                && /\d/u.test(normalized[index - 1] || '')
+                && /\d/u.test(normalized[index + 1] || ''))
+            && (index + 1 >= normalized.length || /\s/u.test(normalized[index + 1]))) {
+            boundaries.push(index + 1);
+        }
+    }
+    const boundedBoundary = boundaries
+        .filter((boundary) => boundary <= PUBLIC_EVIDENCE_MAX_CHARS)
+        .pop()
+        || boundaries.find((boundary) => boundary <= PUBLIC_EVIDENCE_HARD_MAX_CHARS);
+    if (!boundedBoundary) {
+        return '';
+    }
+    const complete = normalizeWhitespace(normalized.slice(0, boundedBoundary));
+    return hasBalancedPublicMathDelimiters(complete) ? complete : '';
 }
 function collectDefinitionEvidenceHighlights(context) {
     const leadingPoint = context.knowledgePoints[0];
@@ -433,39 +528,6 @@ function buildRevisionGraphConnectionSentence(context, useChinese) {
     }
     return `The strongest graph path runs through ${pathTitles.join(' -> ')}`;
 }
-function normalizeRevisionGraphComparableTitle(value) {
-    return normalizeDefinitionEvidenceTitle(value).toLowerCase();
-}
-function collectRevisionGraphWindowTitles(graphContext, windowKey, limit) {
-    if (!graphContext || !Array.isArray(graphContext[windowKey])) {
-        return [];
-    }
-    const anchorProfile = graphContext.anchorGraphProfile && typeof graphContext.anchorGraphProfile === 'object'
-        ? graphContext.anchorGraphProfile
-        : null;
-    const anchorAtomId = normalizeWhitespace(String(graphContext.anchorAtomId || anchorProfile?.atomId || '').trim());
-    const anchorTitle = normalizeRevisionGraphComparableTitle(graphContext.anchorTitle || anchorProfile?.title || '');
-    const seen = new Set();
-    const titles = [];
-    for (const node of graphContext[windowKey] || []) {
-        const atomId = normalizeWhitespace(String(node && node.atomId || '').trim());
-        const title = normalizeDefinitionEvidenceTitle(node && node.title);
-        const comparableTitle = normalizeRevisionGraphComparableTitle(title);
-        if (!title || (atomId && atomId === anchorAtomId) || (comparableTitle && comparableTitle === anchorTitle)) {
-            continue;
-        }
-        const key = comparableTitle || atomId;
-        if (seen.has(key)) {
-            continue;
-        }
-        seen.add(key);
-        titles.push(title);
-        if (titles.length >= limit) {
-            break;
-        }
-    }
-    return titles;
-}
 function buildRevisionGraphProfileSentence(context, useChinese) {
     const graphContext = context.graphContext;
     if (!graphContext) {
@@ -474,48 +536,15 @@ function buildRevisionGraphProfileSentence(context, useChinese) {
     const anchorProfile = graphContext.anchorGraphProfile && typeof graphContext.anchorGraphProfile === 'object'
         ? graphContext.anchorGraphProfile
         : null;
-    const anchorTitle = normalizeDefinitionEvidenceTitle(graphContext.anchorTitle || anchorProfile?.title || '');
-    const predecessorTitles = collectRevisionGraphWindowTitles(graphContext, 'predecessorWindow', 2);
-    const successorTitles = collectRevisionGraphWindowTitles(graphContext, 'successorWindow', 2);
-    const degreeParts = [];
-    const inDegree = anchorProfile ? Number(anchorProfile.inDegree) : NaN;
-    const outDegree = anchorProfile ? Number(anchorProfile.outDegree) : NaN;
-    if (Number.isFinite(inDegree)) {
-        degreeParts.push(useChinese ? `入度为 ${inDegree}` : `${inDegree} incoming`);
-    }
-    if (Number.isFinite(outDegree)) {
-        degreeParts.push(useChinese ? `出度为 ${outDegree}` : `${outDegree} outgoing`);
-    }
-    if (degreeParts.length <= 0 && predecessorTitles.length <= 0 && successorTitles.length <= 0) {
+    const facts = (0, graphAnswerFacts_1.collectGraphAnswerFacts)(graphContext, {
+        anchorAtomId: graphContext.anchorAtomId || anchorProfile?.atomId || '',
+        anchorTitle: graphContext.anchorTitle || anchorProfile?.title || '',
+        normalizeTitle: normalizeDefinitionEvidenceTitle,
+    });
+    if (!facts) {
         return '';
     }
-    if (useChinese) {
-        const fragments = [];
-        if (degreeParts.length > 0) {
-            fragments.push(`${anchorTitle || '当前锚点'}在当前图中的${degreeParts.join('，')}`);
-        }
-        if (predecessorTitles.length > 0) {
-            fragments.push(`紧邻前置节点包括 ${predecessorTitles.join('、')}`);
-        }
-        if (successorTitles.length > 0) {
-            fragments.push(`后续分支包括 ${successorTitles.join('、')}`);
-        }
-        return fragments.join('，');
-    }
-    const fragments = [];
-    if (degreeParts.length > 0) {
-        fragments.push(`${anchorTitle || 'The current anchor'} has ${degreeParts.join(' and ')} links in the current graph`);
-    }
-    if (predecessorTitles.length > 0 && successorTitles.length > 0) {
-        fragments.push(`its immediate predecessors include ${predecessorTitles.join(', ')}, and likely next nodes include ${successorTitles.join(', ')}`);
-    }
-    else if (predecessorTitles.length > 0) {
-        fragments.push(`its immediate predecessors include ${predecessorTitles.join(', ')}`);
-    }
-    else if (successorTitles.length > 0) {
-        fragments.push(`its likely next nodes include ${successorTitles.join(', ')}`);
-    }
-    return fragments.join('; ');
+    return (0, graphAnswerFacts_1.formatGraphAnswerProfileSentence)(facts, useChinese);
 }
 function expandAnswerWithGraphContext(baseAnswer, context, useChinese, extraSentences = []) {
     const sentences = [];
@@ -523,13 +552,13 @@ function expandAnswerWithGraphContext(baseAnswer, context, useChinese, extraSent
     extraSentences.forEach((sentence) => appendRevisionAnswerSentence(sentences, sentence, useChinese));
     appendRevisionAnswerSentence(sentences, buildRevisionGraphConnectionSentence(context, useChinese), useChinese);
     appendRevisionAnswerSentence(sentences, buildRevisionGraphProfileSentence(context, useChinese), useChinese);
-    return sentences.slice(0, ANSWER_RELEASE_SENTENCE_BUDGET).join(useChinese ? '' : ' ');
+    return sentences.join(useChinese ? '' : ' ');
 }
 function expandRagGroundedAnswer(baseAnswer, useChinese, evidenceSentences = []) {
     const sentences = [];
     appendRevisionAnswerSentence(sentences, baseAnswer, useChinese);
     evidenceSentences.forEach((sentence) => appendRevisionAnswerSentence(sentences, sentence, useChinese));
-    return sentences.slice(0, ANSWER_RELEASE_SENTENCE_BUDGET).join(useChinese ? '' : ' ');
+    return sentences.join(useChinese ? '' : ' ');
 }
 function hasUsableRagEvidenceContext(context) {
     const pack = context.ragContextPack;
@@ -651,7 +680,7 @@ function splitRagPublicEvidenceClauses(fragment, options = {}) {
     if (!cleaned) {
         return [];
     }
-    const clauses = splitPublicEvidenceClauses(cleaned)
+    const clauses = (0, ragEvidenceQuality_1.segmentRagEvidenceClauses)(cleaned)
         .map((clause) => normalizeWhitespace(clause))
         .map((clause) => (0, ragPublicText_1.naturalizeRagPublicEvidenceClause)(clause))
         .filter((clause) => (clause.length >= 8
@@ -678,6 +707,7 @@ function collectRagPublicEvidenceClauses(context, roles, limit, excludedClauses
                 clause,
                 queryTerms: collectRagPublicClauseQueryTerms(clause, queryTerms),
                 headingQueryTerms,
+                qualityScore: (0, ragEvidenceQuality_1.scoreRagEvidenceClause)(clause).score,
                 order,
             });
             order += 1;
@@ -698,10 +728,13 @@ function collectRagPublicEvidenceClauses(context, roles, limit, excludedClauses
         if (rightScore !== leftScore) {
             return rightScore - leftScore;
         }
+        if (right.qualityScore !== left.qualityScore) {
+            return right.qualityScore - left.qualityScore;
+        }
         return left.order - right.order;
     });
     rankedCandidates.forEach((candidate) => {
-        if (clauses.length >= limit || ragClauseAlreadyCovered(candidate.clause, selected)) {
+        if ((limit !== undefined && clauses.length >= limit) || ragClauseAlreadyCovered(candidate.clause, selected)) {
             return;
         }
         selected.push(candidate.clause);
@@ -709,33 +742,6 @@ function collectRagPublicEvidenceClauses(context, roles, limit, excludedClauses
     });
     return clauses;
 }
-function ragRevisionDirectClauseLimit(profile) {
-    if (profile === 'compare') {
-        return 1;
-    }
-    if (profile === 'how_to') {
-        return 3;
-    }
-    if (profile === 'causal') {
-        return 2;
-    }
-    return 1;
-}
-function ragRevisionDocumentClauseLimit(profile) {
-    if (profile === 'compare') {
-        return 2;
-    }
-    if (profile === 'how_to' || profile === 'causal') {
-        return 2;
-    }
-    return 2;
-}
-function ragRevisionGraphClauseLimit(profile) {
-    if (profile === 'compare' || profile === 'how_to' || profile === 'causal') {
-        return 2;
-    }
-    return 1;
-}
 function ragRevisionDocumentClauseOptions(profile, queryTerms) {
     if (profile === 'compare') {
         return {
@@ -775,36 +781,39 @@ function ragRevisionGraphClauseOptions(profile, queryTerms) {
         minimumLeafHeadingTermCount: queryTerms.length >= 3 ? queryTerms.length : 0,
     };
 }
+function hasPlannedGraphAnswerClaims(context) {
+    return (context.graphAnswerPlan?.claims || []).some((claim) => (normalizeWhitespace(String(claim.statement || '')).length > 0));
+}
 function buildRagGroundedRevisionAnswer(context) {
-    if (!hasUsableRagEvidenceContext(context)) {
+    if (hasPlannedGraphAnswerClaims(context) || !hasUsableRagEvidenceContext(context)) {
         return '';
     }
-    const useChinese = containsCjk([
-        context.message,
-        context.draftAnswer,
+    const useChinese = useChineseAnswerLanguage(context, [
         context.graphContext?.anchorTitle || '',
         ...(context.ragContextPack?.fragments || []).slice(0, 4).map((fragment) => fragment.text),
-    ].join(' '));
+    ]);
     const queryTerms = extractRagPublicQueryTerms(context.message);
     const profile = resolveRagPublicAnswerProfile(context.message);
     const isCompareQuery = profile === 'compare';
+    const rejectAnswerControlClause = ragPublicText_1.shouldRejectPublicEvidenceClause;
     const rejectCompareProcedureClause = isCompareQuery
-        ? (clause) => (0, ragPublicText_1.shouldRejectCompareProcedureEvidenceClause)(clause, context.message)
-        : undefined;
-    const directClauses = collectRagPublicEvidenceClauses(context, new Set(['direct_support']), ragRevisionDirectClauseLimit(profile), [], {
+        ? (clause) => (rejectAnswerControlClause(clause)
+            || (0, ragPublicText_1.shouldRejectCompareProcedureEvidenceClause)(clause, context.message))
+        : rejectAnswerControlClause;
+    const directClauses = collectRagPublicEvidenceClauses(context, new Set(['direct_support']), undefined, [], {
         preserveLeadingHeading: isCompareQuery,
         rejectClause: rejectCompareProcedureClause,
     });
-    const documentClauses = collectRagPublicEvidenceClauses(context, new Set(['parent_context', 'adjacent_context']), ragRevisionDocumentClauseLimit(profile), directClauses, {
+    const documentClauses = collectRagPublicEvidenceClauses(context, new Set(['parent_context', 'adjacent_context']), undefined, directClauses, {
         ...ragRevisionDocumentClauseOptions(profile, queryTerms),
         rejectClause: rejectCompareProcedureClause,
     });
     const hasConflictEvidence = context.ragSufficiencyReview?.degradationState === 'conflict'
         || (context.ragSufficiencyReview?.reasons || []).some((reason) => String(reason || '').includes('conflict_evidence_present'));
     const conflictClauses = hasConflictEvidence
-        ? collectRagPublicEvidenceClauses(context, new Set(['conflict']), 3, [...directClauses, ...documentClauses])
+        ? collectRagPublicEvidenceClauses(context, new Set(['conflict']), undefined, [...directClauses, ...documentClauses])
         : [];
-    const graphClauses = collectRagPublicEvidenceClauses(context, new Set(['graph_neighbor_support']), ragRevisionGraphClauseLimit(profile), [...directClauses, ...documentClauses, ...conflictClauses], {
+    const graphClauses = collectRagPublicEvidenceClauses(context, new Set(['graph_neighbor_support']), undefined, [...directClauses, ...documentClauses, ...conflictClauses], {
         ...ragRevisionGraphClauseOptions(profile, queryTerms),
         rejectClause: rejectCompareProcedureClause,
     });
@@ -816,11 +825,8 @@ function buildRagGroundedRevisionAnswer(context) {
     if (!baseAnswer) {
         return '';
     }
-    const additionalDirectClauses = profile === 'compare'
-        ? []
-        : directClauses.slice(1);
     const extraSentences = [
-        ...additionalDirectClauses,
+        ...directClauses.slice(1),
         ...conflictClauses,
         ...documentClauses,
         ...graphClauses,
@@ -873,12 +879,7 @@ function buildDefinitionIntentRevisionAnswer(context, supportFrame) {
     const subject = normalizeWhitespace(String(leadingPoint?.title || supportFrame.subject || ''));
     const value = stripTerminalSentencePunctuation(supportFrame.value);
     const normalizedSurface = normalizeWhitespace(String(supportFrame.surface || ''));
-    const useChinese = containsCjk([
-        context.message,
-        subject,
-        value,
-        normalizedSurface,
-    ].join(' '));
+    const useChinese = useChineseAnswerLanguage(context, [subject, value, normalizedSurface]);
     if (!useChinese && normalizedSurface) {
         const canonicalizedSurface = (subject
             && supportFrame.subject
@@ -912,33 +913,18 @@ function buildDefinitionIntentRevisionAnswer(context, supportFrame) {
     ]);
 }
 function buildReleasedPublicAnswer(context, draftAnswer) {
-    if (!isDefinitionIntentQuery(context.message)) {
-        return draftAnswer;
-    }
-    const ragGroundedAnswer = buildRagGroundedRevisionAnswer(context);
-    if (ragGroundedAnswer) {
-        return ragGroundedAnswer;
+    if (isDefinitionIntentQuery(context.message)) {
+        const ragGroundedAnswer = buildRagGroundedRevisionAnswer(context);
+        if (ragGroundedAnswer && !normalizeWhitespace(draftAnswer).includes(normalizeWhitespace(ragGroundedAnswer))) {
+            return normalizeWhitespace(`${draftAnswer} ${ragGroundedAnswer}`);
+        }
     }
-    const useChinese = containsCjk([
-        context.message,
-        draftAnswer,
-        context.knowledgePoints[0]?.title || '',
-        context.graphContext?.anchorTitle || '',
-    ].join(' '));
-    return expandAnswerWithGraphContext(draftAnswer, context, useChinese, [
-        buildDefinitionAugmentationSentence(context, useChinese),
-        buildDefinitionEvidenceHighlightSentence(context, useChinese),
-    ]);
+    return draftAnswer;
 }
 function buildGraphOrderRevisionAnswer(context, conflict) {
     const earlierTitle = normalizeWhitespace(conflict.evidence.earlierTitle);
     const laterTitle = normalizeWhitespace(conflict.evidence.laterTitle);
-    const useChinese = containsCjk([
-        context.message,
-        context.draftAnswer,
-        earlierTitle,
-        laterTitle,
-    ].join(' '));
+    const useChinese = useChineseAnswerLanguage(context, [earlierTitle, laterTitle]);
     if (useChinese) {
         return conflict.evidence.relationKind === 'prerequisite'
             ? `${earlierTitle}是${laterTitle}的前置条件。`
@@ -951,12 +937,7 @@ function buildGraphOrderRevisionAnswer(context, conflict) {
 function buildGraphCausalRevisionAnswer(context, conflict) {
     const causeTitle = normalizeWhitespace(conflict.evidence.causeTitle);
     const effectTitle = normalizeWhitespace(conflict.evidence.effectTitle);
-    const useChinese = containsCjk([
-        context.message,
-        context.draftAnswer,
-        causeTitle,
-        effectTitle,
-    ].join(' '));
+    const useChinese = useChineseAnswerLanguage(context, [causeTitle, effectTitle]);
     if (useChinese) {
         return `${causeTitle}导致${effectTitle}。`;
     }
@@ -965,12 +946,7 @@ function buildGraphCausalRevisionAnswer(context, conflict) {
 function buildGraphComparisonRevisionAnswer(context, conflict) {
     const leftTitle = normalizeWhitespace(conflict.evidence.leftTitle);
     const rightTitle = normalizeWhitespace(conflict.evidence.rightTitle);
-    const useChinese = containsCjk([
-        context.message,
-        context.draftAnswer,
-        leftTitle,
-        rightTitle,
-    ].join(' '));
+    const useChinese = useChineseAnswerLanguage(context, [leftTitle, rightTitle]);
     if (useChinese) {
         return conflict.evidence.relationKind === 'contrast'
             ? `${leftTitle}与${rightTitle}不同。`
@@ -995,13 +971,11 @@ function buildTemporalValidityRevisionAnswer(context, conflict) {
         || context.knowledgePoints[0]?.title
         || conflict.invalidKnowledgePointTitles[0]
         || '');
-    const useChinese = containsCjk([
-        context.message,
-        context.draftAnswer,
+    const useChinese = useChineseAnswerLanguage(context, [
         anchorTitle,
         ...conflict.invalidKnowledgePointTitles,
         ...conflict.warningReasons,
-    ].join(' '));
+    ]);
     if (useChinese) {
         if (anchorTitle) {
             return `关于${anchorTitle}的当前命中证据带有时序警告，我不能把它直接当作当前结论发布。`;
@@ -1036,12 +1010,7 @@ function buildStructuredComparisonRevisionAnswer(context, conflict) {
     if (!correctedLeft || !correctedRight) {
         return buildGroundedRevisionAnswer(context);
     }
-    const useChinese = containsCjk([
-        context.message,
-        context.draftAnswer,
-        correctedLeft,
-        correctedRight,
-    ].join(' '));
+    const useChinese = useChineseAnswerLanguage(context, [correctedLeft, correctedRight]);
     if (useChinese) {
         return `${correctedLeft}高于${correctedRight}。`;
     }
@@ -1057,6 +1026,7 @@ function buildSupportCandidates(context) {
                 candidates.push({
                     label: title,
                     text,
+                    sourceText: String(fragment.text || ''),
                 });
             }
         });
@@ -1069,6 +1039,7 @@ function buildSupportCandidates(context) {
             candidates.push({
                 label: title,
                 text,
+                sourceText: String(citation.snippet || ''),
             });
         }
     });
@@ -1080,11 +1051,35 @@ function buildSupportCandidates(context) {
             candidates.push({
                 label: title,
                 text,
+                sourceText: String(point.evidenceSnippet || point.summary || ''),
             });
         }
     });
     return candidates;
 }
+function removeSupportedSourceLabels(context, answer) {
+    const sourceClausesByLabel = new Map();
+    const clauseKey = (text) => stripTerminalSentencePunctuation(normalizeWhitespace((0, ragPublicText_1.naturalizeRagPublicEvidenceClause)(text)));
+    for (const source of buildSupportCandidates(context)) {
+        const label = normalizeWhitespace(source.label).toLowerCase();
+        const clauses = sourceClausesByLabel.get(label) || new Set();
+        for (const clause of (0, ragEvidenceQuality_1.segmentRagEvidenceClauses)(source.sourceText))
+            clauses.add(clauseKey(clause));
+        sourceClausesByLabel.set(label, clauses);
+    }
+    return (0, ragEvidenceQuality_1.segmentRagEvidenceClauses)(answer).map(clause => {
+        for (const separator of clause.matchAll(/[:：]/gu)) {
+            const label = clauseKey(clause.slice(0, separator.index)).toLowerCase();
+            const sourceClauses = sourceClausesByLabel.get(label);
+            const body = clause.slice(separator.index + 1).trim();
+            // A source prefix is presentation only when the complete remaining
+            // clause is quoted from that source. Labels cannot legitimize a changed assertion.
+            if (body && sourceClauses?.has(clauseKey(body)))
+                return body;
+        }
+        return clause;
+    }).join('\n');
+}
 function isGraphOrderSupportedRelationKind(value) {
     return value === 'prerequisite' || value === 'sequence';
 }
@@ -1248,11 +1243,18 @@ function buildPolarityComparableFeatures(value) {
         .filter((feature) => feature.length >= 2)
         .filter((feature) => !STRUCTURED_ANCHOR_STOPWORDS.has(feature));
 }
-function extractPolaritySentences(value) {
+function stripLearningRoutePresentation(value) {
     return String(value || '')
+        .replace(/(?:^|\n)\s*#{1,6}\s*(?:建议学习路径|推荐学习路径|Suggested learning path)\s*:?[^\n]*\n[\s\S]*$/imu, ' ')
+        .replace(/(?:建议学习路径|推荐学习路径|Suggested learning path)\s*[:：][\s\S]*?(?=。|\.$|$)/giu, ' ')
+        .trim();
+}
+function extractPolaritySentences(value, responseMode = 'slim') {
+    return stripLearningRoutePresentation(value)
         .split(POLARITY_SENTENCE_SPLIT_PATTERN)
         .map((sentence) => normalizeWhitespace(sentence))
         .filter((sentence) => sentence.length >= 8)
+        .filter((sentence) => responseMode !== 'full' || !isMarkdownLabelOnlySentence(sentence))
         .map((sentence) => ({
         surface: sentence,
         polarity: classifySentencePolarity(sentence),
@@ -1260,6 +1262,13 @@ function extractPolaritySentences(value) {
     }))
         .filter((sentence) => sentence.comparableFeatures.length >= 2);
 }
+function isMarkdownLabelOnlySentence(value) {
+    const normalized = normalizeWhitespace(String(value || ''));
+    if (!normalized) {
+        return true;
+    }
+    return /^(?:#{1,6}\s*|[|]\s*|[-*+]\s+)?(?:\*\*)?[^.!?\u3002\uFF01\uFF1F]{2,}(?:\*\*)?[:：]\s*$/u.test(normalized);
+}
 function computePolarityFeatureOverlap(answerSentence, supportSentence) {
     if (answerSentence.comparableFeatures.length <= 0 || supportSentence.comparableFeatures.length <= 0) {
         return 0;
@@ -1825,7 +1834,7 @@ function extractStateFrames(value) {
             connectorKind: 'definition',
         },
     ];
-    return String(value || '')
+    return stripLearningRoutePresentation(value)
         .split(POLARITY_SENTENCE_SPLIT_PATTERN)
         .map((sentence) => normalizeWhitespace(sentence))
         .filter((sentence) => sentence.length >= 8 || (containsCjk(sentence) && sentence.length >= 5))
@@ -1861,6 +1870,9 @@ function buildSubjectFrame(surface, subject, tail) {
         tailFeatures,
     };
 }
+function collapseDisplayMathForSemanticParsing(value) {
+    return String(value || '').replace(/\s*(?<!\\)\$\$([\s\S]*?)(?<!\\)\$\$\s*/gu, (_match, expression) => ` $$${normalizeWhitespace(expression)}$$ `);
+}
 function buildAttributeFrame(surface, subject, value) {
     const normalizedSurface = normalizeWhitespace(surface);
     const normalizedSubject = normalizeAttributeFrameSubject(subject);
@@ -1889,7 +1901,7 @@ function extractSubjectFrames(value) {
         /^(.{1,80}?)\s+(?:is|are|was|were|remains|stays|equals|means|refers to|belongs to|has|contains)\s+(.+)$/iu,
         /^(.{1,24}?)(?:是|为|等于|指|属于|有|包含)(.+)$/u,
     ];
-    return String(value || '')
+    return collapseDisplayMathForSemanticParsing(stripLearningRoutePresentation(value))
         .split(POLARITY_SENTENCE_SPLIT_PATTERN)
         .map((sentence) => normalizeWhitespace(sentence))
         .filter((sentence) => sentence.length >= 8 || (containsCjk(sentence) && sentence.length >= 5))
@@ -1900,7 +1912,11 @@ function extractSubjectFrames(value) {
                 continue;
             }
             const frame = buildSubjectFrame(sentence, String(match[1] || ''), String(match[2] || ''));
-            return frame ? [frame] : [];
+            return frame
+                && !isStandaloneVariableDefinitionClaim(frame.surface)
+                && !/(?<!\\)\$[^$\n]+?(?<!\\)\$/u.test(frame.subject)
+                ? [frame]
+                : [];
         }
         return [];
     });
@@ -1910,7 +1926,7 @@ function extractAttributeFrames(value) {
         /^(.{1,80}?)\s+(?:has|have|had|features?)\s+(.+)$/iu,
         /^(.{1,24}?)(?:有|具有|带有)(.+)$/u,
     ];
-    return String(value || '')
+    return stripLearningRoutePresentation(value)
         .split(POLARITY_SENTENCE_SPLIT_PATTERN)
         .map((sentence) => normalizeWhitespace(sentence))
         .filter((sentence) => sentence.length >= 8 || (containsCjk(sentence) && sentence.length >= 5))
@@ -2027,7 +2043,7 @@ function extractContainmentFrames(value) {
         /^(.{1,80}?)\s+(?:is|are|was|were)\s+filled\s+with\s+(.+)$/iu,
         /^(.{1,24}?)(?:装有|盛有|含有|包含)(.+)$/u,
     ];
-    return String(value || '')
+    return stripLearningRoutePresentation(value)
         .split(POLARITY_SENTENCE_SPLIT_PATTERN)
         .map((sentence) => normalizeWhitespace(sentence))
         .filter((sentence) => sentence.length >= 8 || (containsCjk(sentence) && sentence.length >= 5))
@@ -2054,7 +2070,7 @@ function extractPurposeFrames(value) {
         /^(.{1,24}?)(?:可)?用来(.+)$/u,
         /^(.{1,24}?)(?:被)?用作(.+)$/u,
     ];
-    return String(value || '')
+    return stripLearningRoutePresentation(value)
         .split(POLARITY_SENTENCE_SPLIT_PATTERN)
         .map((sentence) => normalizeWhitespace(sentence))
         .filter((sentence) => sentence.length >= 8 || (containsCjk(sentence) && sentence.length >= 5))
@@ -2097,7 +2113,7 @@ function extractDependencyFrames(value) {
             dependencyIndex: 1,
         },
     ];
-    return String(value || '')
+    return stripLearningRoutePresentation(value)
         .split(POLARITY_SENTENCE_SPLIT_PATTERN)
         .map((sentence) => normalizeWhitespace(sentence))
         .filter((sentence) => sentence.length >= 8 || (containsCjk(sentence) && sentence.length >= 5))
@@ -2149,7 +2165,7 @@ function extractLocationFrames(value) {
         /^(.{1,80}?)\s+lies?\s+(?:in|within)\s+(.+)$/iu,
         /^(.{1,24}?)(?:位于|位於|坐落于|坐落於|处于|處於)(.+)$/u,
     ];
-    return String(value || '')
+    return stripLearningRoutePresentation(value)
         .split(POLARITY_SENTENCE_SPLIT_PATTERN)
         .map((sentence) => normalizeWhitespace(sentence))
         .filter((sentence) => sentence.length >= 8 || (containsCjk(sentence) && sentence.length >= 5))
@@ -2175,7 +2191,7 @@ function extractCompositionFrames(value) {
         /^(.{1,24}?)(?:是)?由(.+?)(?:组成|构成|構成)(?:的.+)?$/u,
         /^(.{1,24}?)(?:被定义为|定义为|被定義為|定義為).+?由(.+?)(?:组成|构成|構成)(?:的.+)?$/u,
     ];
-    return String(value || '')
+    return stripLearningRoutePresentation(value)
         .split(POLARITY_SENTENCE_SPLIT_PATTERN)
         .map((sentence) => normalizeWhitespace(sentence))
         .filter((sentence) => sentence.length >= 8 || (containsCjk(sentence) && sentence.length >= 5))
@@ -2192,10 +2208,54 @@ function extractCompositionFrames(value) {
     });
 }
 function subjectFramesShareTail(answerFrame, supportFrame) {
+    const answerQualifiers = collectScopeQualifierTokens(`${answerFrame.subject} ${answerFrame.tail}`);
+    const supportQualifiers = collectScopeQualifierTokens(`${supportFrame.subject} ${supportFrame.tail}`);
+    if (answerQualifiers.size > 0
+        && supportQualifiers.size > 0
+        && !Array.from(answerQualifiers).some((qualifier) => supportQualifiers.has(qualifier))) {
+        return false;
+    }
     const overlapRatio = computeFeatureOverlapRatio(answerFrame.tailFeatures, supportFrame.tailFeatures);
     const jaccard = computeFeatureJaccard(answerFrame.tailFeatures, supportFrame.tailFeatures);
     return overlapRatio >= 0.75 || jaccard >= 0.7;
 }
+const SUBJECT_SCOPE_QUALIFIER_FEATURES = new Set([
+    'staging', 'production', 'development', 'dev', 'test', 'testing', 'qa', 'sandbox',
+    'windows', 'android', 'ios', 'linux', 'macos', 'mac',
+    'current', 'planned', 'historical', 'history', 'legacy', 'future', 'past',
+    '生产', '预发布', '开发', '测试', '版本',
+]);
+function collectScopeQualifierTokens(value) {
+    const normalized = normalizeWhitespace(value).toLowerCase();
+    const qualifiers = normalized.match(/\b(?:staging|production|development|dev|test|testing|qa|sandbox|windows|android|ios|linux|macos|mac|current|planned|historical|history|legacy|future|past)\b|\b(?:version|v)\s*\d+(?:\.\d+)*\b|(?:生产|预发布|开发|测试|当前|计划|历史|旧版|版本\s*\d+(?:\.\d+)*)/gu) || [];
+    return new Set(qualifiers.map((qualifier) => {
+        const normalizedQualifier = normalizeWhitespace(qualifier);
+        const versionMatch = normalizedQualifier.match(/^(?:version|v)\s*(\d+(?:\.\d+)*)$/iu);
+        if (!versionMatch) {
+            return normalizedQualifier;
+        }
+        const components = String(versionMatch[1] || '').split('.');
+        while (components.length > 1 && components[components.length - 1] === '0') {
+            components.pop();
+        }
+        return `version ${components.join('.')}`;
+    }));
+}
+function subjectFramesShareQualifiedIdentity(answerFrame, supportFrame) {
+    if (!subjectFramesShareTail(answerFrame, supportFrame)) {
+        return false;
+    }
+    const answerQualifiers = collectScopeQualifierTokens(`${answerFrame.subject} ${answerFrame.tail}`);
+    const supportQualifiers = collectScopeQualifierTokens(`${supportFrame.subject} ${supportFrame.tail}`);
+    if (answerQualifiers.size <= 0
+        || !Array.from(answerQualifiers).some((qualifier) => supportQualifiers.has(qualifier))) {
+        return false;
+    }
+    const answerFeatures = new Set(answerFrame.subjectFeatures.filter((feature) => !SUBJECT_SCOPE_QUALIFIER_FEATURES.has(feature)));
+    const supportFeatures = new Set(supportFrame.subjectFeatures.filter((feature) => !SUBJECT_SCOPE_QUALIFIER_FEATURES.has(feature)));
+    const sharedCoreFeatureCount = Array.from(answerFeatures).filter((feature) => supportFeatures.has(feature)).length;
+    return sharedCoreFeatureCount >= 2;
+}
 function subjectFramesEquivalent(answerFrame, supportFrame) {
     const normalizedAnswerSubject = normalizeWhitespace(answerFrame.subject).toLowerCase();
     const normalizedSupportSubject = normalizeWhitespace(supportFrame.subject).toLowerCase();
@@ -2205,7 +2265,8 @@ function subjectFramesEquivalent(answerFrame, supportFrame) {
     if (normalizedAnswerSubject === normalizedSupportSubject) {
         return true;
     }
-    return computeFeatureOverlapRatio(answerFrame.subjectFeatures, supportFrame.subjectFeatures) >= 0.75;
+    return computeFeatureOverlapRatio(answerFrame.subjectFeatures, supportFrame.subjectFeatures) >= 0.75
+        || subjectFramesShareQualifiedIdentity(answerFrame, supportFrame);
 }
 function computeSubjectFrameTailOverlap(answerFrame, supportFrame) {
     return computeFeatureOverlapRatio(answerFrame.tailFeatures, supportFrame.tailFeatures);
@@ -2579,7 +2640,7 @@ function evaluateGroundingAlignment(context) {
     const scored = candidates
         .map((candidate) => ({
         label: candidate.label,
-        score: computeGroundingAlignmentScore(context.draftAnswer, candidate.text),
+        score: computeGroundingAlignmentScore(stripLearningRoutePresentation(context.draftAnswer), candidate.text),
     }))
         .sort((left, right) => right.score - left.score);
     const best = scored[0] || { label: '', score: 0 };
@@ -2617,7 +2678,8 @@ function ragAnswerRoleIsCovered(context, role) {
     if (!supportText) {
         return true;
     }
-    return computeGroundingAlignmentScore(context.draftAnswer, supportText) >= 0.22;
+    return splitDraftAnswerClaims(context.draftAnswer)
+        .some((claim) => computeGroundingAlignmentScore(claim, supportText) >= 0.22);
 }
 const HOW_TO_PROFILE_SIGNAL_RULES = [
     {
@@ -2734,6 +2796,446 @@ function buildRagAnswerCompletenessMessage(result) {
     }
     return `Draft answer missed required RAG evidence roles: ${result.missingRoles.join(', ') || 'none'}; missing profile signals: ${result.missingProfileSignals.join(', ') || 'none'}.`;
 }
+function preservePlannedGraphAnswerClaims(answer, plan) {
+    if (!plan) {
+        return normalizePublicAnswerSurface(answer);
+    }
+    const plannedStatements = (plan.claims || [])
+        .map((claim) => (0, ragPublicText_1.naturalizeRagPublicEvidenceClause)(String(claim.statement || '')))
+        .filter((statement) => (statement
+        && hasBalancedPublicMathDelimiters(statement)
+        && !(0, ragPublicText_1.shouldRejectPublicEvidenceClause)(statement)));
+    if (plannedStatements.length <= 0) {
+        return normalizeWhitespace(answer);
+    }
+    const normalizedAnswer = normalizeWhitespace(answer);
+    const orderedPlanText = plannedStatements.join('\n\n');
+    const supplementalClauses = (0, ragEvidenceQuality_1.segmentRagEvidenceClauses)((0, ragPublicText_1.naturalizeRagPublicEvidenceClause)(normalizedAnswer))
+        .map((clause) => normalizeWhitespace(clause))
+        .filter((clause) => (clause
+        && hasBalancedPublicMathDelimiters(clause)
+        && !(0, ragPublicText_1.shouldRejectPublicEvidenceClause)(clause)))
+        .filter((clause) => plan?.intent !== 'definition' || (!/\b(?:compared?\s+with|versus|vs\.?|plastic\s+cup|metal\s+cup|对比|比较|差异|区别)\b/iu.test(clause)
+        && !/\b(?:remain(?:s)?\s+(?:internal|outside)|public\s+(?:definition|answer)\s+budget|extra\s+sentence|beyond\s+the\s+public)\b/iu.test(clause)))
+        .filter((clause) => !plannedStatements.some((plannedStatement) => {
+        const clauseKey = clause.toLowerCase();
+        const plannedKey = plannedStatement.toLowerCase();
+        return clauseKey === plannedKey
+            || clauseKey.includes(plannedKey)
+            || plannedKey.includes(clauseKey);
+    }));
+    const supplementalText = plan?.intent === 'definition'
+        ? ''
+        : supplementalClauses.join('\n\n');
+    const useChinese = /[\u3400-\u9fff]/u.test(`${answer} ${plan.answerTaskPlan?.primarySubject || ''}`);
+    return (0, answerTaskPlan_1.formatTaskAwareAnswer)([orderedPlanText, supplementalText], plan.answerTaskPlan, useChinese);
+}
+function isIncompletePublicGraphClaim(value) {
+    const normalized = normalizeWhitespace(value);
+    if (normalized.length < (containsCjk(normalized) ? 5 : 16) || /^\d+(?:\.\d+)*[.\u3001)]?$/u.test(normalized)) {
+        return true;
+    }
+    const endsWithTerminalPunctuation = /[.!?\u3002\uFF01\uFF1F]$/u.test(normalized);
+    const endsWithBalancedMath = /(?<!\\)(?:\$\$[\s\S]+?\$\$|\$[^$\n]+\$)$/u.test(normalized);
+    if (!endsWithTerminalPunctuation && !endsWithBalancedMath) {
+        return true;
+    }
+    if (/[：:]$|(?:and|or|with|between|from|to|is|are|以及|并且|其中|通常在|范围为|分别为|性能)$/iu.test(normalized)) {
+        return true;
+    }
+    return false;
+}
+function isDefinitionComparisonOrArtifactClaim(value) {
+    const normalized = normalizeWhitespace(value);
+    return /\b(?:compare|comparison|contrast|versus|vs\.?|plastic\s+cup|metal\s+cup|ceramic\s+(?:mug|cup)|technologies|context\s+paragraph|local\s+window|technical\s+document|subsequent\s+branch)\b/iu.test(normalized)
+        || /\b(?:validates?\s+(?:the\s+)?source|source\s+anchoring|same\s+clause\s+appears\s+in\s+multiple\s+sections)\b/iu.test(normalized)
+        || /相关技术|比较|对比|塑料杯|金属杯|陶瓷杯|流体容器技术比较|上下文段落|后续分支|本技术文档|技术规格|性能特征|核心概念|我们将从|我们将|本节|本章/u.test(normalized);
+}
+function isDefinitionDisambiguationContextStatement(value) {
+    const normalized = normalizeWhitespace(value);
+    if (!normalized) {
+        return false;
+    }
+    const sectionReference = /\b(?:(?:target|selected|matched|active|current|applicable)\s+(?:section|occurrence|version|record|entry|context)|(?:first|second|later|earlier|specific|corresponding)\s+(?:occurrence|section|match|entry))\b/iu.test(normalized);
+    const authoritySignal = /\b(?:controls?|determines?|applies?|guides?|answers?|answer|selected|active|authoritative|canonical|use|used)\b/iu.test(normalized);
+    return sectionReference && authoritySignal;
+}
+function isFullDocumentDefinitionNoiseStatement(value) {
+    const normalized = normalizeWhitespace(value);
+    return !normalized
+        || /^\d+(?:\.\d+)*[.、)]?$/u.test(normalized)
+        || /常见用例|应用场景|关键技术规格|技术规格|性能指标|性能特征|统计度量|量化分析|静水压力|环向应力|威布尔|机械可靠性|simple\s+optical\s+lens|use\s+case|application\s+scenario|technical\s+specification|performance\s+(?:metric|characteristic)|quantitative\s+analysis|hydrostatic\s+pressure|hoop\s+stress|weibull|mechanical\s+reliability/iu.test(normalized);
+}
+function extractNormalizedPublicMathExpressions(value) {
+    const source = String(value || '');
+    const expressions = [];
+    const displayPattern = /(?<!\\)\$\$([\s\S]*?)(?<!\\)\$\$/gu;
+    for (const match of source.matchAll(displayPattern)) {
+        const expression = normalizeWhitespace(match[1]).replace(/\s+/gu, '');
+        if (expression) {
+            expressions.push(expression);
+        }
+    }
+    const inlineSource = source.replace(displayPattern, '');
+    const inlinePattern = /(?<!\\)\$([^$\n]+?)(?<!\\)\$/gu;
+    for (const match of inlineSource.matchAll(inlinePattern)) {
+        const expression = normalizeWhitespace(match[1]).replace(/\s+/gu, '');
+        if (expression) {
+            expressions.push(expression);
+        }
+    }
+    return Array.from(new Set(expressions));
+}
+function isFormulaOnlyPublicGraphClaim(value) {
+    const source = String(value || '');
+    if (extractNormalizedPublicMathExpressions(source).length <= 0) {
+        return false;
+    }
+    const withoutDisplayMath = source.replace(/(?<!\\)\$\$[\s\S]*?(?<!\\)\$\$/gu, '');
+    const prose = withoutDisplayMath
+        .replace(/(?<!\\)\$[^$\n]+?(?<!\\)\$/gu, '')
+        .replace(/[()[\]{}.,;:!?]/gu, '')
+        .trim();
+    return prose.length <= 0;
+}
+function formulaOnlyPublicClaimIsAlreadyCovered(candidate, selectedClaims) {
+    if (!isFormulaOnlyPublicGraphClaim(candidate.statement)) {
+        return false;
+    }
+    const candidateExpressions = extractNormalizedPublicMathExpressions(candidate.statement);
+    return candidateExpressions.length > 0 && selectedClaims.some((selectedClaim) => {
+        const selectedExpressions = extractNormalizedPublicMathExpressions(selectedClaim.statement);
+        return candidateExpressions.every((expression) => selectedExpressions.includes(expression));
+    });
+}
+function isStandaloneVariableDefinitionClaim(value) {
+    const source = normalizeWhitespace(String(value || ''));
+    const expressions = extractNormalizedPublicMathExpressions(source);
+    if (expressions.length !== 1 || /(?<!\\)\$\$[\s\S]*?(?<!\\)\$\$/u.test(source)) {
+        return false;
+    }
+    const prose = source
+        .replace(/(?<!\\)\$[^$\n]+?(?<!\\)\$/gu, '')
+        .replace(/[()[\]{}.,;:!?]/gu, '')
+        .trim();
+    return /^(?:is|are|was|were|means?|denotes?|represents?|分别是|是|为|表示|指)/iu.test(prose)
+        || /(?:^|\s)(?:is|are|means?|denotes?|represents?|分别是|是|为|表示|指)(?:\s|$)/iu.test(prose);
+}
+function isStandaloneVariableGlossaryClaim(value) {
+    const source = normalizeWhitespace(String(value || ''));
+    const expressions = extractNormalizedPublicMathExpressions(source);
+    if (expressions.length < 2 || expressions.some((expression) => expression.includes('='))) {
+        return false;
+    }
+    const variableDefinitions = source.match(/(?<!\\)\$[^$\n]+?(?<!\\)\$\s*(?:is|are|means?|denotes?|represents?|是|为|表示|指)/giu) || [];
+    if (variableDefinitions.length < 2) {
+        return false;
+    }
+    const prose = source
+        .replace(/(?<!\\)\$[^$\n]+?(?<!\\)\$/gu, ' ')
+        .trim();
+    return /^(?:where|in which|here|variables?|the variables|其中|其中的|分别|各变量)/iu.test(prose)
+        || variableDefinitions.length >= 3;
+}
+function definitionQueryMatchesVariableGlossary(glossary, message) {
+    const normalizedMessage = normalizeWhitespace(String(message || ''))
+        .replace(/^(?:what\s+is|what'?s|what\s+are|define|definition\s+of|meaning\s+of|什么是|指的是什么|定义|是什么意思)\s*/iu, '')
+        .replace(/[?？!！。.;；]+$/u, '')
+        .trim()
+        .toLowerCase();
+    if (!normalizedMessage) {
+        return false;
+    }
+    if (/\b(?:cfl|courant(?:-friedrichs-lewy)?|mesh(?:ing)?|grid|numerical\s+simulation|characteristic\s+velocity|finite\s+(?:volume|element))\b/iu.test(normalizedMessage)
+        || /库朗|数值模拟|网格|特征速度|有限元|有限体积|稳定性/u.test(normalizedMessage)) {
+        return true;
+    }
+    const source = normalizeWhitespace(String(glossary || ''))
+        .toLowerCase()
+        .replace(/\\/gu, '');
+    const queryTokens = normalizedMessage.match(/[\p{L}\p{N}]+/gu) || [];
+    const stopwords = new Set([
+        'a', 'an', 'the', 'and', 'are', 'be', 'definition', 'define', 'does', 'how',
+        'is', 'meaning', 'of', 'or', 'what', 'which', 'who', 'with', '这', '个', '是', '的',
+    ]);
+    return queryTokens.some((token) => !stopwords.has(token) && source.includes(token));
+}
+function isUnrelatedVariableGlossaryClaim(value, message) {
+    return isStandaloneVariableGlossaryClaim(value)
+        && !definitionQueryMatchesVariableGlossary(value, message);
+}
+function publicClaimCarriesCompleteMathContext(value) {
+    const source = normalizeWhitespace(String(value || ''));
+    if (!source
+        || isStandaloneVariableDefinitionClaim(source)
+        || isStandaloneVariableGlossaryClaim(source)) {
+        return false;
+    }
+    const expressions = extractNormalizedPublicMathExpressions(source);
+    return expressions.some((expression) => expression.includes('='));
+}
+function publicClaimMathKeys(value) {
+    return extractNormalizedPublicMathExpressions(value)
+        .filter((expression) => expression.includes('='));
+}
+function extractConflictPredicate(value) {
+    const normalized = normalizeWhitespace(String(value || '')).replace(/[.!?。！？]+$/u, '');
+    const englishMatch = normalized.match(/^(.+?)\s+(?:is|are|was|were|equals?|remains?|contains?|uses?)\s+(.+)$/iu);
+    if (englishMatch) {
+        return {
+            subject: normalizeWhitespace(englishMatch[1]).toLowerCase(),
+            value: normalizeWhitespace(englishMatch[2]).toLowerCase(),
+        };
+    }
+    const chineseMatch = normalized.match(/^(.+?)(?:是|为|包含|使用|位于)(.+)$/u);
+    if (chineseMatch) {
+        return {
+            subject: normalizeWhitespace(chineseMatch[1]).toLowerCase(),
+            value: normalizeWhitespace(chineseMatch[2]).toLowerCase(),
+        };
+    }
+    return null;
+}
+function selectConflictDefinitionClaims(candidates) {
+    const requiredCandidates = candidates.filter(({ claim }) => claim.required);
+    const conflictCandidates = requiredCandidates.filter(({ claim }, candidateIndex) => {
+        const left = extractConflictPredicate(claim.statement);
+        if (!left) {
+            return false;
+        }
+        return requiredCandidates.some(({ claim: otherClaim }, otherIndex) => {
+            if (candidateIndex === otherIndex) {
+                return false;
+            }
+            const right = extractConflictPredicate(otherClaim.statement);
+            return Boolean(right && right.subject === left.subject && right.value !== left.value);
+        });
+    });
+    return conflictCandidates.length >= 2 ? conflictCandidates : [];
+}
+function findContextualFormulaClaim(formulaOnlyCandidate, candidates) {
+    if (!isFormulaOnlyPublicGraphClaim(formulaOnlyCandidate.statement)) {
+        return null;
+    }
+    const candidateExpressions = extractNormalizedPublicMathExpressions(formulaOnlyCandidate.statement);
+    if (candidateExpressions.length <= 0) {
+        return null;
+    }
+    return candidates.find((candidate) => {
+        if (candidate.claimId === formulaOnlyCandidate.claimId || isFormulaOnlyPublicGraphClaim(candidate.statement)) {
+            return false;
+        }
+        const contextualExpressions = extractNormalizedPublicMathExpressions(candidate.statement);
+        return candidateExpressions.every((expression) => contextualExpressions.includes(expression));
+    }) || null;
+}
+function selectPublicGraphPlanStatements(plan, ragContextPack, message) {
+    const claims = Array.isArray(plan?.claims)
+        ? plan.claims.filter((claim) => hasBalancedPublicMathDelimiters(String(claim.statement || '')))
+        : [];
+    if (plan?.intent !== 'definition') {
+        return claims;
+    }
+    const eligibleClaims = claims
+        .filter((claim) => claim.role !== 'contrast' && claim.role !== 'analogy')
+        .filter((claim) => !/\b(?:compared?\s+with|versus|vs\.?|plastic\s+cup|metal\s+cup|对比|比较|差异|区别)\b/iu.test(String(claim.statement || '')))
+        .filter((claim) => !/\b(?:remain(?:s)?\s+(?:internal|outside)|public\s+(?:definition|answer)\s+budget|extra\s+sentence|beyond\s+the\s+public)\b/iu.test(String(claim.statement || '')))
+        .filter((claim) => !isIncompletePublicGraphClaim(String(claim.statement || '')))
+        .filter((claim) => !isDefinitionComparisonOrArtifactClaim(String(claim.statement || '')))
+        .filter((claim) => !isFullDocumentDefinitionNoiseStatement(String(claim.statement || '')))
+        .filter((claim) => !isUnrelatedVariableGlossaryClaim(String(claim.statement || ''), String(message || '')));
+    const selectedCandidates = [];
+    const selectedClaimIds = new Set();
+    const appendCandidate = (candidate) => {
+        if (selectedClaimIds.has(candidate.claim.claimId)) {
+            return;
+        }
+        if (formulaOnlyPublicClaimIsAlreadyCovered(candidate.claim, selectedCandidates.map((selectedCandidate) => selectedCandidate.claim))) {
+            return;
+        }
+        selectedCandidates.push(candidate);
+        selectedClaimIds.add(candidate.claim.claimId);
+    };
+    eligibleClaims.forEach((claim, index) => {
+        const contextualClaim = findContextualFormulaClaim(claim, eligibleClaims);
+        appendCandidate({ claim: contextualClaim || claim, index });
+    });
+    let selected = selectedCandidates
+        .sort((left, right) => left.index - right.index)
+        .map(({ claim }) => claim);
+    if (ragContextPack?.fragments?.some((fragment) => fragment.role === 'conflict')) {
+        const conflictClaims = selectConflictDefinitionClaims(selectedCandidates);
+        if (conflictClaims.length >= 2) {
+            return conflictClaims
+                .sort((left, right) => left.index - right.index)
+                .map(({ claim }) => claim);
+        }
+    }
+    if (ragContextPack?.sourceBoundary === 'full_document' && selected.length > 0) {
+        const selectedClaimIds = new Set();
+        const boundedCandidates = [];
+        const appendBoundedCandidate = (candidate) => {
+            if (boundedCandidates.length >= 5 || selectedClaimIds.has(candidate.claim.claimId)) {
+                return;
+            }
+            if (formulaOnlyPublicClaimIsAlreadyCovered(candidate.claim, boundedCandidates.map((entry) => entry.claim))) {
+                return;
+            }
+            boundedCandidates.push(candidate);
+            selectedClaimIds.add(candidate.claim.claimId);
+        };
+        const indexedSelected = selected.map((claim, index) => ({ claim, index }));
+        const definitionCandidates = indexedSelected.filter((entry) => (entry.claim.role === 'definition'
+            && !isFormulaOnlyPublicGraphClaim(entry.claim.statement)
+            && !isStandaloneVariableDefinitionClaim(entry.claim.statement)));
+        const leadingDefinition = definitionCandidates.find(entry => extractNormalizedPublicMathExpressions(entry.claim.statement).length === 0)
+            || definitionCandidates[0];
+        if (leadingDefinition) {
+            appendBoundedCandidate(leadingDefinition);
+        }
+        indexedSelected
+            .filter((entry) => isDefinitionDisambiguationContextStatement(entry.claim.statement))
+            .sort((left, right) => right.claim.priority - left.claim.priority || left.index - right.index)
+            .slice(0, 1)
+            .forEach(appendBoundedCandidate);
+        if (isCompoundLearningDefinitionQuery(String(message || ''))) {
+            indexedSelected
+                .filter((entry) => extractNormalizedPublicMathExpressions(entry.claim.statement).length > 0)
+                .filter((entry) => !publicClaimCarriesCompleteMathContext(entry.claim.statement))
+                .filter((entry) => !isStandaloneVariableDefinitionClaim(entry.claim.statement))
+                .sort((left, right) => right.claim.priority - left.claim.priority || left.index - right.index)
+                .slice(0, 1)
+                .forEach(appendBoundedCandidate);
+        }
+        indexedSelected
+            .filter((entry) => ['composition', 'boundary', 'attribute'].includes(entry.claim.role))
+            .filter((entry) => !isUnrelatedVariableGlossaryClaim(entry.claim.statement, String(message || '')))
+            .slice(0, 2)
+            .forEach(appendBoundedCandidate);
+        // Full-document definition evidence often contains a variable glossary
+        // after each equation. Prefer complete equation contexts across distinct
+        // formulas; standalone `$x$ is ...` clauses are useful only as fallback
+        // when no contextual equation is available.
+        const selectedMathKeys = new Set();
+        let selectedMathContextCount = 0;
+        indexedSelected
+            .filter((entry) => publicClaimCarriesCompleteMathContext(entry.claim.statement))
+            .sort((left, right) => (Number(right.claim.role === 'definition')
+            - Number(left.claim.role === 'definition')
+            || right.claim.priority - left.claim.priority
+            || left.index - right.index))
+            .forEach((entry) => {
+            if (selectedMathContextCount >= 2) {
+                return;
+            }
+            const mathKeys = publicClaimMathKeys(entry.claim.statement);
+            if (mathKeys.length <= 0 || mathKeys.some((key) => !selectedMathKeys.has(key))) {
+                appendBoundedCandidate(entry);
+                mathKeys.forEach((key) => selectedMathKeys.add(key));
+                selectedMathContextCount += 1;
+            }
+        });
+        if (boundedCandidates.length <= 1) {
+            indexedSelected
+                .filter((entry) => !isStandaloneVariableDefinitionClaim(entry.claim.statement))
+                .filter((entry) => !isUnrelatedVariableGlossaryClaim(entry.claim.statement, String(message || '')))
+                .filter((entry) => extractNormalizedPublicMathExpressions(entry.claim.statement).length > 0)
+                .forEach((entry) => appendBoundedCandidate(entry));
+        }
+        if (boundedCandidates.length <= 2) {
+            indexedSelected
+                .filter((entry) => entry.claim.role === 'mechanism')
+                .filter((entry) => !isStandaloneVariableDefinitionClaim(entry.claim.statement))
+                .filter((entry) => !isUnrelatedVariableGlossaryClaim(entry.claim.statement, String(message || '')))
+                .filter((entry) => extractNormalizedPublicMathExpressions(entry.claim.statement).length <= 0)
+                .forEach(appendBoundedCandidate);
+        }
+        indexedSelected
+            .filter((entry) => extractNormalizedPublicMathExpressions(entry.claim.statement).length <= 0)
+            .filter((entry) => !isStandaloneVariableDefinitionClaim(entry.claim.statement))
+            .filter((entry) => !isUnrelatedVariableGlossaryClaim(entry.claim.statement, String(message || '')))
+            .filter((entry) => ['composition', 'boundary', 'attribute'].includes(entry.claim.role))
+            .filter((entry) => !isFullDocumentDefinitionNoiseStatement(entry.claim.statement))
+            .forEach(appendBoundedCandidate);
+        // Extraction may classify several independent supported facts as definitions.
+        // Keep those complements within the same cap instead of silently dropping them by role.
+        indexedSelected
+            .filter((entry) => entry.claim.required && entry.claim.role === 'definition')
+            .filter((entry) => !isStandaloneVariableDefinitionClaim(entry.claim.statement))
+            .filter((entry) => !isUnrelatedVariableGlossaryClaim(entry.claim.statement, String(message || '')))
+            .forEach(appendBoundedCandidate);
+        selected = boundedCandidates
+            .sort((left, right) => left.index - right.index)
+            .map(({ claim }) => claim);
+    }
+    return selected;
+}
+function projectPublicGraphAnswerPlan(plan, ragContextPack, message) {
+    if (!plan) {
+        return null;
+    }
+    if (plan.intent !== 'definition') {
+        return plan;
+    }
+    const claims = selectPublicGraphPlanStatements(plan, ragContextPack, message);
+    return {
+        ...plan,
+        depth: claims.length <= 2 ? 'compact' : 'standard',
+        leadClaimId: claims[0]?.claimId || '',
+        claims,
+        requiredRoles: Array.from(new Set(claims.map((claim) => claim.role))),
+    };
+}
+function createEmptyPublicGraphAnswerPlan(plan) {
+    if (!plan) {
+        return null;
+    }
+    return {
+        ...plan,
+        depth: 'compact',
+        leadClaimId: '',
+        claims: [],
+        requiredRoles: [],
+    };
+}
+function isVerifiedRagConflictDisclosurePlan(context, plan) {
+    const fragments = context.ragContextPack?.fragments || [];
+    const conflictFragmentIds = new Set(fragments
+        .filter((fragment) => fragment.role === 'conflict')
+        .map((fragment) => normalizeWhitespace(String(fragment.fragmentId || '')))
+        .filter(Boolean));
+    if (conflictFragmentIds.size <= 0
+        || context.ragSufficiencyReview?.degradationState !== 'conflict'
+        || !plan
+        || plan.claims.length < 2) {
+        return false;
+    }
+    const conflictClaims = plan.claims.filter((claim) => ((claim.evidenceRefs || []).some((evidence) => conflictFragmentIds.has(normalizeWhitespace(String(evidence.evidenceId || ''))))));
+    const nonConflictClaims = plan.claims.filter((claim) => ((claim.evidenceRefs || []).some((evidence) => !conflictFragmentIds.has(normalizeWhitespace(String(evidence.evidenceId || ''))))));
+    return conflictClaims.length > 0
+        && nonConflictClaims.length > 0
+        && plan.claims.every((claim) => (hasBalancedPublicMathDelimiters(String(claim.statement || ''))
+            && (claim.evidenceRefs || []).some((evidence) => normalizeWhitespace(String(evidence.text || '')).length > 0)));
+}
+function discloseRagEvidenceConflicts(context, answer) {
+    const conflicts = (context.ragContextPack?.fragments || []).filter(fragment => (fragment.role === 'conflict' && !fragment.truncated && fragment.citationIds.length > 0));
+    if (conflicts.length === 0)
+        return answer;
+    const useChinese = useChineseAnswerLanguage(context);
+    let publicAnswer = answer;
+    for (const fragment of conflicts) {
+        const heading = fragment.text.split('\n', 1)[0];
+        if (heading.startsWith('Conflicting evidence for ')) {
+            publicAnswer = publicAnswer.split(heading).join(useChinese ? '来源中的冲突记录：' : 'Conflicting source observations:');
+        }
+    }
+    // Claim projection can discard supplemental text. The release boundary owns
+    // this conclusion so slim/full and every transport expose the same uncertainty.
+    const notice = useChinese
+        ? '来源中的观测存在冲突，现有证据无法确定哪一项正确。'
+        : 'The source observations conflict; the available evidence does not establish which is correct.';
+    return publicAnswer.startsWith(notice) ? publicAnswer : `${notice}\n\n${publicAnswer}`;
+}
 function collectCitationBackedRagFragments(context) {
     if (!hasUsableRagEvidenceContext(context)) {
         return [];
@@ -2748,10 +3250,14 @@ function claimLooksLikeReleaseScaffolding(claim) {
         return true;
     }
     return (/\b(?:grounded by|key evidence|citations?|rag context|retrieval|planner)\b/iu.test(normalizedClaim)
+        || /^(?:建议学习路径|推荐学习路径|Suggested learning path)\s*[:：]/iu.test(normalizedClaim)
+        || /\b(?:available evidence|evidence coverage)\s+is\s+still\s+partial\b/iu.test(normalizedClaim)
+        || /当前证据覆盖仍然有限|回答只使用已命中的材料|回答只陈述已有材料能够支持的内容/u.test(normalizedClaim)
+        || /^(?:当前图中的关键路径是|The strongest graph path runs through)(?:\s|$)/iu.test(normalizedClaim)
         || INTERNAL_DIAGNOSTIC_FRAGMENTS.some((fragment) => normalizedClaim.includes(fragment)));
 }
 function splitDraftAnswerClaims(answer) {
-    return stripMarkdownScaffolding(answer)
+    return stripMarkdownScaffolding(stripLearningRoutePresentation(answer))
         .split(POLARITY_SENTENCE_SPLIT_PATTERN)
         .map((claim) => normalizeWhitespace(claim))
         .filter((claim) => (claim.length >= 8
@@ -2830,6 +3336,12 @@ function evaluateRagClaimCitationSupport(context) {
     }
     const claims = splitDraftAnswerClaims(context.draftAnswer).filter((claim) => (collectClaimSupportFeatures(claim).length >= RAG_CLAIM_CITATION_SUPPORT_MIN_FEATURES));
     const citationBackedFragments = collectCitationBackedRagFragments(context);
+    const citationBackedPlanEvidence = (context.graphAnswerPlan?.claims || [])
+        .flatMap((claim) => claim.evidenceRefs || [])
+        .filter((evidence) => (normalizeWhitespace(String(evidence.text || '')).length > 0
+        && Array.isArray(evidence.citationIds)
+        && evidence.citationIds.some((citationId) => normalizeWhitespace(String(citationId || '')).length > 0)));
+    const citationBackedEvidenceCount = citationBackedFragments.length + citationBackedPlanEvidence.length;
     if (claims.length <= 0) {
         return {
             passed: true,
@@ -2840,7 +3352,7 @@ function evaluateRagClaimCitationSupport(context) {
             citationBackedFragmentCount: citationBackedFragments.length,
         };
     }
-    if (citationBackedFragments.length <= 0) {
+    if (citationBackedEvidenceCount <= 0) {
         return {
             passed: false,
             applicable: true,
@@ -2855,6 +3367,7 @@ function evaluateRagClaimCitationSupport(context) {
         normalizeWhitespace(String(fragment.title || '').trim()),
         normalizeWhitespace(String(fragment.text || '').trim()),
     ].filter(Boolean).join(' '))
+        .concat(citationBackedPlanEvidence.map((evidence) => normalizeWhitespace(evidence.text)))
         .filter(Boolean)
         .join(' ');
     const supportFeatures = new Set(collectClaimSupportFeatures(supportText));
@@ -2879,7 +3392,7 @@ function evaluateRagClaimCitationSupport(context) {
         supportedClaimCount,
         weakClaims,
         unsupportedClaims,
-        citationBackedFragmentCount: citationBackedFragments.length,
+        citationBackedFragmentCount: citationBackedEvidenceCount,
     };
 }
 function buildRagClaimCitationSupportMessage(result) {
@@ -2920,6 +3433,120 @@ function isMetaDocumentaryAnswer(answer) {
     return (ENGLISH_META_DOCUMENTARY_PATTERN.test(normalizedAnswer)
         || CHINESE_META_DOCUMENTARY_PATTERN.test(normalizedAnswer));
 }
+function normalizeQuerySubject(value) {
+    return normalizeWhitespace(String(value || ''))
+        .replace(/^["'“”‘’`]+|["'“”‘’`]+$/gu, '')
+        .replace(/^(?:a|an|the)\s+/iu, '')
+        .replace(/[?？!！。.;；:,，]+$/u, '')
+        .trim();
+}
+function stripDefinitionQuestionPredicate(value) {
+    return normalizeWhitespace(value)
+        .replace(/^(?:(?:a|an|the)\s+)?(?:prerequisite|precondition|requirement|dependency|dependencies)\s+(?:for|of)\s+/iu, '')
+        .replace(/\s+(?:made\s+of|composed\s+of|consists?\s+of|used\s+for|used\s+to|designed\s+for|designed\s+to|intended\s+for|located\s+in|found\s+in|contains?|includes?|depends?\s+on)\b.*$/iu, '')
+        .trim();
+}
+function querySubjectFeatures(value) {
+    return collectLexicalFeatures(value)
+        .map((feature) => String(feature || '').trim().toLowerCase())
+        .filter((feature) => feature.length > 0 && !QUERY_SUBJECT_STOPWORDS.has(feature));
+}
+function compactSubject(value) {
+    return normalizeQuerySubject(value)
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}]+/gu, '');
+}
+function scoreQuerySubjectAgainstLabel(subject, label) {
+    const normalizedSubject = normalizeQuerySubject(subject);
+    const normalizedLabel = normalizeQuerySubject(label);
+    if (!normalizedSubject || !normalizedLabel) {
+        return 0;
+    }
+    const subjectCompact = compactSubject(normalizedSubject);
+    const labelCompact = compactSubject(normalizedLabel);
+    if (!subjectCompact || !labelCompact) {
+        return 0;
+    }
+    if (subjectCompact === labelCompact) {
+        return 1;
+    }
+    // Parenthetical bilingual titles and qualified headings are valid aliases.
+    if (labelCompact.includes(subjectCompact)) {
+        return 0.95;
+    }
+    const subjectFeatures = querySubjectFeatures(normalizedSubject);
+    const labelFeatures = new Set(querySubjectFeatures(normalizedLabel));
+    if (subjectFeatures.length <= 0 || labelFeatures.size <= 0) {
+        return 0;
+    }
+    const overlap = subjectFeatures.filter((feature) => labelFeatures.has(feature)).length;
+    return Number((overlap / subjectFeatures.length).toFixed(4));
+}
+function collectQuerySubjectEvidenceLabels(context) {
+    const labels = [
+        ...(context.ragContextPack?.fragments || [])
+            .filter((fragment) => fragment.role !== 'graph_neighbor_support' && fragment.role !== 'background')
+            .flatMap((fragment) => [fragment.title || '', fragment.sourcePath || '', fragment.documentId || '']),
+        ...context.citations.flatMap((citation) => [citation.title || '', citation.sourcePath || '', citation.documentId || '']),
+        ...context.knowledgePoints.map((point) => point.title || ''),
+    ]
+        .map((label) => normalizeQuerySubject(String(label || '')))
+        .filter(Boolean);
+    return Array.from(new Set(labels));
+}
+function evaluateQuerySubjectAlignment(context) {
+    const subject = isDefinitionIntentQuery(context.message)
+        ? normalizeQuerySubject(stripDefinitionQuestionPredicate((0, answerTaskPlan_1.extractDefinitionQuerySubject)(context.message)))
+        : '';
+    if (!subject || querySubjectFeatures(subject).length <= 0) {
+        return {
+            passed: true,
+            applicable: false,
+            subject,
+            subjectFeatures: querySubjectFeatures(subject),
+            matchedLabels: [],
+            bestScore: 0,
+        };
+    }
+    const labels = collectQuerySubjectEvidenceLabels(context);
+    const scoredLabels = labels
+        .map((label) => ({ label, score: scoreQuerySubjectAgainstLabel(subject, label) }))
+        .filter((entry) => entry.score > 0)
+        .sort((left, right) => right.score - left.score);
+    const attributeQuery = /^(.+?)\s+(?:for|of)\s+(.+)$/iu.exec(subject);
+    if ((scoredLabels[0]?.score || 0) < 0.9 && attributeQuery
+        && labels.some(label => scoreQuerySubjectAgainstLabel(attributeQuery[2], label) >= 0.9)) {
+        // A title can name an entity while its body states the requested attribute.
+        // Require both witnesses; sharing an attribute with a different entity is insufficient.
+        const attributeSubject = `${attributeQuery[2]} ${attributeQuery[1]}`;
+        for (const candidate of buildSupportCandidates(context)) {
+            for (const frame of extractSubjectFrames(candidate.text)) {
+                const score = scoreQuerySubjectAgainstLabel(attributeSubject, frame.subject);
+                if (score >= 0.9)
+                    scoredLabels.push({ label: `${candidate.label}: ${frame.subject}`, score });
+            }
+        }
+        scoredLabels.sort((left, right) => right.score - left.score);
+    }
+    const bestScore = scoredLabels[0]?.score || 0;
+    return {
+        passed: bestScore >= 0.9,
+        applicable: true,
+        subject,
+        subjectFeatures: querySubjectFeatures(subject),
+        matchedLabels: scoredLabels.filter((entry) => entry.score >= 0.9).map((entry) => entry.label).slice(0, 3),
+        bestScore,
+    };
+}
+function buildQuerySubjectAlignmentMessage(result) {
+    if (!result.applicable) {
+        return 'The query did not expose a stable definition subject, so subject alignment stayed conservative.';
+    }
+    if (result.passed) {
+        return `Evidence titles aligned with the requested subject "${result.subject}" (best match ${Math.round(result.bestScore * 100)}%).`;
+    }
+    return `Evidence titles did not establish the requested subject "${result.subject}" (best match ${Math.round(result.bestScore * 100)}%); unrelated entities must not be released as the answer.`;
+}
 function evaluateQueryIntentAlignment(context) {
     if (!isDefinitionIntentQuery(context.message)) {
         return {
@@ -2945,7 +3572,10 @@ function evaluateQueryIntentAlignment(context) {
         };
     }
     return {
-        passed: !isMetaDocumentaryAnswer(context.draftAnswer),
+        // Full mode intentionally emits a report preface and section headers;
+        // those are allowed as long as the answer also contains the grounded
+        // definition frame. Slim mode keeps the stricter documentary guard.
+        passed: context.responseMode === 'full' || !isMetaDocumentaryAnswer(context.draftAnswer),
         applicable: true,
         comparableFrameCount: supportFrames.length,
         supportFrame: primarySupportFrame,
@@ -3284,7 +3914,7 @@ function evaluateStructuredComparisonConsistency(context) {
     };
 }
 function evaluateSubjectConsistency(context) {
-    const answerFrames = extractSubjectFrames(context.draftAnswer);
+    const answerFrames = extractSubjectFrames(removeSupportedSourceLabels(context, context.draftAnswer));
     if (answerFrames.length <= 0) {
         return {
             passed: true,
@@ -3638,7 +4268,15 @@ function evaluateStateConsistency(context) {
     };
 }
 function evaluatePolarityConsistency(context) {
-    const answerSentences = extractPolaritySentences(context.draftAnswer);
+    const sourceHeadings = new Set([
+        ...context.knowledgePoints.map(point => point.title),
+        ...context.citations.map(citation => citation.title),
+        ...(context.ragContextPack?.fragments || []).flatMap(fragment => [fragment.title || '', ...(fragment.headingPath || [])]),
+    ].map(title => normalizeWhitespace(title).toLowerCase()).filter(Boolean));
+    // A known source title is identity/presentation, not a positive assertion.
+    // Unknown headings remain subject to the same contradiction checks as prose.
+    const omitSourceTitleHeadings = (text) => text.replace(/^ {0,3}#{1,6}[\t ]+(.+?)(?:[\t ]+#+[\t ]*)?$/gmu, (heading, title) => (sourceHeadings.has(normalizeWhitespace(title).toLowerCase()) ? '' : heading));
+    const answerSentences = extractPolaritySentences(omitSourceTitleHeadings(removeSupportedSourceLabels(context, context.draftAnswer)), context.responseMode);
     if (answerSentences.length <= 0) {
         return {
             passed: true,
@@ -3646,7 +4284,7 @@ function evaluatePolarityConsistency(context) {
             conflicts: [],
         };
     }
-    const supportSentences = buildSupportCandidates(context).flatMap((candidate) => (extractPolaritySentences(candidate.text).map((sentence) => ({
+    const supportSentences = buildSupportCandidates(context).flatMap((candidate) => (extractPolaritySentences(omitSourceTitleHeadings(candidate.text), context.responseMode).map((sentence) => ({
         ...sentence,
         label: candidate.label,
     }))));
@@ -3812,20 +4450,55 @@ function evaluateTemporalValidityConsistency(context) {
         },
     };
 }
-function checkPublicSurfaceContraction(answer) {
-    const normalizedAnswer = String(answer || '');
-    if (normalizeWhitespace(normalizedAnswer).length > ANSWER_RELEASE_PUBLIC_CHAR_LIMIT) {
+function checkPublicSurfaceContraction(answer, responseMode = 'slim') {
+    // Learning-route bullets are an explicit typed deliverable, not internal
+    // diagnostics. Exclude that section from the legacy contraction heuristic.
+    const normalizedAnswer = stripLearningRoutePresentation(String(answer || ''));
+    const forbiddenScaffolding = (/\bGrounded by\b/i.test(normalizedAnswer)
+        || /\bKey evidence\b/i.test(normalizedAnswer)
+        || /\bCitations?:\b/i.test(normalizedAnswer));
+    if (forbiddenScaffolding) {
         return false;
     }
-    return !(/\bGrounded by\b/i.test(normalizedAnswer)
-        || /\bKey evidence\b/i.test(normalizedAnswer)
-        || /\bCitations?:\b/i.test(normalizedAnswer)
-        || /\n\s*[-*]\s+/u.test(normalizedAnswer));
+    return responseMode === 'full' || !/\n\s*[-*]\s+/u.test(normalizedAnswer);
+}
+function finalPublicAnswerPassesSemanticSafety(context, answer) {
+    const finalContext = {
+        ...context,
+        draftAnswer: String(answer || '').replace(/\r?\n/gu, ' '),
+    };
+    const checks = [
+        ['structured', evaluateStructuredConsistency(finalContext).passed],
+        ['structuredComparison', evaluateStructuredComparisonConsistency(finalContext).passed],
+        ['attribute', evaluateAttributeConsistency(finalContext).passed],
+        ['containment', evaluateContainmentConsistency(finalContext).passed],
+        ['composition', evaluateCompositionConsistency(finalContext).passed],
+        ['purpose', evaluatePurposeConsistency(finalContext).passed],
+        ['dependency', evaluateDependencyConsistency(finalContext).passed],
+        ['location', evaluateLocationConsistency(finalContext).passed],
+        ['subject', evaluateSubjectConsistency(finalContext).passed],
+        ['state', evaluateStateConsistency(finalContext).passed],
+        ['polarity', evaluatePolarityConsistency(finalContext).passed],
+        ['graphCausal', evaluateGraphCausalConsistency(finalContext).passed],
+        ['graphOrder', evaluateGraphOrderConsistency(finalContext).passed],
+        ['graphComparison', evaluateGraphComparisonConsistency(finalContext).passed],
+    ];
+    return checks.every(([, passed]) => passed);
+}
+function finalPublicAnswerPassesReleaseContract(context, answer, requireSemanticSafety, responseMode = 'slim') {
+    return hasBalancedPublicMathDelimiters(answer)
+        && checkPublicSurfaceContraction(answer, responseMode)
+        && (!requireSemanticSafety || finalPublicAnswerPassesSemanticSafety(context, answer));
 }
-function buildDecision(groundedEvidenceAvailable, groundingAlignmentPassed, queryIntentAlignmentPassed, structuredConsistencyPassed, structuredComparisonConsistencyPassed, attributeConsistencyPassed, containmentConsistencyPassed, compositionConsistencyPassed, purposeConsistencyPassed, dependencyConsistencyPassed, locationConsistencyPassed, subjectConsistencyPassed, stateConsistencyPassed, polarityConsistencyPassed, graphCausalConsistencyPassed, graphOrderConsistencyPassed, graphComparisonConsistencyPassed, temporalValidityConsistencyPassed, ragAnswerCompletenessPassed, ragClaimCitationSupportPassed, leakedInternalFragments, publicSurfaceContracted) {
+function buildDecision(groundedEvidenceAvailable, groundingAlignmentPassed, queryIntentAlignmentPassed, querySubjectAlignmentPassed, structuredConsistencyPassed, structuredComparisonConsistencyPassed, attributeConsistencyPassed, containmentConsistencyPassed, compositionConsistencyPassed, purposeConsistencyPassed, dependencyConsistencyPassed, locationConsistencyPassed, subjectConsistencyPassed, stateConsistencyPassed, polarityConsistencyPassed, graphCausalConsistencyPassed, graphOrderConsistencyPassed, graphComparisonConsistencyPassed, temporalValidityConsistencyPassed, ragAnswerCompletenessPassed, ragClaimCitationSupportPassed, graphAnswerPlanCoveragePassed, leakedInternalFragments, publicSurfaceContracted) {
     if (!groundedEvidenceAvailable) {
         return 'abstain';
     }
+    // A grounded answer for the wrong entity is unsafe to revise into shape:
+    // the only valid public outcome is an explicit abstention.
+    if (!querySubjectAlignmentPassed) {
+        return 'abstain';
+    }
     if (!groundingAlignmentPassed
         || !queryIntentAlignmentPassed
         || !structuredConsistencyPassed
@@ -3845,6 +4518,7 @@ function buildDecision(groundedEvidenceAvailable, groundingAlignmentPassed, quer
         || !temporalValidityConsistencyPassed
         || !ragAnswerCompletenessPassed
         || !ragClaimCitationSupportPassed
+        || !graphAnswerPlanCoveragePassed
         || leakedInternalFragments.length > 0
         || !publicSurfaceContracted) {
         return 'revise';
@@ -3862,8 +4536,64 @@ function buildReason(decision, groundedEvidenceAvailable) {
         ? 'Draft answer was downgraded even though some evidence existed.'
         : 'Draft answer lacked grounded evidence, so the public answer was downgraded to a concise abstention.';
 }
+function evaluateLearningRouteSubjectAlignment(plan) {
+    const taskPlan = plan?.answerTaskPlan;
+    const route = taskPlan?.learningRoute || [];
+    if (!taskPlan?.subtasks.some((subtask) => subtask.kind === 'learning_route')) {
+        return true;
+    }
+    const subjectKey = normalizeWhitespace(taskPlan.primarySubject)
+        .replace(/[^\p{L}\p{N}]+/gu, '')
+        .toLowerCase();
+    if (!subjectKey || route.length < 3) {
+        return false;
+    }
+    return route.some((node) => {
+        const titleKey = normalizeWhitespace(node.title)
+            .replace(/[^\p{L}\p{N}]+/gu, '')
+            .toLowerCase();
+        return node.role === 'core' && Boolean(titleKey && (titleKey === subjectKey
+            || titleKey.includes(subjectKey)
+            || subjectKey.includes(titleKey)));
+    });
+}
+function evaluateLearningRouteOrderEvidence(plan) {
+    const taskPlan = plan?.answerTaskPlan;
+    const route = taskPlan?.learningRoute || [];
+    if (!taskPlan?.subtasks.some((subtask) => subtask.kind === 'learning_route')) {
+        return true;
+    }
+    const explicitOrderingPresent = route.some((node) => (node.orderingBasis === 'explicit_prerequisite'
+        || node.orderingBasis === 'explicit_sequence'));
+    return route.length >= 3
+        && route.every((node, index) => node.order === index + 1 && node.evidenceRefs.length > 0)
+        && route.some((node) => node.role === 'core')
+        && (!explicitOrderingPresent || route.some((node) => node.orderingBasis === 'explicit_prerequisite'));
+}
+function buildAnswerTaskCoverageMessage(result) {
+    if (!result.applicable) {
+        return 'No compound answer-task contract was active for this request.';
+    }
+    if (result.passed) {
+        return `The public answer covered all ${result.coveredSubtaskIds.length} required answer deliverable(s).`;
+    }
+    return `The public answer is missing required deliverable(s): ${result.missingRequiredSubtaskIds.join(', ')}.`;
+}
+function appendAnswerTaskDeliverables(answer, plan, answerLanguage) {
+    const normalizedAnswer = String(answer || '').replace(/\r\n?/gu, '\n').trim();
+    if (!plan || !plan.subtasks.some((subtask) => subtask.kind === 'learning_route') || plan.learningRoute.length <= 0) {
+        return normalizedAnswer;
+    }
+    const useChinese = answerLanguage === 'zh'
+        || (answerLanguage !== 'en' && /[\u3400-\u9fff]/u.test(`${normalizedAnswer} ${plan.primarySubject}`));
+    const routeText = (0, answerTaskPlan_1.formatLearningRouteAnswer)(plan, useChinese);
+    if (!routeText || normalizedAnswer.includes(routeText)) {
+        return normalizedAnswer;
+    }
+    return (0, answerTaskPlan_1.formatTaskAwareAnswer)([normalizedAnswer], plan, useChinese);
+}
 function reviewAnswerRelease(context) {
-    const draftAnswer = normalizeWhitespace(context.draftAnswer);
+    const draftAnswer = normalizePublicAnswerSurface(context.draftAnswer);
     const groundedEvidenceAvailable = context.knowledgePoints.length > 0
         || context.citations.length > 0
         || hasUsableRagEvidenceContext(context);
@@ -3889,6 +4619,19 @@ function reviewAnswerRelease(context) {
             comparableFrameCount: 0,
             supportFrame: null,
         };
+    const querySubjectAlignment = groundedEvidenceAvailable
+        ? evaluateQuerySubjectAlignment({
+            ...context,
+            draftAnswer,
+        })
+        : {
+            passed: true,
+            applicable: false,
+            subject: '',
+            subjectFeatures: [],
+            matchedLabels: [],
+            bestScore: 0,
+        };
     const structuredConsistency = groundedEvidenceAvailable
         ? evaluateStructuredConsistency({
             ...context,
@@ -4066,23 +4809,34 @@ function reviewAnswerRelease(context) {
             unsupportedClaims: [],
             citationBackedFragmentCount: 0,
         };
-    const publicSurfaceContracted = checkPublicSurfaceContraction(draftAnswer);
+    const draftAnswerTaskCoverage = groundedEvidenceAvailable
+        ? (0, answerTaskPlan_1.reviewAnswerTaskCoverage)(draftAnswer, context.graphAnswerPlan?.answerTaskPlan)
+        : (0, answerTaskPlan_1.reviewAnswerTaskCoverage)('', null);
+    const publicGraphAnswerPlan = projectPublicGraphAnswerPlan(context.graphAnswerPlan, context.ragContextPack, context.message);
+    const verifiedRagConflictDisclosurePlan = isVerifiedRagConflictDisclosurePlan(context, publicGraphAnswerPlan);
+    const definitionProjectionIntegrityPassed = !(context.graphAnswerPlan?.intent === 'definition'
+        && (context.graphAnswerPlan.claims || []).some((claim) => claim.required)
+        && (publicGraphAnswerPlan?.claims || []).length <= 0);
+    const draftGraphAnswerPlanCoverage = groundedEvidenceAvailable
+        ? (0, graphAnswerCoverage_1.reviewGraphAnswerCoverage)(draftAnswer, publicGraphAnswerPlan)
+        : (0, graphAnswerCoverage_1.reviewGraphAnswerCoverage)('', null);
+    const publicSurfaceContracted = checkPublicSurfaceContraction(draftAnswer, context.responseMode);
     const graphSupportCount = context.graphContext
         ? ((Array.isArray(context.graphContext.relationSummaries) ? context.graphContext.relationSummaries.length : 0)
             + (Array.isArray(context.graphContext.connectionPaths) ? context.graphContext.connectionPaths.length : 0)
             + (Array.isArray(context.graphContext.supportingAtomIds) ? context.graphContext.supportingAtomIds.length : 0))
         : 0;
     const graphSupportSufficient = context.knowledgePoints.length <= 0 || graphSupportCount > 0 || Boolean(context.graphContext?.anchorAtomId);
-    const decision = buildDecision(groundedEvidenceAvailable, groundingAlignment.passed, queryIntentAlignment.passed, structuredConsistency.passed, structuredComparisonConsistency.passed, attributeConsistency.passed, containmentConsistency.passed, compositionConsistency.passed, purposeConsistency.passed, dependencyConsistency.passed, locationConsistency.passed, subjectConsistency.passed, stateConsistency.passed, polarityConsistency.passed, graphCausalConsistency.passed, graphOrderConsistency.passed, graphComparisonConsistency.passed, temporalValidityConsistency.passed, ragAnswerCompleteness.passed, ragClaimCitationSupport.passed, leakedInternalFragments, publicSurfaceContracted);
+    const draftDecision = buildDecision(groundedEvidenceAvailable, groundingAlignment.passed, queryIntentAlignment.passed, querySubjectAlignment.passed, structuredConsistency.passed, structuredComparisonConsistency.passed, attributeConsistency.passed, containmentConsistency.passed, compositionConsistency.passed, purposeConsistency.passed, dependencyConsistency.passed, locationConsistency.passed, subjectConsistency.passed, stateConsistency.passed, polarityConsistency.passed, graphCausalConsistency.passed, graphOrderConsistency.passed, graphComparisonConsistency.passed, temporalValidityConsistency.passed, ragAnswerCompleteness.passed, ragClaimCitationSupport.passed, draftGraphAnswerPlanCoverage.passed, leakedInternalFragments, publicSurfaceContracted);
     const primaryGraphCausalConflict = graphCausalConsistency.conflicts[0];
     const primaryGraphOrderConflict = graphOrderConsistency.conflicts[0];
     const primaryGraphComparisonConflict = graphComparisonConsistency.conflicts[0];
     const primaryStructuredComparisonConflict = structuredComparisonConsistency.conflicts[0];
     const primaryTemporalValidityConflict = temporalValidityConsistency.conflict;
-    const publicAnswer = normalizeWhitespace(decision === 'abstain'
-        ? buildAbstentionAnswer(context.message, context.usedScope)
-        : decision === 'revise'
-            ? (primaryTemporalValidityConflict
+    let revisedPublicAnswer = draftDecision === 'abstain'
+        ? buildAbstentionAnswer(context)
+        : draftDecision === 'revise'
+            ? appendAnswerTaskDeliverables((primaryTemporalValidityConflict
                 ? buildTemporalValidityRevisionAnswer(context, primaryTemporalValidityConflict)
                 : primaryGraphCausalConflict
                     ? buildGraphCausalRevisionAnswer(context, primaryGraphCausalConflict)
@@ -4094,8 +4848,133 @@ function reviewAnswerRelease(context) {
                                 ? buildStructuredComparisonRevisionAnswer(context, primaryStructuredComparisonConflict)
                                 : (!queryIntentAlignment.passed && queryIntentAlignment.supportFrame)
                                     ? buildDefinitionIntentRevisionAnswer(context, queryIntentAlignment.supportFrame)
-                                    : buildGroundedRevisionAnswer(context))
-            : buildReleasedPublicAnswer(context, draftAnswer));
+                                    : buildGroundedRevisionAnswer(context)), context.graphAnswerPlan?.answerTaskPlan, context.answerLanguage)
+            : appendAnswerTaskDeliverables(buildReleasedPublicAnswer(context, draftAnswer), context.graphAnswerPlan?.answerTaskPlan, context.answerLanguage);
+    // Every claim-level consistency gate is a semantic safety boundary. A plan may
+    // improve coverage, but must never overwrite a correction from any of them.
+    const requiresSafetyCorrection = !verifiedRagConflictDisclosurePlan && [
+        querySubjectAlignment.passed,
+        groundingAlignment.passed,
+        structuredConsistency.passed,
+        structuredComparisonConsistency.passed,
+        attributeConsistency.passed,
+        containmentConsistency.passed,
+        compositionConsistency.passed,
+        purposeConsistency.passed,
+        dependencyConsistency.passed,
+        locationConsistency.passed,
+        subjectConsistency.passed,
+        stateConsistency.passed,
+        polarityConsistency.passed,
+        graphCausalConsistency.passed,
+        graphOrderConsistency.passed,
+        graphComparisonConsistency.passed,
+        temporalValidityConsistency.passed,
+    ].some((passed) => !passed);
+    if (context.responseMode === 'full'
+        && !requiresSafetyCorrection
+        && leakedInternalFragments.length <= 0
+        && hasBalancedPublicMathDelimiters(draftAnswer)) {
+        // Full mode owns the report surface. A non-safety gate (for example a
+        // slim projection coverage heuristic) must not collapse it back to a
+        // single definition sentence.
+        revisedPublicAnswer = draftAnswer;
+    }
+    const candidatePublicPlanCoverage = groundedEvidenceAvailable
+        ? (0, graphAnswerCoverage_1.reviewGraphAnswerCoverage)(revisedPublicAnswer, publicGraphAnswerPlan)
+        : (0, graphAnswerCoverage_1.reviewGraphAnswerCoverage)('', null);
+    const requiresDefinitionProjection = Boolean(publicGraphAnswerPlan?.intent === 'definition'
+        && (!candidatePublicPlanCoverage.passed
+            || !hasBalancedPublicMathDelimiters(revisedPublicAnswer)
+            || isDefinitionComparisonOrArtifactClaim(revisedPublicAnswer)));
+    const shouldPreservePublicPlan = Boolean(publicGraphAnswerPlan
+        && definitionProjectionIntegrityPassed
+        && !requiresSafetyCorrection
+        && context.responseMode !== 'full'
+        && (requiresDefinitionProjection
+            || (context.ragContextPack?.fragments || []).length > 0));
+    let effectivePublicGraphAnswerPlan = requiresSafetyCorrection
+        ? createEmptyPublicGraphAnswerPlan(context.graphAnswerPlan)
+        : publicGraphAnswerPlan;
+    let decision = definitionProjectionIntegrityPassed
+        ? draftDecision
+        : 'abstain';
+    if (decision === 'release'
+        && draftAnswerTaskCoverage.applicable
+        && !draftAnswerTaskCoverage.passed) {
+        decision = 'revise';
+    }
+    let publicAnswer = context.responseMode === 'full'
+        ? revisedPublicAnswer
+        : preservePlannedGraphAnswerClaims(revisedPublicAnswer, shouldPreservePublicPlan ? effectivePublicGraphAnswerPlan : null);
+    if (decision !== 'abstain') {
+        publicAnswer = appendAnswerTaskDeliverables(publicAnswer, context.graphAnswerPlan?.answerTaskPlan, context.answerLanguage);
+    }
+    let graphAnswerPlanCoverage = groundedEvidenceAvailable
+        ? (0, graphAnswerCoverage_1.reviewGraphAnswerCoverage)(publicAnswer, effectivePublicGraphAnswerPlan)
+        : (0, graphAnswerCoverage_1.reviewGraphAnswerCoverage)('', null);
+    if (!definitionProjectionIntegrityPassed) {
+        publicAnswer = buildAbstentionAnswer(context);
+        effectivePublicGraphAnswerPlan = createEmptyPublicGraphAnswerPlan(context.graphAnswerPlan);
+        graphAnswerPlanCoverage = (0, graphAnswerCoverage_1.reviewGraphAnswerCoverage)(publicAnswer, effectivePublicGraphAnswerPlan);
+    }
+    if (groundedEvidenceAvailable
+        && effectivePublicGraphAnswerPlan
+        && graphAnswerPlanCoverage.applicable
+        && !graphAnswerPlanCoverage.passed) {
+        if (context.responseMode === 'full') {
+            decision = decision === 'abstain' ? 'abstain' : 'revise';
+        }
+        else {
+            const coveragePreservingAnswer = preservePlannedGraphAnswerClaims('', effectivePublicGraphAnswerPlan);
+            const coveragePreservingReview = (0, graphAnswerCoverage_1.reviewGraphAnswerCoverage)(coveragePreservingAnswer, effectivePublicGraphAnswerPlan);
+            if (coveragePreservingReview.passed) {
+                publicAnswer = coveragePreservingAnswer;
+                graphAnswerPlanCoverage = coveragePreservingReview;
+                decision = 'revise';
+            }
+            else {
+                publicAnswer = buildAbstentionAnswer(context);
+                graphAnswerPlanCoverage = (0, graphAnswerCoverage_1.reviewGraphAnswerCoverage)(publicAnswer, effectivePublicGraphAnswerPlan);
+                decision = 'abstain';
+            }
+        }
+    }
+    if (decision !== 'abstain') {
+        publicAnswer = discloseRagEvidenceConflicts(context, publicAnswer);
+    }
+    if (decision !== 'abstain'
+        && !finalPublicAnswerPassesReleaseContract(context, publicAnswer, Boolean(shouldPreservePublicPlan
+            && effectivePublicGraphAnswerPlan
+            && effectivePublicGraphAnswerPlan.claims.length > 0
+            && !verifiedRagConflictDisclosurePlan), context.responseMode)) {
+        const correctedAnswer = normalizeWhitespace(revisedPublicAnswer);
+        effectivePublicGraphAnswerPlan = createEmptyPublicGraphAnswerPlan(context.graphAnswerPlan);
+        if (correctedAnswer && finalPublicAnswerPassesReleaseContract(context, correctedAnswer, false, context.responseMode)) {
+            publicAnswer = correctedAnswer;
+            graphAnswerPlanCoverage = (0, graphAnswerCoverage_1.reviewGraphAnswerCoverage)(publicAnswer, effectivePublicGraphAnswerPlan);
+            decision = 'revise';
+        }
+        else {
+            publicAnswer = buildAbstentionAnswer(context);
+            graphAnswerPlanCoverage = (0, graphAnswerCoverage_1.reviewGraphAnswerCoverage)(publicAnswer, effectivePublicGraphAnswerPlan);
+            decision = 'abstain';
+        }
+    }
+    const answerTaskCoverage = groundedEvidenceAvailable
+        ? (0, answerTaskPlan_1.reviewAnswerTaskCoverage)(publicAnswer, context.graphAnswerPlan?.answerTaskPlan)
+        : (0, answerTaskPlan_1.reviewAnswerTaskCoverage)('', null);
+    const learningRouteSubjectAlignment = groundedEvidenceAvailable
+        ? evaluateLearningRouteSubjectAlignment(context.graphAnswerPlan)
+        : true;
+    const learningRouteOrderEvidence = groundedEvidenceAvailable
+        ? evaluateLearningRouteOrderEvidence(context.graphAnswerPlan)
+        : true;
+    if (decision === 'release'
+        && answerTaskCoverage.applicable
+        && (!answerTaskCoverage.passed || !learningRouteSubjectAlignment || !learningRouteOrderEvidence)) {
+        decision = 'revise';
+    }
     const abstentionHygienePassed = decision !== 'abstain'
         || (collectLeakedInternalFragments(publicAnswer).length <= 0
             && !/\bretrieval\b/i.test(publicAnswer)
@@ -4137,6 +5016,13 @@ function reviewAnswerRelease(context) {
                         : 'No grounded definition frame was available, so intent alignment stayed conservative.')
                 : 'No evidence was available, so definition-intent alignment was not evaluated.',
         },
+        {
+            gateId: 'query_subject_alignment',
+            passed: querySubjectAlignment.passed,
+            message: groundedEvidenceAvailable
+                ? buildQuerySubjectAlignmentMessage(querySubjectAlignment)
+                : 'No evidence was available, so query-subject alignment was not evaluated.',
+        },
         {
             gateId: 'claim_structured_consistency',
             passed: structuredConsistency.passed,
@@ -4280,6 +5166,56 @@ function reviewAnswerRelease(context) {
             passed: ragClaimCitationSupport.passed,
             message: buildRagClaimCitationSupportMessage(ragClaimCitationSupport),
         },
+        {
+            gateId: 'graph_answer_plan_coverage',
+            passed: graphAnswerPlanCoverage.passed,
+            message: !graphAnswerPlanCoverage.applicable
+                ? 'No required graph-answer claims were active for this answer.'
+                : graphAnswerPlanCoverage.passed
+                    ? `The public answer covered all ${graphAnswerPlanCoverage.requiredClaimIds.length} required graph-answer claim(s).`
+                    : `The public answer omitted required graph-answer claims: ${graphAnswerPlanCoverage.missingRequiredClaimIds.join(', ')}.`,
+        },
+        {
+            gateId: 'subtask_coverage',
+            passed: draftAnswerTaskCoverage.passed && answerTaskCoverage.passed,
+            message: draftAnswerTaskCoverage.passed
+                ? buildAnswerTaskCoverageMessage(answerTaskCoverage)
+                : `Draft answer ${buildAnswerTaskCoverageMessage(draftAnswerTaskCoverage).replace(/^The public answer /u, '').replace(/^公共回答/u, '')}`,
+        },
+        {
+            gateId: 'learning_route_subject_alignment',
+            passed: learningRouteSubjectAlignment,
+            message: learningRouteSubjectAlignment
+                ? 'Learning-route nodes retained the requested subject as the core anchor.'
+                : 'Learning-route nodes did not establish the requested subject as a core anchor.',
+        },
+        {
+            gateId: 'learning_route_order_evidence',
+            passed: learningRouteOrderEvidence,
+            message: learningRouteOrderEvidence
+                ? 'Learning-route order is sequential and every node retains evidence references; explicit prerequisite order is used when available.'
+                : 'Learning-route order or evidence references were insufficient for release; unsupported prerequisite order was not inferred.',
+        },
+        {
+            gateId: 'deliverable_completeness',
+            passed: draftAnswerTaskCoverage.passed
+                && answerTaskCoverage.passed
+                && learningRouteSubjectAlignment
+                && learningRouteOrderEvidence,
+            message: draftAnswerTaskCoverage.passed
+                && answerTaskCoverage.passed
+                && learningRouteSubjectAlignment
+                && learningRouteOrderEvidence
+                ? 'All required answer deliverables were present and evidence-bounded.'
+                : 'At least one required answer deliverable was missing or not evidence-bounded.',
+        },
+        {
+            gateId: 'definition_projection_integrity',
+            passed: definitionProjectionIntegrityPassed,
+            message: definitionProjectionIntegrityPassed
+                ? 'Definition-plan projection retained at least one eligible required public claim when projection was required.'
+                : 'Required definition claims projected to zero eligible public claims, so the answer was downgraded to abstention.',
+        },
         {
             gateId: 'public_surface_contraction',
             passed: publicSurfaceContracted,
@@ -4311,6 +5247,11 @@ function reviewAnswerRelease(context) {
         revised: publicAnswer !== draftAnswer,
         originalAnswer: draftAnswer,
         publicAnswer,
+        publicGraphAnswerPlan: effectivePublicGraphAnswerPlan || undefined,
+        auditGraphAnswerPlan: context.graphAnswerPlan || undefined,
+        graphAnswerCoverage: graphAnswerPlanCoverage,
+        answerTaskCoverage,
+        draftAnswerTaskCoverage,
         reason: buildReason(decision, groundedEvidenceAvailable),
         failedGateIds,
         leakedInternalFragments,