noteconnection 1.7.0 → 1.9.0

package/dist/src/learning/graphAnswerQualityCalibration.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_GRAPH_ANSWER_QUALITY_CORPUS = exports.GRAPH_ANSWER_QUALITY_POLICY_VERSION = void 0;
+exports.evaluateGraphAnswerQualityCalibration = evaluateGraphAnswerQualityCalibration;
+const graphAnswerCoverageCalibration_1 = require("./graphAnswerCoverageCalibration");
+const graphClaimMatcher_1 = require("./graphClaimMatcher");
+const graphAnswerQualityPolicy_1 = require("./graphAnswerQualityPolicy");
+const ragEvidenceQuality_1 = require("./ragEvidenceQuality");
+const ragPublicText_1 = require("./ragPublicText");
+var graphAnswerQualityPolicy_2 = require("./graphAnswerQualityPolicy");
+Object.defineProperty(exports, "GRAPH_ANSWER_QUALITY_POLICY_VERSION", { enumerable: true, get: function () { return graphAnswerQualityPolicy_2.GRAPH_ANSWER_QUALITY_POLICY_VERSION; } });
+exports.DEFAULT_GRAPH_ANSWER_QUALITY_CORPUS = {
+    version: graphAnswerQualityPolicy_1.GRAPH_ANSWER_QUALITY_POLICY_VERSION,
+    coverageCases: graphAnswerCoverageCalibration_1.DEFAULT_GRAPH_ANSWER_COVERAGE_CALIBRATION_CASES,
+    sourceQualityCases: [
+        {
+            caseId: 'source_quality_equation_over_documentary_en',
+            preferredClause: 'The thermal flux is q = kA(T1 - T2) / L, so thickness changes the exchange rate.',
+            rejectedClause: 'This document will explain the following table as requested.',
+        },
+        {
+            caseId: 'source_quality_complete_fact_over_heading_en',
+            preferredClause: 'Glass conducts heat through the wall before the liquid temperature changes.',
+            rejectedClause: 'Thermal transfer:',
+        },
+        {
+            caseId: 'source_quality_complete_fact_over_meta_zh',
+            preferredClause: '热量穿过杯壁后，液体温度会上升。',
+            rejectedClause: '本文档旨在说明以下表格。',
+        },
+        {
+            caseId: 'source_quality_balanced_formula_over_fragment_en',
+            preferredClause: 'The pressure is P = rho g h, and the wall stress remains below the material limit.',
+            rejectedClause: 'The pressure is P = rho g h (',
+        },
+    ],
+    deduplicationCases: [
+        {
+            caseId: 'dedup_paraphrase_en',
+            left: 'A water glass is a transparent vessel used to hold water.',
+            right: 'A water glass is a transparent container used to hold water.',
+            expectedDuplicate: true,
+        },
+        {
+            caseId: 'dedup_paraphrase_zh',
+            left: '水杯是用于盛水的透明容器。',
+            right: '水杯是一种透明的盛水器皿。',
+            expectedDuplicate: true,
+        },
+        {
+            caseId: 'dedup_conflicting_value_en',
+            left: 'The release date is 2026-07-01.',
+            right: 'The release date is 2026-08-15.',
+            expectedDuplicate: false,
+        },
+        {
+            caseId: 'dedup_polarity_conflict_en',
+            left: 'Glass conducts heat through the wall.',
+            right: 'Glass does not conduct heat through the wall.',
+            expectedDuplicate: false,
+        },
+        {
+            caseId: 'dedup_distinct_mechanisms_en',
+            left: 'Heat passes through the wall by conduction.',
+            right: 'The curved vessel changes the path of incoming light.',
+            expectedDuplicate: false,
+        },
+        {
+            caseId: 'dedup_same_fact_with_heading_en',
+            left: 'The glass wall separates the liquid from the environment.',
+            right: 'The glass wall separates liquid from the environment.',
+            expectedDuplicate: true,
+        },
+    ],
+    branchCoverageCases: [
+        {
+            caseId: 'branch_compare_glass_plastic_en',
+            answer: 'Plastic is the comparison material, and compared with it, glass conducts heat better and remains more rigid.',
+            requiredBranchStatements: ['Glass conducts heat better.', 'Plastic is the comparison material.'],
+        },
+        {
+            caseId: 'branch_compare_glass_plastic_zh',
+            answer: '与塑料相比，玻璃导热更快。',
+            requiredBranchStatements: ['玻璃导热。', '塑料是比较对象。'],
+        },
+        {
+            caseId: 'branch_compare_environment_versions_en',
+            answer: 'Version 1 applies in staging, while version 2 applies in production.',
+            requiredBranchStatements: ['Version 1 applies in staging.', 'Version 2 applies in production.'],
+        },
+        {
+            caseId: 'branch_compare_material_boundary_zh',
+            answer: '玻璃是透明非晶态固体，塑料杯则是聚合物容器。',
+            requiredBranchStatements: ['玻璃是透明固体。', '塑料是聚合物容器。'],
+        },
+    ],
+    languageConsistencyCases: [
+        { caseId: 'language_en_definition', query: 'what is a water glass?', answer: 'A water glass is a transparent vessel for water.', expectedConsistent: true },
+        { caseId: 'language_zh_definition', query: '什么是水杯？', answer: '水杯是用于盛水的透明容器。', expectedConsistent: true },
+        { caseId: 'language_en_compare', query: 'compare glass and plastic', answer: 'Glass conducts heat better than plastic.', expectedConsistent: true },
+        { caseId: 'language_zh_compare', query: '比较玻璃和塑料', answer: '与塑料相比，玻璃导热更快。', expectedConsistent: true },
+        { caseId: 'language_en_math', query: 'what is the pressure?', answer: 'The pressure is P = rho g h.', expectedConsistent: true },
+        { caseId: 'language_mismatch_en_query_zh_answer', query: 'what is a water glass?', answer: '水杯是用于盛水的透明容器。', expectedConsistent: false },
+        { caseId: 'language_mismatch_zh_query_en_answer', query: '什么是水杯？', answer: 'A water glass is a transparent vessel for water.', expectedConsistent: false },
+    ],
+    readabilityCases: [
+        { caseId: 'readability_complete_en', answer: 'A water glass is a transparent vessel used to hold water.', expectedReadable: true },
+        { caseId: 'readability_complete_zh', answer: '水杯是用于盛水的透明容器。', expectedReadable: true },
+        { caseId: 'readability_balanced_math_en', answer: 'The pressure is P = rho g h, so a taller water column increases the load.', expectedReadable: true },
+        { caseId: 'readability_two_claims_en', answer: 'Glass conducts heat through the wall. The liquid temperature rises afterward.', expectedReadable: true },
+        { caseId: 'readability_two_claims_zh', answer: '热量穿过杯壁后，液体温度会上升。玻璃壁仍然把液体与环境分隔开。', expectedReadable: true },
+        { caseId: 'readability_reject_documentary_en', answer: 'This document will explain the following table as requested.', expectedReadable: false },
+        { caseId: 'readability_reject_unbalanced_formula_en', answer: 'The pressure is P = rho g h (.', expectedReadable: false },
+        { caseId: 'readability_reject_authoring_zh', answer: '本技术文档旨在说明下表。', expectedReadable: false },
+        { caseId: 'readability_reject_dangling_heading_en', answer: 'Thermal transfer:', expectedReadable: false },
+    ],
+};
+function metricFromOutcomes(outcomes) {
+    const passedCount = outcomes.filter((outcome) => outcome.passed).length;
+    return {
+        sampleCount: outcomes.length,
+        passedCount,
+        failedCaseIds: outcomes.filter((outcome) => !outcome.passed).map((outcome) => outcome.caseId),
+        accuracy: outcomes.length > 0 ? Number((passedCount / outcomes.length).toFixed(4)) : 0,
+    };
+}
+function detectLanguage(value) {
+    const cjkCount = (String(value || '').match(/[\u3400-\u9fff]/gu) || []).length;
+    const latinCount = (String(value || '').match(/[A-Za-z]/gu) || []).length;
+    return cjkCount > latinCount ? 'zh' : 'en';
+}
+function evaluateSourceQuality(cases) {
+    const margins = [];
+    const outcomes = cases.map((item) => {
+        const margin = (0, ragEvidenceQuality_1.scoreRagEvidenceClause)(item.preferredClause).score
+            - (0, ragEvidenceQuality_1.scoreRagEvidenceClause)(item.rejectedClause).score;
+        margins.push(margin);
+        return { caseId: item.caseId, passed: margin > 0 };
+    });
+    const metric = metricFromOutcomes(outcomes);
+    return {
+        ...metric,
+        pairwiseAccuracy: metric.accuracy,
+        minimumObservedMargin: margins.length > 0
+            ? Number(Math.min(...margins).toFixed(4))
+            : 0,
+    };
+}
+function evaluateDeduplication(cases) {
+    const outcomes = cases.map((item) => {
+        const observedDuplicate = (0, graphAnswerQualityPolicy_1.isPolaritySafeSemanticDuplicate)(item.left, item.right);
+        return { caseId: item.caseId, passed: observedDuplicate === item.expectedDuplicate };
+    });
+    return {
+        ...metricFromOutcomes(outcomes),
+        similarityThreshold: graphAnswerQualityPolicy_1.SUPPLEMENTAL_DEDUP_SIMILARITY_THRESHOLD,
+    };
+}
+function evaluateBranchCoverage(cases) {
+    const outcomes = [];
+    let requiredBranchCount = 0;
+    let coveredBranchCount = 0;
+    cases.forEach((item) => {
+        const branchResults = item.requiredBranchStatements.map((statement) => (0, graphClaimMatcher_1.matchGraphAnswerClaim)(item.answer, statement).covered);
+        const covered = branchResults.filter(Boolean).length;
+        requiredBranchCount += branchResults.length;
+        coveredBranchCount += covered;
+        const passed = covered === branchResults.length;
+        outcomes.push({ caseId: item.caseId, passed });
+    });
+    const metric = metricFromOutcomes(outcomes);
+    return {
+        ...metric,
+        requiredBranchCount,
+        coveredBranchCount,
+        recall: requiredBranchCount > 0 ? Number((coveredBranchCount / requiredBranchCount).toFixed(4)) : 0,
+    };
+}
+function evaluateLanguageConsistency(cases) {
+    const outcomes = cases.map((item) => {
+        const observedConsistent = detectLanguage(item.answer) === detectLanguage(item.query);
+        return { caseId: item.caseId, passed: observedConsistent === item.expectedConsistent };
+    });
+    return metricFromOutcomes(outcomes);
+}
+function evaluateReadability(cases) {
+    const minimumAcceptedScore = graphAnswerQualityPolicy_1.MINIMUM_READABILITY_SCORE;
+    const observedScores = [];
+    const outcomes = cases.map((item) => {
+        const clauses = (0, ragEvidenceQuality_1.segmentRagEvidenceClauses)(item.answer);
+        const qualities = clauses.map((clause) => ({
+            clause,
+            quality: (0, ragEvidenceQuality_1.scoreRagEvidenceClause)(clause),
+        }));
+        if (item.expectedReadable) {
+            qualities.forEach(({ quality }) => observedScores.push(quality.score));
+        }
+        const observedReadable = qualities.length > 0 && qualities.every(({ clause, quality }) => {
+            return quality.score >= minimumAcceptedScore
+                && quality.hasBalancedDelimiters
+                && !(0, ragPublicText_1.shouldRejectPublicEvidenceClause)(clause)
+                && !/[：:]$/u.test(clause);
+        });
+        return { caseId: item.caseId, passed: observedReadable === item.expectedReadable };
+    });
+    return {
+        ...metricFromOutcomes(outcomes),
+        minimumAcceptedScore,
+        minimumObservedScore: observedScores.length > 0
+            ? Number(Math.min(...observedScores).toFixed(4))
+            : 0,
+    };
+}
+function evaluateGraphAnswerQualityCalibration(corpus = exports.DEFAULT_GRAPH_ANSWER_QUALITY_CORPUS) {
+    const coverage = (0, graphAnswerCoverageCalibration_1.evaluateGraphAnswerCoverageCalibration)(corpus.coverageCases);
+    const sourceQuality = evaluateSourceQuality(corpus.sourceQualityCases);
+    const deduplication = evaluateDeduplication(corpus.deduplicationCases);
+    const branchCoverage = evaluateBranchCoverage(corpus.branchCoverageCases);
+    const languageConsistency = evaluateLanguageConsistency(corpus.languageConsistencyCases);
+    const readability = evaluateReadability(corpus.readabilityCases);
+    const versionCompatible = corpus.version === graphAnswerQualityPolicy_1.GRAPH_ANSWER_QUALITY_POLICY_VERSION;
+    const emptyCalibrationDimensions = [
+        ['coverage', corpus.coverageCases],
+        ['source_quality', corpus.sourceQualityCases],
+        ['deduplication', corpus.deduplicationCases],
+        ['branch_coverage', corpus.branchCoverageCases],
+        ['language_consistency', corpus.languageConsistencyCases],
+        ['readability', corpus.readabilityCases],
+    ]
+        .filter(([, cases]) => cases.length === 0)
+        .map(([dimension]) => `corpus_empty:${dimension}`);
+    const failedCaseIds = Array.from(new Set([
+        ...(versionCompatible ? [] : ['corpus_policy_version_mismatch']),
+        ...emptyCalibrationDimensions,
+        ...coverage.falsePositiveCaseIds,
+        ...coverage.falseNegativeCaseIds,
+        ...sourceQuality.failedCaseIds,
+        ...deduplication.failedCaseIds,
+        ...branchCoverage.failedCaseIds,
+        ...languageConsistency.failedCaseIds,
+        ...readability.failedCaseIds,
+    ]));
+    return {
+        version: corpus.version,
+        versionCompatible,
+        coverage,
+        sourceQuality,
+        deduplication,
+        branchCoverage,
+        languageConsistency,
+        readability,
+        failedCaseIds,
+        jointPass: versionCompatible && emptyCalibrationDimensions.length === 0 && failedCaseIds.length === 0,
+    };
+}

package/dist/src/learning/graphAnswerQualityCalibration.test.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphAnswerQualityCalibration_1 = require("./graphAnswerQualityCalibration");
+const graphAnswerQualityPolicy_1 = require("./graphAnswerQualityPolicy");
+describe('graph answer quality calibration', () => {
+    test('uses an explicit versioned policy and preserves contradictory claims', () => {
+        expect(graphAnswerQualityCalibration_1.GRAPH_ANSWER_QUALITY_POLICY_VERSION).toBe('2026-07-23.v2');
+        expect(graphAnswerQualityPolicy_1.SUPPLEMENTAL_DEDUP_SIMILARITY_THRESHOLD).toBe(0.86);
+        expect((0, graphAnswerQualityPolicy_1.isPolaritySafeSemanticDuplicate)('Glass is transparent and conducts heat.', 'The glass is transparent and conducts heat.')).toBe(true);
+        expect((0, graphAnswerQualityPolicy_1.isPolaritySafeSemanticDuplicate)('Glass is transparent and conducts heat.', 'Glass is not transparent and does not conduct heat.')).toBe(false);
+    });
+    test('keeps signed and unit-qualified numeric facts distinct', () => {
+        expect((0, graphAnswerQualityPolicy_1.isPolaritySafeSemanticDuplicate)('The temperature is -5 C.', 'The temperature is 5 C.')).toBe(false);
+        expect((0, graphAnswerQualityPolicy_1.isPolaritySafeSemanticDuplicate)('The wall is 5 cm thick.', 'The wall is 5 mm thick.')).toBe(false);
+        expect((0, graphAnswerQualityPolicy_1.isPolaritySafeSemanticDuplicate)('The wall is 5 cm thick.', 'The wall is 5 cm thick.')).toBe(true);
+        expect((0, graphAnswerQualityPolicy_1.isPolaritySafeSemanticDuplicate)('玻璃壁厚为5厘米。', '玻璃壁厚为5毫米。')).toBe(false);
+    });
+    test('reports all quality dimensions and exact failures for the default corpus', () => {
+        const report = (0, graphAnswerQualityCalibration_1.evaluateGraphAnswerQualityCalibration)(graphAnswerQualityCalibration_1.DEFAULT_GRAPH_ANSWER_QUALITY_CORPUS);
+        expect(report.version).toBe(graphAnswerQualityCalibration_1.GRAPH_ANSWER_QUALITY_POLICY_VERSION);
+        expect(report.coverage.sampleCount).toBeGreaterThanOrEqual(24);
+        expect(report.sourceQuality.sampleCount).toBeGreaterThanOrEqual(4);
+        expect(report.deduplication.sampleCount).toBeGreaterThanOrEqual(4);
+        expect(report.branchCoverage.sampleCount).toBeGreaterThanOrEqual(4);
+        expect(report.languageConsistency.sampleCount).toBeGreaterThanOrEqual(7);
+        expect(report.readability.sampleCount).toBeGreaterThanOrEqual(8);
+        expect(report.failedCaseIds).toEqual([]);
+        expect(report.jointPass).toBe(true);
+        expect(report.sourceQuality.pairwiseAccuracy).toBeGreaterThanOrEqual(0.95);
+        expect(report.sourceQuality.minimumObservedMargin).toBeGreaterThan(0);
+        expect(report.deduplication.accuracy).toBeGreaterThanOrEqual(0.95);
+        expect(report.deduplication.similarityThreshold).toBe(graphAnswerQualityPolicy_1.SUPPLEMENTAL_DEDUP_SIMILARITY_THRESHOLD);
+        expect(report.branchCoverage.recall).toBeGreaterThanOrEqual(0.95);
+        expect(report.languageConsistency.accuracy).toBeGreaterThanOrEqual(0.95);
+        expect(report.readability.accuracy).toBeGreaterThanOrEqual(0.95);
+        expect(report.readability.minimumAcceptedScore).toBe(graphAnswerQualityPolicy_1.MINIMUM_READABILITY_SCORE);
+        expect(report.readability.minimumObservedScore).toBeGreaterThanOrEqual(graphAnswerQualityPolicy_1.MINIMUM_READABILITY_SCORE);
+    });
+    test('does not hide dimension-specific failures behind a single aggregate score', () => {
+        const report = (0, graphAnswerQualityCalibration_1.evaluateGraphAnswerQualityCalibration)({
+            ...graphAnswerQualityCalibration_1.DEFAULT_GRAPH_ANSWER_QUALITY_CORPUS,
+            sourceQualityCases: [
+                {
+                    caseId: 'source_quality_failure',
+                    preferredClause: 'This document contains a table.',
+                    rejectedClause: 'Glass conducts heat through the wall.',
+                },
+            ],
+        });
+        expect(report.jointPass).toBe(false);
+        expect(report.sourceQuality.failedCaseIds).toEqual(['source_quality_failure']);
+        expect(report.failedCaseIds).toContain('source_quality_failure');
+    });
+    test('fails closed when the corpus version drifts from the production policy', () => {
+        const report = (0, graphAnswerQualityCalibration_1.evaluateGraphAnswerQualityCalibration)({
+            ...graphAnswerQualityCalibration_1.DEFAULT_GRAPH_ANSWER_QUALITY_CORPUS,
+            version: '2026-07-23.stale',
+        });
+        expect(report.versionCompatible).toBe(false);
+        expect(report.jointPass).toBe(false);
+        expect(report.failedCaseIds).toContain('corpus_policy_version_mismatch');
+    });
+    test('fails closed when a calibration dimension has no cases', () => {
+        const report = (0, graphAnswerQualityCalibration_1.evaluateGraphAnswerQualityCalibration)({
+            ...graphAnswerQualityCalibration_1.DEFAULT_GRAPH_ANSWER_QUALITY_CORPUS,
+            readabilityCases: [],
+        });
+        expect(report.readability.accuracy).toBe(0);
+        expect(report.failedCaseIds).toContain('corpus_empty:readability');
+        expect(report.jointPass).toBe(false);
+    });
+});

package/dist/src/learning/graphAnswerQualityPolicy.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MINIMUM_READABILITY_SCORE = exports.SUPPLEMENTAL_DEDUP_SIMILARITY_THRESHOLD = exports.GRAPH_ANSWER_QUALITY_POLICY_VERSION = void 0;
+exports.graphClaimsCanShareCoverage = graphClaimsCanShareCoverage;
+exports.isPolaritySafeSemanticDuplicate = isPolaritySafeSemanticDuplicate;
+const graphClaimMatcher_1 = require("./graphClaimMatcher");
+exports.GRAPH_ANSWER_QUALITY_POLICY_VERSION = '2026-07-23.v2';
+exports.SUPPLEMENTAL_DEDUP_SIMILARITY_THRESHOLD = 0.86;
+exports.MINIMUM_READABILITY_SCORE = 0.5;
+// Keep signs and common measurement suffixes in the fact key so distinct values
+// cannot be collapsed by lexical similarity alone.
+const NUMERIC_FACT_PATTERN = /([+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?)(?:\s*(%|°[cfk]|days?|weeks?|months?|years?|milliseconds?|ms|min|hours?|hr|h|seconds?|s|km|cm|mm|nm|um|m|in|ft|yd|mi|kg|mg|lb|oz|kpa|mpa|pa|bar|kj|kw|hz|kb|mb|gb|tb|usd|eur|cny|rmb|c|f|k|g|j|w|v|a|\u6beb\u79d2|\u5206\u949f|\u5c0f\u65f6|\u5929|\u5468|\u6708|\u5e74|\u6beb\u7c73|\u5398\u7c73|\u5343\u7c73|\u7c73|\u6beb\u514b|\u5343\u514b|\u514b|\u5146\u5e15|\u5343\u5e15|\u5e15|\u6444\u6c0f\u5ea6|\u534e\u6c0f\u5ea6|\u5143|\u7f8e\u5143|\u6b27\u5143))?(?![\p{L}\p{N}_])/giu;
+function numericFacts(value) {
+    return Array.from(new Set(Array.from(String(value || '').matchAll(NUMERIC_FACT_PATTERN), (match) => (`${match[1].toLowerCase()}|${(match[2] || '').toLowerCase()}`)))).sort();
+}
+function graphClaimsCanShareCoverage(left, right) {
+    if ((0, graphClaimMatcher_1.isGraphClaimNegated)(left) !== (0, graphClaimMatcher_1.isGraphClaimNegated)(right)) {
+        return false;
+    }
+    const leftNumbers = numericFacts(left);
+    const rightNumbers = numericFacts(right);
+    if (leftNumbers.length > 0 && rightNumbers.length > 0 && leftNumbers.join('|') !== rightNumbers.join('|')) {
+        return false;
+    }
+    return true;
+}
+function isPolaritySafeSemanticDuplicate(left, right) {
+    return graphClaimsCanShareCoverage(left, right)
+        && (0, graphClaimMatcher_1.graphClaimSemanticSimilarity)(left, right) >= exports.SUPPLEMENTAL_DEDUP_SIMILARITY_THRESHOLD;
+}

package/dist/src/learning/graphClaimMatcher.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGraphClaimNegated = isGraphClaimNegated;
+exports.semanticFeatures = semanticFeatures;
+exports.graphClaimSemanticSimilarity = graphClaimSemanticSimilarity;
+exports.matchGraphAnswerClaim = matchGraphAnswerClaim;
+const STOPWORDS = new Set([
+    'a', 'an', 'and', 'are', 'as', 'at', 'be', 'between', 'by', 'for', 'from', 'in', 'is', 'it',
+    'of', 'on', 'or', 'that', 'the', 'their', 'this', 'through', 'to', 'with', 'its', 'will',
+]);
+const CONCEPT_PATTERNS = [
+    ['transparent', /\btransparent\b|透明/u],
+    ['container', /\b(?:container|vessel|cup|water\s+glass)\b|容器|水杯|杯子/u],
+    ['glass_material', /\bglass\b|玻璃/u],
+    ['plastic', /\bplastic\b|塑料/u],
+    ['comparison', /\b(?:compare|compared|than|versus)\b|相比|比/u],
+    ['water', /\b(?:water|liquid)\b|水|液体/u],
+    ['drink', /\b(?:drink|drinking)\b|饮用|喝水/u],
+    ['wall', /\b(?:glass\s+)?wall\b|杯壁|玻璃壁|实体壁/u],
+    ['boundary', /\b(?:boundary|separate|separates|separated|divide|divides)\b|边界|隔开|分隔/u],
+    ['environment', /\b(?:environment|surroundings?|outside|external)\b|环境|外部|周围/u],
+    ['heat', /\b(?:heat|heating|thermal(?:\s+energy)?)\b|加热|受热|热量|热能|导热|热交换|换热/u],
+    ['transfer', /\b(?:move|moves|pass|passes|conduct|conducts|transfer|exchange)\b|穿过|传递|经由|交换|换热/u],
+    ['thickness', /\bthickness\b|厚度|壁厚/u],
+    ['affect', /\b(?:affect|affects|change|changes|influence|influences)\b|影响|改变/u],
+    ['cause', /\b(?:because|cause|causes|lead|leads|result|results)\b|导致|造成|引起/u],
+    ['rise', /\b(?:rise|rises|rising|raise|raises|increase|increases)\b|上升|升高|提高/u],
+    ['apply', /\b(?:apply|applies|effective|valid)\b|生效|适用|有效/u],
+    ['before', /\b(?:before|prior|prerequisite)\b|之前|前置|先/u],
+    ['after', /\b(?:after|then|subsequent)\b|之后|以后|随后|再/u],
+];
+const NEGATION_PATTERN = /\b(?:not|no|never|neither|without|cannot|can't|doesn't|does\s+not|isn't|is\s+not|has\s+no)\b|不(?:会|能|是|再|把|影响|改变|导致|造成|传递|穿过|隔开|分隔)?|并非|没有|无法|不能|不会|无关/u;
+function isGraphClaimNegated(value) {
+    return NEGATION_PATTERN.test(String(value || ''));
+}
+function normalize(value) {
+    return String(value || '').toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').replace(/\s+/g, ' ').trim();
+}
+function lexicalTerms(value) {
+    return normalize(value)
+        .split(' ')
+        .filter((term) => term.length >= 3 && !STOPWORDS.has(term));
+}
+function semanticFeatures(value) {
+    const normalized = normalize(value);
+    const concepts = CONCEPT_PATTERNS
+        .filter(([, pattern]) => pattern.test(normalized))
+        .map(([concept]) => `concept:${concept}`);
+    const lexical = lexicalTerms(normalized)
+        .filter((term) => !CONCEPT_PATTERNS.some(([, pattern]) => pattern.test(term)))
+        .map((term) => `term:${term}`);
+    return Array.from(new Set([...concepts, ...lexical]));
+}
+function graphClaimSemanticSimilarity(left, right) {
+    const leftFeatures = new Set(semanticFeatures(left));
+    const rightFeatures = new Set(semanticFeatures(right));
+    if (leftFeatures.size === 0 || rightFeatures.size === 0)
+        return 0;
+    const intersection = Array.from(leftFeatures).filter((feature) => rightFeatures.has(feature)).length;
+    return Number((intersection / Math.max(leftFeatures.size, rightFeatures.size)).toFixed(4));
+}
+function clauses(value) {
+    const normalizedValue = String(value || '').trim();
+    const splitClauses = normalizedValue
+        .split(/(?<=[.!?。！？；;])|[,，]\s*/u)
+        .map((clause) => clause.trim())
+        .filter(Boolean);
+    return splitClauses.length > 1 ? [...splitClauses, normalizedValue] : splitClauses;
+}
+function matchClause(statementFeatures, statementNegated, clause) {
+    const clauseFeatures = new Set(semanticFeatures(clause));
+    const matchedConcepts = statementFeatures.filter((feature) => clauseFeatures.has(feature));
+    const missingConcepts = statementFeatures.filter((feature) => !clauseFeatures.has(feature));
+    const score = statementFeatures.length > 0 ? matchedConcepts.length / statementFeatures.length : 0;
+    const minimumMatches = Math.min(statementFeatures.length, Math.max(2, Math.ceil(statementFeatures.length * 0.55)));
+    const polarityConflict = matchedConcepts.length >= minimumMatches && statementNegated !== isGraphClaimNegated(clause);
+    return {
+        covered: !polarityConflict && matchedConcepts.length >= minimumMatches && score >= 0.55,
+        score: Number(score.toFixed(4)),
+        matchedConcepts,
+        missingConcepts,
+        polarityConflict,
+    };
+}
+function matchGraphAnswerClaim(answer, statement) {
+    const normalizedStatement = normalize(statement);
+    if (!normalizedStatement) {
+        return { covered: false, score: 0, matchedConcepts: [], missingConcepts: [], polarityConflict: false };
+    }
+    const normalizedAnswer = normalize(answer);
+    const statementNegated = NEGATION_PATTERN.test(statement);
+    if (normalizedAnswer.includes(normalizedStatement) && statementNegated === isGraphClaimNegated(answer)) {
+        const features = semanticFeatures(statement);
+        return { covered: true, score: 1, matchedConcepts: features, missingConcepts: [], polarityConflict: false };
+    }
+    const features = semanticFeatures(statement);
+    if (features.length === 0) {
+        return { covered: false, score: 0, matchedConcepts: [], missingConcepts: [], polarityConflict: false };
+    }
+    return clauses(answer)
+        .map((clause) => matchClause(features, statementNegated, clause))
+        .sort((left, right) => Number(right.covered) - Number(left.covered) || right.score - left.score)[0]
+        || { covered: false, score: 0, matchedConcepts: [], missingConcepts: features, polarityConflict: false };
+}

package/dist/src/learning/graphConditionedContext.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conditionRagFragmentsByGraphPlan = conditionRagFragmentsByGraphPlan;
+function claimAtomIds(claim, anchorAtomId) {
+    return new Set([
+        anchorAtomId,
+        claim.subjectAtomId,
+        ...claim.supportingAtomIds,
+        ...claim.evidenceRefs.map((evidence) => evidence.atomId || ''),
+    ].filter(Boolean));
+}
+function matchFragmentToClaim(fragment, claim, anchorAtomId) {
+    const atomIds = claimAtomIds(claim, anchorAtomId);
+    if (fragment.atomId && atomIds.has(fragment.atomId)) {
+        return true;
+    }
+    const edgeIds = new Set(claim.supportingEdgeIds);
+    return (fragment.relationEdgeIds || []).some((edgeId) => edgeIds.has(edgeId));
+}
+function conditionRagFragmentsByGraphPlan(params) {
+    const fragments = Array.isArray(params.fragments) ? params.fragments : [];
+    const plan = params.graphAnswerPlan;
+    if (!plan) {
+        return {
+            fragmentOrder: fragments.map((fragment) => fragment.fragmentId),
+            trace: {
+                strategy: 'none',
+                matchedClaimCount: 0,
+                matchedFragmentCount: 0,
+                selectedAtomIds: [],
+                selectedEdgeIds: [],
+                fallbackReason: 'no_graph_answer_plan',
+            },
+        };
+    }
+    if (plan.claims.length <= 0) {
+        return {
+            fragmentOrder: fragments.map((fragment) => fragment.fragmentId),
+            trace: {
+                strategy: 'none',
+                matchedClaimCount: 0,
+                matchedFragmentCount: 0,
+                selectedAtomIds: [],
+                selectedEdgeIds: [],
+                fallbackReason: 'empty_graph_answer_plan',
+            },
+        };
+    }
+    const matches = new Map();
+    const matchedClaims = new Set();
+    const selectedAtomIds = new Set();
+    const selectedEdgeIds = new Set();
+    fragments.forEach((fragment) => {
+        const match = {
+            claimIds: new Set(),
+            priority: 0,
+            required: false,
+        };
+        plan.claims.forEach((claim) => {
+            if (!matchFragmentToClaim(fragment, claim, plan.anchorAtomId)) {
+                return;
+            }
+            match.claimIds.add(claim.claimId);
+            match.priority = Math.max(match.priority, claim.priority);
+            match.required = match.required || claim.required;
+            matchedClaims.add(claim.claimId);
+        });
+        if (match.claimIds.size <= 0) {
+            return;
+        }
+        matches.set(fragment.fragmentId, match);
+        if (fragment.atomId) {
+            selectedAtomIds.add(fragment.atomId);
+        }
+        (fragment.relationEdgeIds || []).forEach((edgeId) => {
+            if (plan.claims.some((claim) => claim.supportingEdgeIds.includes(edgeId))) {
+                selectedEdgeIds.add(edgeId);
+            }
+        });
+    });
+    const originalOrder = new Map(fragments.map((fragment, index) => [fragment.fragmentId, index]));
+    const fragmentOrder = fragments
+        .slice()
+        .sort((left, right) => {
+        const leftMatch = matches.get(left.fragmentId);
+        const rightMatch = matches.get(right.fragmentId);
+        const leftRank = leftMatch ? (leftMatch.required ? 0 : 1) : 2;
+        const rightRank = rightMatch ? (rightMatch.required ? 0 : 1) : 2;
+        if (leftRank !== rightRank) {
+            return leftRank - rightRank;
+        }
+        const priorityDelta = (rightMatch?.priority || 0) - (leftMatch?.priority || 0);
+        if (priorityDelta !== 0) {
+            return priorityDelta;
+        }
+        return (originalOrder.get(left.fragmentId) || 0) - (originalOrder.get(right.fragmentId) || 0);
+    })
+        .map((fragment) => fragment.fragmentId);
+    return {
+        fragmentOrder,
+        trace: {
+            strategy: 'graph_answer_plan',
+            matchedClaimCount: matchedClaims.size,
+            matchedFragmentCount: matches.size,
+            selectedAtomIds: Array.from(selectedAtomIds).sort(),
+            selectedEdgeIds: Array.from(selectedEdgeIds).sort(),
+        },
+    };
+}