noteconnection 1.8.0 → 1.9.0

package/dist/src/learning/evidenceContextAssembler.js

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assembleRagEvidenceContext = assembleRagEvidenceContext;
 const ragContextPack_1 = require("./ragContextPack");
+const graphConditionedContext_1 = require("./graphConditionedContext");
+const ragEvidenceQuality_1 = require("./ragEvidenceQuality");
 const DEFAULT_PARAGRAPH_WINDOW = 5;
 const MAX_GRAPH_NEIGHBOR_DOCUMENT_CONTEXT_FRAGMENTS = 2;
-const COMPARABLE_NUMERIC_FACT_PATTERN = /\b(?:the\s+)?([a-z][a-z0-9 -]{2,80}?)\s+(?:is|=|:)\s*(?:±|\+\/-|\+\s*\/\s*-)?\s*(-?\d+(?:\.\d+)?)\s*(mm|cm|m|um|µm|nm|kg|g|mg|s|ms|%|deg|degree|degrees|c|k)\b/gi;
 const COMPARABLE_QUANTITY_FACT_PATTERN = /\b(?:the\s+)?([a-z][a-z0-9 -]{2,80}?(?:count|limit|threshold|budget|quota|capacity|size|window|attempts|retries))\s+(?:is|are|=|:)\s*(-?\d+(?:\.\d+)?)\b/gi;
 const COMPARABLE_DATE_FACT_PATTERN = /\b(?:the\s+)?([a-z][a-z0-9 -]{2,80}?(?:date|year|deadline|cutoff|cut-off|version|release|revision|effective))\s+(?:is|=|:)\s*(\d{4}(?:-\d{2}-\d{2})?)\b/gi;
 const COMPARABLE_STATE_FACT_PATTERN = /\b(?:the\s+)?([a-z][a-z0-9 -]{2,80}?(?:status|state|mode|flag|policy|availability|setting|gate|switch))\s+(?:is|=|:)\s*(enabled|disabled|active|inactive|available|unavailable|supported|unsupported|allowed|blocked|required|optional|open|closed|on|off)\b/gi;
@@ -84,50 +85,110 @@ const COMPARABLE_PLATFORM_SCOPE_ALIASES = {
     mobile: 'mobile',
 };
 const COMPARABLE_PLATFORM_SCOPE_PATTERN = /\b(?:in|for|on|under|within)\s+(?:the\s+)?(windows|win32|macos|mac|linux|android|ios|web|desktop|mobile)(?:\s+(?:platform|os|runtime|client|app|build|target))?\b|\b(windows|win32|macos|mac|linux|android|ios|web|desktop|mobile)\s+(?:platform|os|runtime|client|app|build|target)\b/i;
+const COMPARABLE_TIME_SCOPE_PATTERN = /\b(?:in|during|on|as of)\s+(\d{4}(?:-\d{2}(?:-\d{2})?)?)\b/i;
+const MEASUREMENT_UNIT_GROUPS = [
+    { aliases: ['B', 'byte', 'bytes', '字节'], dimension: 'information', scale: 1 },
+    { aliases: ['b', 'bit', 'bits', '比特'], dimension: 'information', scale: 1 / 8 },
+    { aliases: ['kB', 'kilobyte', 'kilobytes'], dimension: 'information', scale: 1000 },
+    { aliases: ['MB', 'megabyte', 'megabytes', '兆字节'], dimension: 'information', scale: 1e6 },
+    { aliases: ['Mb', 'megabit', 'megabits'], dimension: 'information', scale: 1e6 / 8 },
+    { aliases: ['GB', 'gigabyte', 'gigabytes'], dimension: 'information', scale: 1e9 },
+    { aliases: ['KiB', 'kibibyte', 'kibibytes'], dimension: 'information', scale: 1024 },
+    { aliases: ['MiB', 'mebibyte', 'mebibytes'], dimension: 'information', scale: 1024 ** 2 },
+    { aliases: ['GiB', 'gibibyte', 'gibibytes'], dimension: 'information', scale: 1024 ** 3 },
+    { aliases: ['m', 'meter', 'meters', 'metre', 'metres', '米'], dimension: 'length', scale: 1 },
+    { aliases: ['cm', '厘米'], dimension: 'length', scale: 1e-2 },
+    { aliases: ['mm', '毫米'], dimension: 'length', scale: 1e-3 },
+    { aliases: ['um', 'µm', 'μm', '微米'], dimension: 'length', scale: 1e-6 },
+    { aliases: ['nm', '纳米'], dimension: 'length', scale: 1e-9 },
+    { aliases: ['kg', '千克', '公斤'], dimension: 'mass', scale: 1 },
+    { aliases: ['g', 'gram', 'grams', '克'], dimension: 'mass', scale: 1e-3 },
+    { aliases: ['mg', '毫克'], dimension: 'mass', scale: 1e-6 },
+    { aliases: ['s', 'second', 'seconds', '秒'], dimension: 'duration', scale: 1 },
+    { aliases: ['ms', 'millisecond', 'milliseconds', '毫秒'], dimension: 'duration', scale: 1e-3 },
+    { aliases: ['us', 'µs', 'μs', '微秒'], dimension: 'duration', scale: 1e-6 },
+    { aliases: ['min', 'minute', 'minutes', '分钟'], dimension: 'duration', scale: 60 },
+    { aliases: ['h', 'hour', 'hours', '小时'], dimension: 'duration', scale: 3600 },
+    { aliases: ['d', 'day', 'days', '天', '日'], dimension: 'duration', scale: 86400 },
+    { aliases: ['Hz', 'hz', 'hertz', '赫兹'], dimension: 'frequency', scale: 1 },
+    { aliases: ['kHz', 'khz', '千赫兹'], dimension: 'frequency', scale: 1000 },
+    { aliases: ['K', 'kelvin', '开尔文'], dimension: 'temperature', scale: 1 },
+    { aliases: ['C', 'c', '°C', '°c', '℃', '摄氏度'], dimension: 'temperature', scale: 1, offset: 273.15 },
+    { aliases: ['deg', 'degree', 'degrees', '度'], dimension: 'angle', scale: Math.PI / 180 },
+    { aliases: ['rad', 'radian', 'radians', '弧度'], dimension: 'angle', scale: 1 },
+    { aliases: ['%'], dimension: 'ratio', scale: 0.01 },
+];
+const MEASUREMENT_UNITS = new Map(MEASUREMENT_UNIT_GROUPS.flatMap(group => group.aliases.map(alias => [alias, group])));
+const MEASUREMENT_UNIT_PATTERN = Array.from(MEASUREMENT_UNITS.keys()).sort((left, right) => right.length - left.length).join('|');
+const MEASUREMENT_NUMBER_PATTERN = /[+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?/i;
+const MEASUREMENT_PREFIX_PATTERNS = [
+    /(?<![\p{L}\p{N}])([\p{L}][\p{L}\p{N} _-]{1,100}?)(?:\s+(?:is|are)\s+|\s*[:=]\s*)(not\s+)?/u,
+    /(?<![\p{L}\p{N}])([\p{L}][\p{L}\p{N} _-]{1,100}?)\s*(?:(并不是|不是|不为|不等于|并非)|是|为|等于|：)\s*/u,
+];
+const MEASUREMENT_FACT_PATTERNS = MEASUREMENT_PREFIX_PATTERNS.map(prefix => new RegExp(prefix.source + /(?:(?:\+\s*\/\s*-|±)\s*)?/.source + '(' + MEASUREMENT_NUMBER_PATTERN.source + ')' + /\s*/.source
+    + '(' + MEASUREMENT_UNIT_PATTERN + ')' + /(?![a-z0-9_])/.source, 'giu'));
+const MEASUREMENT_UNIT_SUFFIX_PATTERN = new RegExp('^\\s*(?:' + MEASUREMENT_UNIT_PATTERN + ')(?![a-z0-9_])', 'iu');
+const CHINESE_SCOPE_TERMS = {
+    当前: ' current ', 目前: ' current ', 现行: ' current ', 历史: ' historical ', 旧版: ' historical ',
+    计划: ' planned ', 未来: ' planned ', 生产环境: ' production environment ', 测试环境: ' test environment ',
+    开发环境: ' development environment ', 预发环境: ' staging environment ', 预生产环境: ' staging environment ',
+    版本: ' version ', 安卓平台: ' android platform ', 桌面平台: ' desktop platform ', 移动平台: ' mobile platform ',
+};
+const CHINESE_SCOPE_PATTERN = new RegExp(Object.keys(CHINESE_SCOPE_TERMS).sort((a, b) => b.length - a.length).join('|'), 'gu');
+function normalizeScopeLanguage(value) {
+    return value.replace(CHINESE_SCOPE_PATTERN, term => CHINESE_SCOPE_TERMS[term])
+        .replace(/(\d{4})年(?:(\d{1,2})月)?(?:(\d{1,2})日)?/gu, (_match, year, month, day) => (` in ${year}${month ? `-${month.padStart(2, '0')}` : ''}${day ? `-${day.padStart(2, '0')}` : ''} `));
+}
 function normalizeWhitespace(value) {
     return String(value || '').replace(/\s+/g, ' ').trim();
 }
+function finishEvidenceFragment(fragment, execution) {
+    if (!execution)
+        return fragment;
+    execution.recordFragment();
+    if (fragment.text.length <= execution.maxFragmentChars)
+        return fragment;
+    const text = fragment.text.slice(0, execution.maxFragmentChars);
+    return {
+        ...fragment, text, charCount: text.length, tokenEstimate: (0, ragContextPack_1.estimateRagTokenCount)(text),
+        truncated: true, truncationReason: 'runtime_fragment_chars_limit',
+    };
+}
 function sanitizeFragmentPart(value) {
     return normalizeWhitespace(value)
         .replace(/[^a-zA-Z0-9_-]+/g, '_')
         .replace(/^_+|_+$/g, '')
         .slice(0, 80) || 'fragment';
 }
-function splitSourceLines(content) {
+function splitSourceLines(content, execution) {
     const normalizedContent = String(content || '');
     if (!normalizedContent) {
         return [];
     }
-    const lines = normalizedContent.split(/\r\n|\n|\r/);
     const records = [];
+    const newline = /\r\n|\n|\r/g;
     let cursor = 0;
-    lines.forEach((line, index) => {
-        const startOffset = cursor;
-        const endOffset = startOffset + line.length;
+    let delimiter;
+    while ((delimiter = newline.exec(normalizedContent)) !== null) {
+        execution?.checkSourceLineCount(records.length + 1);
         records.push({
-            lineNumber: index + 1,
-            text: line,
-            startOffset,
-            endOffset,
+            lineNumber: records.length + 1,
+            text: normalizedContent.slice(cursor, delimiter.index),
+            startOffset: cursor,
+            endOffset: delimiter.index,
         });
-        if (normalizedContent.startsWith('\r\n', endOffset)) {
-            cursor = endOffset + 2;
-        }
-        else if (normalizedContent[endOffset] === '\n' || normalizedContent[endOffset] === '\r') {
-            cursor = endOffset + 1;
-        }
-        else {
-            cursor = endOffset;
-        }
-    });
+        cursor = delimiter.index + delimiter[0].length;
+    }
+    execution?.checkSourceLineCount(records.length + 1);
+    records.push({ lineNumber: records.length + 1, text: normalizedContent.slice(cursor), startOffset: cursor, endOffset: normalizedContent.length });
     return records;
 }
 function isTableLine(text) {
     const trimmed = String(text || '').trim();
     return trimmed.startsWith('|') && trimmed.endsWith('|');
 }
-function parseMarkdownBlocks(content) {
-    const sourceLines = splitSourceLines(content);
+function parseMarkdownBlocks(content, execution) {
+    const sourceLines = splitSourceLines(content, execution);
     const blocks = [];
     const headingStack = [];
     let pendingLines = [];
@@ -158,6 +219,7 @@ function parseMarkdownBlocks(content) {
         pendingHeadingPath = currentHeadingPath();
     };
     sourceLines.forEach((line) => {
+        execution?.assertActive();
         const rawText = String(line.text || '');
         const trimmed = rawText.trim();
         const fenceLine = /^```/.test(trimmed);
@@ -306,7 +368,7 @@ function normalizeComparableFactSubject(value) {
     return normalizeWhitespace(value)
         .toLowerCase()
         .replace(/^(the|a|an)\s+/i, '')
-        .replace(/[^a-z0-9]+/g, ' ')
+        .replace(/[^\p{L}\p{N}]+/gu, ' ')
         .trim();
 }
 function comparableFactSentenceTail(blockText, match) {
@@ -315,7 +377,8 @@ function comparableFactSentenceTail(blockText, match) {
         return '';
     }
     const tail = String(blockText || '').slice(matchIndex + String(match[0] || '').length);
-    return normalizeWhitespace(tail.split(/[.!?]/)[0] || '');
+    const boundary = /[!?。！？；;\r\n]|\.(?!\d)/u.exec(tail);
+    return normalizeWhitespace(boundary ? tail.slice(0, boundary.index) : tail);
 }
 function comparableFactTemporalScopeKey(subjectLabel, sentenceTail) {
     const scopedText = `${normalizeWhitespace(subjectLabel)} ${normalizeWhitespace(sentenceTail)}`;
@@ -356,6 +419,8 @@ function comparableFactPlatformScopeKey(subjectLabel, sentenceTail) {
     return COMPARABLE_PLATFORM_SCOPE_ALIASES[platformLabel] || null;
 }
 function comparableFactScopeKeys(subjectLabel, sentenceTail) {
+    subjectLabel = normalizeScopeLanguage(subjectLabel);
+    sentenceTail = normalizeScopeLanguage(sentenceTail);
     const scopeKeys = [];
     const temporalScopeKey = comparableFactTemporalScopeKey(subjectLabel, sentenceTail);
     if (temporalScopeKey) {
@@ -373,26 +438,89 @@ function comparableFactScopeKeys(subjectLabel, sentenceTail) {
     if (platformScopeKey) {
         scopeKeys.push(`platform:${platformScopeKey}`);
     }
+    const timeScope = COMPARABLE_TIME_SCOPE_PATTERN.exec(`${subjectLabel} ${sentenceTail}`)?.[1];
+    if (timeScope)
+        scopeKeys.push(`time:${timeScope}`);
     return scopeKeys.sort();
 }
 function comparableFactSubjectKey(subjectLabel, scopeKeys) {
+    subjectLabel = normalizeScopeLanguage(subjectLabel);
     const scopedSubjectLabel = scopeKeys.some((scopeKey) => scopeKey.startsWith('temporal:'))
         ? normalizeWhitespace(subjectLabel).replace(COMPARABLE_TEMPORAL_SCOPE_PATTERN, '')
         : subjectLabel;
-    const subjectKey = normalizeComparableFactSubject(scopedSubjectLabel);
+    const subjectKey = normalizeComparableFactSubject(scopedSubjectLabel
+        .replace(COMPARABLE_ENVIRONMENT_SCOPE_PATTERN, '')
+        .replace(COMPARABLE_PLATFORM_SCOPE_PATTERN, '')
+        .replace(COMPARABLE_VERSION_SCOPE_PATTERN, '')
+        .replace(COMPARABLE_TIME_SCOPE_PATTERN, ''));
     return scopeKeys.length > 0 && subjectKey
         ? `${subjectKey}@scope:${scopeKeys.join('+')}`
         : subjectKey;
 }
-function normalizeComparableFactUnit(value) {
-    const normalized = normalizeWhitespace(value).toLowerCase();
-    if (normalized === 'um') {
-        return 'µm';
+function measurementScopeKeys(text) {
+    const normalized = normalizeScopeLanguage(text);
+    const keys = new Set();
+    for (const pattern of [COMPARABLE_TEMPORAL_SCOPE_PATTERN, COMPARABLE_ENVIRONMENT_SCOPE_PATTERN,
+        COMPARABLE_VERSION_SCOPE_PATTERN, COMPARABLE_PLATFORM_SCOPE_PATTERN, COMPARABLE_TIME_SCOPE_PATTERN]) {
+        for (const match of normalized.matchAll(new RegExp(pattern.source, 'gi'))) {
+            comparableFactScopeKeys('', match[0]).forEach(key => keys.add(key));
+        }
     }
-    if (normalized === 'degree' || normalized === 'degrees') {
-        return 'deg';
+    // A coordinated qualifier ("in production or staging") is not a single scope.
+    if (Array.from(keys).some(key => key.startsWith('environment:'))) {
+        for (const word of normalized.toLowerCase().match(/\b[a-z]+\b/g) || []) {
+            const environment = COMPARABLE_ENVIRONMENT_SCOPE_ALIASES[word];
+            if (environment)
+                keys.add(`environment:${environment}`);
+        }
+    }
+    if (Array.from(keys).some(key => key.startsWith('platform:'))) {
+        for (const word of normalized.toLowerCase().match(/\b[a-z0-9]+\b/g) || []) {
+            const platform = COMPARABLE_PLATFORM_SCOPE_ALIASES[word];
+            if (platform)
+                keys.add(`platform:${platform}`);
+        }
     }
-    return normalized;
+    const dimensions = new Set();
+    for (const key of keys) {
+        const dimension = key.slice(0, key.indexOf(':'));
+        if (dimensions.has(dimension))
+            return null;
+        dimensions.add(dimension);
+    }
+    return Array.from(keys).sort();
+}
+function measurementHeadingScopeKeys(headingPath) {
+    const byDimension = new Map();
+    for (const heading of headingPath) {
+        const keys = measurementScopeKeys(`in ${heading}`);
+        if (!keys)
+            return null;
+        for (const key of keys)
+            byDimension.set(key.slice(0, key.indexOf(':')), key);
+    }
+    return Array.from(byDimension.values()).sort();
+}
+function measurementAssertionScopeKeys(headingKeys, paragraphKeys, clauseKeys) {
+    const byDimension = new Map();
+    for (const key of [...headingKeys, ...paragraphKeys, ...clauseKeys]) {
+        byDimension.set(key.slice(0, key.indexOf(':')), key);
+    }
+    return Array.from(byDimension.values()).sort();
+}
+function standaloneMeasurementScopeKeys(clause) {
+    const normalized = normalizeScopeLanguage(clause).replace(/[.:：。]+$/u, '').trim();
+    const keys = measurementScopeKeys(`in ${normalized}`);
+    if (!keys?.length)
+        return null;
+    const remainder = `in ${normalized}`
+        .replace(COMPARABLE_TEMPORAL_SCOPE_PATTERN, '')
+        .replace(COMPARABLE_ENVIRONMENT_SCOPE_PATTERN, '')
+        .replace(COMPARABLE_VERSION_SCOPE_PATTERN, '')
+        .replace(COMPARABLE_PLATFORM_SCOPE_PATTERN, '')
+        .replace(COMPARABLE_TIME_SCOPE_PATTERN, '')
+        .replace(/\b(?:in|for|on|under|within|during|as of|the)\b/gi, '').trim();
+    return remainder ? null : keys;
 }
 function normalizeComparableDateValue(value) {
     const normalized = normalizeWhitespace(value);
@@ -499,27 +627,61 @@ function extractComparableEvidenceFacts(params) {
         return [];
     }
     const facts = [];
-    for (const match of String(params.block.text || '').matchAll(COMPARABLE_NUMERIC_FACT_PATTERN)) {
-        const subjectLabel = normalizeWhitespace(match[1]);
-        const scopeKeys = comparableFactScopeKeys(subjectLabel, comparableFactSentenceTail(params.block.text, match));
-        const subjectKey = comparableFactSubjectKey(subjectLabel, scopeKeys);
-        const value = Number(match[2]);
-        const unit = normalizeComparableFactUnit(match[3]);
-        if (!subjectKey || !Number.isFinite(value) || !unit) {
+    const appendFact = (fact) => {
+        params.execution?.recordSourceFact();
+        facts.push(fact);
+    };
+    const headingKeys = measurementHeadingScopeKeys(params.block.headingPath);
+    let paragraphKeys = [];
+    for (const clause of (0, ragEvidenceQuality_1.iterateRagEvidenceClauses)(params.block.text)) {
+        params.execution?.assertActive();
+        const inheritedKeys = paragraphKeys;
+        // Only an immediately preceding standalone qualifier is unambiguous.
+        paragraphKeys = standaloneMeasurementScopeKeys(clause) || [];
+        const clauseKeys = measurementScopeKeys(clause);
+        if (!headingKeys || !clauseKeys)
+            continue;
+        if (/\b(?:approximately|roughly|about|at least|at most|between|range)\b|大约|约为|至少|至多|范围/iu.test(clause))
             continue;
+        const scopeKeys = measurementAssertionScopeKeys(headingKeys, inheritedKeys, clauseKeys);
+        for (const pattern of MEASUREMENT_FACT_PATTERNS) {
+            for (const match of clause.matchAll(pattern)) {
+                params.execution?.assertActive();
+                const tail = clause.slice(match.index + match[0].length);
+                if (/^\s*(?:[\/^*]|(?:[-–—~～]|to|至|到)\s*[+-]?\d)/iu.test(tail))
+                    continue;
+                const subjectLabel = normalizeWhitespace(match[1]);
+                const subjectKey = comparableFactSubjectKey(subjectLabel, scopeKeys);
+                const tolerance = /(?:\btolerance|公差|容差)$/iu.test(subjectLabel);
+                // A named tolerance defines a half-width; an uncertain observation does not define an exact value.
+                if (/±|\+\s*\/\s*-/u.test(clause)
+                    && (!tolerance || !/±|\+\s*\/\s*-/u.test(match[0])))
+                    continue;
+                // SI symbol case is significant: µM is not µm, nor Ms milliseconds.
+                const unit = MEASUREMENT_UNITS.get(match[4])
+                    || (match[4].length > 2 ? MEASUREMENT_UNITS.get(match[4].toLowerCase()) : undefined);
+                if (!subjectKey || !unit)
+                    continue;
+                const converted = Number(match[3]) * unit.scale + (tolerance ? 0 : (unit.offset || 0));
+                if (!Number.isFinite(converted) || (tolerance && converted < 0))
+                    continue;
+                // Significant digits remove conversion noise without rounding tiny measurements to zero.
+                const magnitude = Number(converted.toPrecision(15));
+                const relation = match[2] ? 'not_equal' : 'equal';
+                const dimension = tolerance ? `tolerance:${unit.dimension}` : unit.dimension;
+                appendFact({
+                    subjectKey, subjectLabel,
+                    valueKey: `${dimension}:${relation}:${magnitude}`,
+                    valueLabel: `${match[2] || ''}${match[3]} ${match[4]}`,
+                    factKind: 'measurement', measurement: { dimension, magnitude, relation },
+                    block: params.block, citationIds: params.citationIds, item: params.item,
+                });
+            }
         }
-        facts.push({
-            subjectKey,
-            subjectLabel,
-            valueKey: `${Number(value.toFixed(12))}:${unit}`,
-            valueLabel: `${match[2]} ${match[3]}`,
-            factKind: 'measurement',
-            block: params.block,
-            citationIds: params.citationIds,
-            item: params.item,
-        });
     }
     for (const match of String(params.block.text || '').matchAll(COMPARABLE_QUANTITY_FACT_PATTERN)) {
+        if (MEASUREMENT_UNIT_SUFFIX_PATTERN.test(params.block.text.slice(match.index + match[0].length)))
+            continue;
         const subjectLabel = normalizeWhitespace(match[1]);
         const scopeKeys = comparableFactScopeKeys(subjectLabel, comparableFactSentenceTail(params.block.text, match));
         const subjectKey = comparableFactSubjectKey(subjectLabel, scopeKeys);
@@ -527,7 +689,7 @@ function extractComparableEvidenceFacts(params) {
         if (!subjectKey || !Number.isFinite(value)) {
             continue;
         }
-        facts.push({
+        appendFact({
             subjectKey,
             subjectLabel,
             valueKey: `${Number(value.toFixed(12))}`,
@@ -546,7 +708,7 @@ function extractComparableEvidenceFacts(params) {
         if (!subjectKey || !valueKey) {
             continue;
         }
-        facts.push({
+        appendFact({
             subjectKey,
             subjectLabel,
             valueKey,
@@ -565,7 +727,7 @@ function extractComparableEvidenceFacts(params) {
         if (!subjectKey || !stateValue) {
             continue;
         }
-        facts.push({
+        appendFact({
             subjectKey: `${subjectKey}:${stateValue.groupKey}`,
             subjectLabel,
             valueKey: stateValue.valueKey,
@@ -584,7 +746,7 @@ function extractComparableEvidenceFacts(params) {
         if (!subjectKey || !valueKey) {
             continue;
         }
-        facts.push({
+        appendFact({
             subjectKey,
             subjectLabel,
             valueKey,
@@ -603,7 +765,7 @@ function extractComparableEvidenceFacts(params) {
         if (!subjectKey || !valueKey) {
             continue;
         }
-        facts.push({
+        appendFact({
             subjectKey,
             subjectLabel,
             valueKey,
@@ -622,7 +784,7 @@ function extractComparableEvidenceFacts(params) {
         if (!subjectKey || !valueKey) {
             continue;
         }
-        facts.push({
+        appendFact({
             subjectKey,
             subjectLabel,
             valueKey,
@@ -641,7 +803,7 @@ function extractComparableEvidenceFacts(params) {
         if (!subjectKey || !valueKey) {
             continue;
         }
-        facts.push({
+        appendFact({
             subjectKey,
             subjectLabel,
             valueKey,
@@ -660,7 +822,7 @@ function extractComparableEvidenceFacts(params) {
         if (!subjectKey || !valueKey) {
             continue;
         }
-        facts.push({
+        appendFact({
             subjectKey,
             subjectLabel,
             valueKey,
@@ -679,7 +841,7 @@ function extractComparableEvidenceFacts(params) {
         if (!subjectKey || !valueKey) {
             continue;
         }
-        facts.push({
+        appendFact({
             subjectKey,
             subjectLabel,
             valueKey,
@@ -698,7 +860,7 @@ function extractComparableEvidenceFacts(params) {
         if (!subjectKey || !valueKey) {
             continue;
         }
-        facts.push({
+        appendFact({
             subjectKey,
             subjectLabel,
             valueKey,
@@ -717,7 +879,7 @@ function extractComparableEvidenceFacts(params) {
         if (!subjectKey || !valueKey) {
             continue;
         }
-        facts.push({
+        appendFact({
             subjectKey,
             subjectLabel,
             valueKey,
@@ -736,7 +898,7 @@ function extractComparableEvidenceFacts(params) {
         if (!subjectKey || !valueKey) {
             continue;
         }
-        facts.push({
+        appendFact({
             subjectKey,
             subjectLabel,
             valueKey,
@@ -763,10 +925,11 @@ function buildBlockCitationMap(group, blocks, source) {
     });
     return citationIdsByBlock;
 }
-function extractComparableEvidenceFactsFromBlockEntries(entries, citationIdsByBlock) {
+function extractComparableEvidenceFactsFromBlockEntries(entries, citationIdsByBlock, execution) {
     return entries
         .sort((left, right) => left.block.startOffset - right.block.startOffset)
         .flatMap(({ block, item }) => extractComparableEvidenceFacts({
+        execution,
         block,
         item,
         citationIds: Array.from(citationIdsByBlock.get(sourceBlockKey(block)) || []),
@@ -796,8 +959,7 @@ function buildEvidenceItemMap(group, blocks, source) {
     });
     return itemByBlock;
 }
-function collectSelectedContextComparableFacts(group, source, paragraphWindow) {
-    const blocks = parseMarkdownBlocks(source.content);
+function collectSelectedContextComparableFacts(group, source, paragraphWindow, blocks, execution) {
     const citationIdsByBlock = buildBlockCitationMap(group, blocks, source);
     const selectedBlocks = new Map();
     group.entries
@@ -810,33 +972,42 @@ function collectSelectedContextComparableFacts(group, source, paragraphWindow) {
             });
         });
     });
-    return extractComparableEvidenceFactsFromBlockEntries(Array.from(selectedBlocks.values()), citationIdsByBlock);
+    return extractComparableEvidenceFactsFromBlockEntries(Array.from(selectedBlocks.values()), citationIdsByBlock, execution);
 }
-function collectFullDocumentComparableFacts(group, source) {
+function collectFullDocumentComparableFacts(group, source, blocks, execution) {
     const fallbackItem = selectRepresentativeGroupItem(group);
     if (!fallbackItem) {
         return [];
     }
-    const blocks = parseMarkdownBlocks(source.content);
     const citationIdsByBlock = buildBlockCitationMap(group, blocks, source);
     const evidenceItemByBlock = buildEvidenceItemMap(group, blocks, source);
     return extractComparableEvidenceFactsFromBlockEntries(blocks.map((block) => ({
         block,
         item: evidenceItemByBlock.get(sourceBlockKey(block)) || fallbackItem,
-    })), citationIdsByBlock);
+    })), citationIdsByBlock, execution);
 }
 function comparableFactDocumentKey(fact) {
     return `${fact.item.atom.documentId}\n${fact.item.atom.sourcePath}`;
 }
-function buildConflictFragments(group, facts, paragraphWindow) {
+function comparableEvidenceFactsConflict(left, right) {
+    if (left.subjectKey !== right.subjectKey || left.factKind !== right.factKind)
+        return false;
+    if (left.factKind === 'measurement' && right.factKind === 'measurement') {
+        if (left.measurement.dimension !== right.measurement.dimension)
+            return false;
+        const sameMagnitude = left.measurement.magnitude === right.measurement.magnitude;
+        if (left.measurement.relation !== right.measurement.relation)
+            return sameMagnitude;
+        return left.measurement.relation === 'equal' && !sameMagnitude;
+    }
+    return left.valueKey !== right.valueKey;
+}
+function buildConflictFragments(group, facts, paragraphWindow, execution) {
     const fragments = [];
     const seenConflicts = new Set();
     facts.forEach((left, leftIndex) => {
         facts.slice(leftIndex + 1).forEach((right) => {
-            if (left.subjectKey !== right.subjectKey || left.factKind !== right.factKind) {
-                return;
-            }
-            if (left.valueKey === right.valueKey) {
+            if (!comparableEvidenceFactsConflict(left, right)) {
                 return;
             }
             const blockDistance = Math.abs(left.block.startLine - right.block.startLine);
@@ -864,7 +1035,7 @@ function buildConflictFragments(group, facts, paragraphWindow) {
                 `Conflicting evidence for ${left.subjectLabel}:`,
                 ...conflictBlockTexts,
             ].join('\n');
-            fragments.push({
+            fragments.push(finishEvidenceFragment({
                 fragmentId: `rag_conflict_${sanitizeFragmentPart(group.documentId)}_${fragments.length + 1}`,
                 role: 'conflict',
                 text,
@@ -887,12 +1058,12 @@ function buildConflictFragments(group, facts, paragraphWindow) {
                 ])),
                 score: Number(Math.max(Number(left.item.score || 0), Number(right.item.score || 0)).toFixed(4)),
                 sourceBoundary: 'full_document',
-            });
+            }, execution));
         });
     });
     return fragments;
 }
-function buildCrossDocumentConflictFragments(facts) {
+function buildCrossDocumentConflictFragments(facts, execution) {
     const orderedFacts = facts.slice().sort((left, right) => {
         const sourceDelta = String(left.item.atom.sourcePath || '').localeCompare(String(right.item.atom.sourcePath || ''));
         if (sourceDelta !== 0) {
@@ -903,14 +1074,12 @@ function buildCrossDocumentConflictFragments(facts) {
     const fragments = [];
     const seenConflicts = new Set();
     orderedFacts.forEach((left, leftIndex) => {
+        execution?.assertActive();
         orderedFacts.slice(leftIndex + 1).forEach((right) => {
             if (comparableFactDocumentKey(left) === comparableFactDocumentKey(right)) {
                 return;
             }
-            if (left.subjectKey !== right.subjectKey || left.factKind !== right.factKind) {
-                return;
-            }
-            if (left.valueKey === right.valueKey) {
+            if (!comparableEvidenceFactsConflict(left, right)) {
                 return;
             }
             const orderedSourceKeys = [comparableFactDocumentKey(left), comparableFactDocumentKey(right)].sort();
@@ -931,7 +1100,7 @@ function buildCrossDocumentConflictFragments(facts) {
                 `${left.item.atom.title}: ${left.block.text}`,
                 `${right.item.atom.title}: ${right.block.text}`,
             ].join('\n');
-            fragments.push({
+            fragments.push(finishEvidenceFragment({
                 fragmentId: `rag_conflict_cross_document_${sanitizeFragmentPart(left.item.atom.documentId)}_${sanitizeFragmentPart(right.item.atom.documentId)}_${fragments.length + 1}`,
                 role: 'conflict',
                 text,
@@ -950,7 +1119,7 @@ function buildCrossDocumentConflictFragments(facts) {
                 ])),
                 score: Number(Math.max(Number(left.item.score || 0), Number(right.item.score || 0)).toFixed(4)),
                 sourceBoundary: 'full_document',
-            });
+            }, execution));
         });
     });
     return fragments;
@@ -974,9 +1143,9 @@ function limitGraphNeighborDocumentContextFragments(fragments) {
         || fragment.sourceBoundary !== 'full_document'
         || selectedContextFragmentIds.has(fragment.fragmentId)));
 }
-function buildDirectFragment(item, span, index, role = 'direct_support') {
+function buildDirectFragment(item, span, index, role = 'direct_support', execution) {
     const text = normalizeWhitespace(String(span.snippet || item.atom.content || item.atom.title || ''));
-    return {
+    return finishEvidenceFragment({
         fragmentId: `${role === 'graph_neighbor_support' ? 'rag_graph_neighbor' : 'rag_direct'}_${sanitizeFragmentPart(item.atom.documentId)}_${sanitizeFragmentPart(span.id || String(index + 1))}`,
         role,
         text,
@@ -996,7 +1165,7 @@ function buildDirectFragment(item, span, index, role = 'direct_support') {
         relationEdgeIds: item.relationPath.map((edge) => edge.id),
         score: Number(Number(item.score || 0).toFixed(4)),
         sourceBoundary: 'direct_span_only',
-    };
+    }, execution);
 }
 function groupItemsByDocument(items, graphNeighborItems = []) {
     const groups = new Map();
@@ -1038,7 +1207,7 @@ async function resolveDocumentSource(group, sourceResolver) {
         atomIds,
         citationIds,
     });
-    if (!source || !String(source.content || '').trim()) {
+    if (!source || (!source.unavailableReason && !String(source.content || '').trim())) {
         return null;
     }
     return {
@@ -1048,8 +1217,7 @@ async function resolveDocumentSource(group, sourceResolver) {
         content: String(source.content || ''),
     };
 }
-function buildParentFragments(group, source, paragraphWindow) {
-    const blocks = parseMarkdownBlocks(source.content);
+function buildParentFragments(group, source, paragraphWindow, blocks, execution) {
     const parentDrafts = new Map();
     group.entries
         .filter((entry) => entry.expandDocumentContext)
@@ -1098,7 +1266,7 @@ function buildParentFragments(group, source, paragraphWindow) {
         const fragmentPrefix = draft.role === 'graph_neighbor_support'
             ? 'rag_graph_neighbor_context'
             : 'rag_parent';
-        return {
+        return finishEvidenceFragment({
             fragmentId: `${fragmentPrefix}_${sanitizeFragmentPart(draft.documentId)}_${index + 1}`,
             role: draft.role,
             text,
@@ -1118,7 +1286,7 @@ function buildParentFragments(group, source, paragraphWindow) {
             relationEdgeIds: Array.from(draft.relationEdgeIds),
             score: Number(Number(draft.score || 0).toFixed(4)),
             sourceBoundary: 'full_document',
-        };
+        }, execution);
     }).filter((fragment) => fragment.text.length > 0);
 }
 async function assembleRagEvidenceContext(params) {
@@ -1126,51 +1294,75 @@ async function assembleRagEvidenceContext(params) {
     const decisions = [];
     const rawFragments = [];
     const fullDocumentComparableFacts = [];
+    const execution = params.execution;
     let readFullDocument = false;
     const groups = groupItemsByDocument(Array.isArray(params.items) ? params.items : [], Array.isArray(params.graphNeighborItems) ? params.graphNeighborItems : []);
     for (const group of groups) {
-        group.entries.forEach((entry) => {
-            const item = entry.item;
-            itemEvidenceSpans(item).forEach((span, spanIndex) => {
-                rawFragments.push(buildDirectFragment(item, span, rawFragments.length + spanIndex, entry.directRole));
+        await execution?.yieldCheckpoint();
+        try {
+            group.entries.forEach(entry => {
+                itemEvidenceSpans(entry.item).forEach((span, spanIndex) => {
+                    rawFragments.push(buildDirectFragment(entry.item, span, rawFragments.length + spanIndex, entry.directRole, execution));
+                });
             });
-        });
-        const source = await resolveDocumentSource(group, params.sourceResolver);
-        if (!source) {
-            const unavailableRoles = Array.from(new Set(group.entries
-                .map((entry) => entry.directRole)
-                .filter(Boolean))).join(',');
+            const source = await resolveDocumentSource(group, params.sourceResolver);
+            execution?.assertActive();
+            if (!source || source.unavailableReason) {
+                const unavailableRoles = Array.from(new Set(group.entries.map(entry => entry.directRole))).join(',');
+                decisions.push({
+                    documentId: group.documentId, sourcePath: group.sourcePath,
+                    sourceBoundary: 'direct_span_only', status: 'source_window_unavailable',
+                    reason: source?.unavailableReason || `source_resolver_returned_no_content:${unavailableRoles}`,
+                });
+                continue;
+            }
+            readFullDocument = true;
+            const blocks = parseMarkdownBlocks(source.content, execution);
+            rawFragments.push(...buildParentFragments(group, source, paragraphWindow, blocks, execution));
+            const selectedFacts = collectSelectedContextComparableFacts(group, source, paragraphWindow, blocks, execution);
+            fullDocumentComparableFacts.push(...collectFullDocumentComparableFacts(group, source, blocks, execution));
+            rawFragments.push(...buildConflictFragments(group, selectedFacts, paragraphWindow, execution));
             decisions.push({
-                documentId: group.documentId,
-                sourcePath: group.sourcePath,
-                sourceBoundary: 'direct_span_only',
-                status: 'source_window_unavailable',
-                reason: unavailableRoles
-                    ? `source_resolver_returned_no_content:${unavailableRoles}`
-                    : 'source_resolver_returned_no_content',
+                documentId: group.documentId, sourcePath: group.sourcePath,
+                sourceBoundary: 'full_document', status: 'read', charsRead: source.content.length,
             });
-            continue;
         }
-        readFullDocument = true;
+        catch (error) {
+            if (!execution || !execution.isResourceLimit(error))
+                throw error;
+            decisions.push({
+                documentId: group.documentId, sourcePath: group.sourcePath,
+                sourceBoundary: 'direct_span_only', status: 'source_window_unavailable', reason: error.code,
+            });
+            if (error.code === 'runtime_fragment_limit')
+                break;
+        }
+    }
+    try {
+        rawFragments.push(...buildCrossDocumentConflictFragments(fullDocumentComparableFacts, execution));
+    }
+    catch (error) {
+        if (!execution || !execution.isResourceLimit(error))
+            throw error;
         decisions.push({
-            documentId: group.documentId,
-            sourcePath: group.sourcePath,
-            sourceBoundary: 'full_document',
-            status: 'read',
-            charsRead: source.content.length,
+            documentId: 'cross_document_conflicts', sourcePath: '',
+            sourceBoundary: 'direct_span_only', status: 'source_window_unavailable', reason: error.code,
         });
-        rawFragments.push(...buildParentFragments(group, source, paragraphWindow));
-        const selectedContextComparableFacts = collectSelectedContextComparableFacts(group, source, paragraphWindow);
-        fullDocumentComparableFacts.push(...collectFullDocumentComparableFacts(group, source));
-        rawFragments.push(...buildConflictFragments(group, selectedContextComparableFacts, paragraphWindow));
     }
-    rawFragments.push(...buildCrossDocumentConflictFragments(fullDocumentComparableFacts));
+    execution?.assertActive();
+    const candidateFragments = limitGraphNeighborDocumentContextFragments(rawFragments);
+    const graphConditioning = (0, graphConditionedContext_1.conditionRagFragmentsByGraphPlan)({
+        fragments: candidateFragments,
+        graphAnswerPlan: params.graphAnswerPlan,
+    });
     return (0, ragContextPack_1.buildRagContextPack)({
         query: params.query,
         generatedAt: params.generatedAt,
         sourceBoundary: readFullDocument ? 'full_document' : 'direct_span_only',
-        fragments: limitGraphNeighborDocumentContextFragments(rawFragments),
+        fragments: candidateFragments,
         sourceDecisions: decisions,
         budget: params.budget,
+        fragmentOrder: graphConditioning.fragmentOrder,
+        graphConditioning: graphConditioning.trace,
     });
 }