noteconnection 1.8.0 → 1.9.0

package/dist/src/learning/ragContextPack.js

@@ -5,6 +5,8 @@ exports.normalizeRagContextBudget = normalizeRagContextBudget;
 exports.estimateRagTokenCount = estimateRagTokenCount;
 exports.buildRagContextPack = buildRagContextPack;
 const crypto_1 = require("crypto");
+const graphClaimMatcher_1 = require("./graphClaimMatcher");
+const ragPublicText_1 = require("./ragPublicText");
 exports.DEFAULT_RAG_CONTEXT_BUDGET = {
     maxFragments: 16,
     maxCharsPerFragment: 1600,
@@ -19,6 +21,9 @@ const ROLE_PRIORITY = {
     background: 5,
 };
 function normalizeRagContextBudget(input) {
+    const productCapDisabled = input?.productCapDisabled === true;
+    const maxFragmentsLimit = productCapDisabled ? 4096 : 512;
+    const maxTotalCharsLimit = productCapDisabled ? 512000 : 512000;
     const numberOrDefault = (value, fallback, min, max) => {
         const numeric = Number(value);
         if (!Number.isFinite(numeric)) {
@@ -27,9 +32,15 @@ function normalizeRagContextBudget(input) {
         return Math.floor(Math.max(min, Math.min(max, numeric)));
     };
     return {
-        maxFragments: numberOrDefault(input?.maxFragments, exports.DEFAULT_RAG_CONTEXT_BUDGET.maxFragments, 1, 200),
+        maxFragments: numberOrDefault(input?.maxFragments, exports.DEFAULT_RAG_CONTEXT_BUDGET.maxFragments, 1, maxFragmentsLimit),
         maxCharsPerFragment: numberOrDefault(input?.maxCharsPerFragment, exports.DEFAULT_RAG_CONTEXT_BUDGET.maxCharsPerFragment, 80, 20000),
-        maxTotalChars: numberOrDefault(input?.maxTotalChars, exports.DEFAULT_RAG_CONTEXT_BUDGET.maxTotalChars, 120, 100000),
+        maxTotalChars: numberOrDefault(input?.maxTotalChars, exports.DEFAULT_RAG_CONTEXT_BUDGET.maxTotalChars, 120, maxTotalCharsLimit),
+        ...(productCapDisabled ? {
+            productCapDisabled: true,
+            runtimeMaxFragments: numberOrDefault(input?.runtimeMaxFragments, input?.maxFragments ?? exports.DEFAULT_RAG_CONTEXT_BUDGET.maxFragments, 1, 4096),
+            runtimeMaxCharsPerFragment: numberOrDefault(input?.runtimeMaxCharsPerFragment, input?.maxCharsPerFragment ?? exports.DEFAULT_RAG_CONTEXT_BUDGET.maxCharsPerFragment, 80, 20000),
+            runtimeMaxTotalChars: numberOrDefault(input?.runtimeMaxTotalChars, input?.maxTotalChars ?? exports.DEFAULT_RAG_CONTEXT_BUDGET.maxTotalChars, 120, 64 * 1024 * 1024),
+        } : {}),
     };
 }
 function estimateRagTokenCount(text) {
@@ -39,7 +50,75 @@ function estimateRagTokenCount(text) {
     }
     return Math.max(1, Math.ceil(normalized.length / 4));
 }
-function truncateMiddle(text, maxChars) {
+const QUERY_WINDOW_STOPWORDS = new Set([
+    'and', 'compare', 'contrast', 'difference', 'the', 'versus', 'with',
+]);
+function queryWindowTerms(query) {
+    return Array.from(new Set((String(query || '').toLowerCase().match(/[a-z0-9][a-z0-9_-]{2,}|[\u3400-\u9fff]{2,}/gu) || [])
+        .filter((term) => !QUERY_WINDOW_STOPWORDS.has(term))));
+}
+function queryTermCoverage(text, terms) {
+    const normalized = text.toLowerCase();
+    return terms.reduce((count, term) => count + (normalized.includes(term) ? 1 : 0), 0);
+}
+function queryFeatureCoverage(text, queryFeatures) {
+    return (0, graphClaimMatcher_1.semanticFeatures)(text).reduce((count, feature) => count + (queryFeatures.has(feature) ? 1 : 0), 0);
+}
+function queryWindowAnchors(source, terms, queryFeatures) {
+    const anchors = new Set();
+    const normalizedSource = source.toLowerCase();
+    terms.forEach((term) => {
+        let matchIndex = normalizedSource.indexOf(term);
+        while (matchIndex >= 0) {
+            anchors.add(matchIndex);
+            matchIndex = normalizedSource.indexOf(term, matchIndex + term.length);
+        }
+    });
+    const clausePattern = /[^\n.!?。！？；;]+(?:[.!?。！？；;]+|$)/gu;
+    let clauseMatch;
+    while ((clauseMatch = clausePattern.exec(source)) !== null) {
+        if (queryFeatureCoverage(clauseMatch[0], queryFeatures) > 0) {
+            anchors.add(clauseMatch.index + Math.floor(clauseMatch[0].length / 2));
+        }
+    }
+    return Array.from(anchors).sort((left, right) => left - right);
+}
+function queryCenteredWindow(source, maxChars, query, baseline) {
+    const terms = queryWindowTerms(query);
+    const queryFeatures = new Set((0, graphClaimMatcher_1.semanticFeatures)(query));
+    if (queryFeatures.size < 2) {
+        return null;
+    }
+    const visibleSource = (0, ragPublicText_1.omitFencedMarkdownPayload)(source);
+    const markerLength = '\n[...]\n'.length;
+    const windowLength = Math.max(16, maxChars - markerLength * 2);
+    const visibleBaseline = (0, ragPublicText_1.omitFencedMarkdownPayload)(baseline);
+    const baselineFeatureCoverage = queryFeatureCoverage(visibleBaseline, queryFeatures);
+    const baselineTermCoverage = queryTermCoverage(visibleBaseline, terms);
+    let selected = null;
+    for (const anchor of queryWindowAnchors(visibleSource, terms, queryFeatures)) {
+        const start = Math.max(0, Math.min(visibleSource.length - windowLength, anchor - Math.floor(windowLength * 0.35)));
+        const candidate = visibleSource.slice(start, start + windowLength);
+        const featureCoverage = queryFeatureCoverage(candidate, queryFeatures);
+        const termCoverage = queryTermCoverage(candidate, terms);
+        if (!selected
+            || featureCoverage > selected.featureCoverage
+            || (featureCoverage === selected.featureCoverage
+                && termCoverage > selected.termCoverage)) {
+            selected = { start, text: candidate, featureCoverage, termCoverage };
+        }
+    }
+    if (!selected
+        || selected.featureCoverage < baselineFeatureCoverage
+        || (selected.featureCoverage === baselineFeatureCoverage
+            && selected.termCoverage <= baselineTermCoverage)) {
+        return null;
+    }
+    const prefix = selected.start > 0 ? '[...]\n' : '';
+    const suffix = selected.start + selected.text.length < visibleSource.length ? '\n[...]' : '';
+    return `${prefix}${selected.text.trim()}${suffix}`;
+}
+function truncateMiddle(text, maxChars, query) {
     const source = String(text || '');
     if (source.length <= maxChars) {
         return { text: source, truncated: false };
@@ -51,13 +130,14 @@ function truncateMiddle(text, maxChars) {
     const available = Math.max(0, maxChars - marker.length);
     const headLength = Math.ceil(available * 0.6);
     const tailLength = Math.floor(available * 0.4);
+    const baseline = `${source.slice(0, headLength).trimEnd()}${marker}${source.slice(source.length - tailLength).trimStart()}`;
     return {
-        text: `${source.slice(0, headLength).trimEnd()}${marker}${source.slice(source.length - tailLength).trimStart()}`,
+        text: queryCenteredWindow(source, maxChars, query, baseline) || baseline,
         truncated: true,
     };
 }
-function withBudgetedText(fragment, maxChars, reason) {
-    const truncated = truncateMiddle(fragment.text, maxChars);
+function withBudgetedText(fragment, maxChars, reason, query) {
+    const truncated = truncateMiddle(fragment.text, maxChars, query);
     const text = truncated.text;
     return {
         ...fragment,
@@ -71,7 +151,8 @@ function withBudgetedText(fragment, maxChars, reason) {
 function rolePriority(fragment) {
     return ROLE_PRIORITY[fragment.role] ?? ROLE_PRIORITY.background;
 }
-function sortFragmentsForBudget(fragments) {
+function sortFragmentsForBudget(fragments, fragmentOrder) {
+    const order = new Map((fragmentOrder || []).map((fragmentId, index) => [String(fragmentId), index]));
     return fragments
         .map((fragment, index) => ({ fragment, index }))
         .sort((a, b) => {
@@ -83,33 +164,48 @@ function sortFragmentsForBudget(fragments) {
         if (Math.abs(scoreDelta) > 0.0001) {
             return scoreDelta;
         }
+        const conditionedOrderDelta = (order.get(a.fragment.fragmentId) ?? Number.MAX_SAFE_INTEGER)
+            - (order.get(b.fragment.fragmentId) ?? Number.MAX_SAFE_INTEGER);
+        if (conditionedOrderDelta !== 0) {
+            return conditionedOrderDelta;
+        }
         return a.index - b.index;
     })
         .map((entry) => entry.fragment);
 }
-function applyContextBudget(fragments, budget, decisions) {
+function applyContextBudget(fragments, budget, decisions, query, fragmentOrder) {
     const selected = [];
     let usedChars = 0;
-    sortFragmentsForBudget(fragments).forEach((fragment) => {
-        if (selected.length >= budget.maxFragments) {
+    const productCapDisabled = budget.productCapDisabled === true;
+    const maxFragments = productCapDisabled
+        ? budget.runtimeMaxFragments || budget.maxFragments
+        : budget.maxFragments;
+    const maxCharsPerFragment = productCapDisabled
+        ? budget.runtimeMaxCharsPerFragment || budget.maxCharsPerFragment
+        : budget.maxCharsPerFragment;
+    const maxTotalChars = productCapDisabled
+        ? budget.runtimeMaxTotalChars || budget.maxTotalChars
+        : budget.maxTotalChars;
+    sortFragmentsForBudget(fragments, fragmentOrder).forEach((fragment) => {
+        if (selected.length >= maxFragments) {
             decisions.push({
                 documentId: fragment.documentId,
                 sourcePath: fragment.sourcePath,
                 sourceBoundary: fragment.sourceBoundary,
                 status: 'fragment_dropped',
-                reason: 'max_fragments_exceeded',
+                reason: productCapDisabled ? 'runtime_fragment_limit_exceeded' : 'max_fragments_exceeded',
             });
             return;
         }
-        let candidate = withBudgetedText(fragment, budget.maxCharsPerFragment, 'max_chars_per_fragment_exceeded');
-        const remainingChars = budget.maxTotalChars - usedChars;
+        let candidate = withBudgetedText(fragment, maxCharsPerFragment, productCapDisabled ? 'runtime_max_chars_per_fragment_exceeded' : 'max_chars_per_fragment_exceeded', query);
+        const remainingChars = maxTotalChars - usedChars;
         if (remainingChars <= 0) {
             decisions.push({
                 documentId: fragment.documentId,
                 sourcePath: fragment.sourcePath,
                 sourceBoundary: fragment.sourceBoundary,
                 status: 'fragment_dropped',
-                reason: 'max_total_chars_exceeded',
+                reason: productCapDisabled ? 'runtime_total_chars_exceeded' : 'max_total_chars_exceeded',
             });
             return;
         }
@@ -124,7 +220,7 @@ function applyContextBudget(fragments, budget, decisions) {
                 });
                 return;
             }
-            candidate = withBudgetedText(candidate, remainingChars, 'max_total_chars_exceeded');
+            candidate = withBudgetedText(candidate, remainingChars, productCapDisabled ? 'runtime_total_chars_exceeded' : 'max_total_chars_exceeded', query);
         }
         selected.push(candidate);
         usedChars += candidate.charCount;
@@ -216,6 +312,7 @@ function buildRagContextReplayId(params) {
             left.status.localeCompare(right.status),
             left.reason.localeCompare(right.reason),
         ].find((delta) => delta !== 0) || 0),
+        graphConditioning: params.graphConditioning || null,
     };
     const digest = (0, crypto_1.createHash)('sha256')
         .update(JSON.stringify(payload))
@@ -229,7 +326,7 @@ function buildRagContextPack(params) {
         ? params.sourceDecisions.map((decision) => ({ ...decision }))
         : [];
     const fragments = Array.isArray(params.fragments) ? params.fragments.filter(Boolean) : [];
-    const selectedFragments = applyContextBudget(fragments, budget, decisions);
+    const selectedFragments = applyContextBudget(fragments, budget, decisions, params.query, params.fragmentOrder);
     annotateReadDecisions(decisions, selectedFragments);
     const totalCharCount = selectedFragments.reduce((sum, fragment) => sum + fragment.charCount, 0);
     const tokenEstimate = selectedFragments.reduce((sum, fragment) => sum + fragment.tokenEstimate, 0);
@@ -244,6 +341,7 @@ function buildRagContextPack(params) {
             sourceDecisions: decisions,
             totalCharCount,
             tokenEstimate,
+            graphConditioning: params.graphConditioning,
         }),
         query,
         generatedAt: String(params.generatedAt || new Date().toISOString()),
@@ -253,5 +351,6 @@ function buildRagContextPack(params) {
         sourceDecisions: decisions,
         totalCharCount,
         tokenEstimate,
+        graphConditioning: params.graphConditioning,
     };
 }

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

@@ -117,6 +117,61 @@ describe('buildRagContextPack', () => {
             }),
         ]));
     });
+    test('centers the bounded window on query terms when a later comparison clause would otherwise be dropped', () => {
+        const longText = [
+            'Opening definition: a water glass is a transparent vessel.',
+            'Background context '.repeat(28),
+            'Comparison: a plastic cup is lightweight and less rigid than a water glass.',
+            'Terminal qualifier: the comparison remains limited to the scoped note.',
+        ].join('\n');
+        const pack = (0, ragContextPack_1.buildRagContextPack)({
+            query: 'compare water glass and plastic cup',
+            fragments: [
+                makeFragment({
+                    role: 'parent_context',
+                    text: longText,
+                    sourceBoundary: 'full_document',
+                }),
+            ],
+            sourceDecisions: [],
+            budget: {
+                maxFragments: 3,
+                maxCharsPerFragment: 180,
+                maxTotalChars: 220,
+            },
+            generatedAt: '2026-07-05T00:00:00.000Z',
+        });
+        expect(pack.fragments[0].text).toContain('plastic cup');
+        expect(pack.fragments[0].text).toContain('water glass');
+    });
+    test('prefers multilingual comparison prose outside fenced renderer payloads', () => {
+        const longText = [
+            'Opening definition: a water glass is a transparent vessel.',
+            'Background context '.repeat(20),
+            '```mermaid',
+            'graph LR',
+            'A[Water Glass] --> B[Plastic Cup PET]',
+            '```',
+            '相同尺寸下，PET塑料杯比玻璃水杯更轻、更有韧性，但刚度和透明度较低。',
+            'Terminal qualifier: the comparison remains limited to the scoped note.',
+        ].join('\n');
+        const pack = (0, ragContextPack_1.buildRagContextPack)({
+            query: 'compare water glass and plastic cup',
+            fragments: [makeFragment({
+                    role: 'parent_context',
+                    text: longText,
+                    sourceBoundary: 'full_document',
+                })],
+            sourceDecisions: [],
+            budget: {
+                maxFragments: 3,
+                maxCharsPerFragment: 180,
+                maxTotalChars: 220,
+            },
+        });
+        expect(pack.fragments[0].text).toContain('PET塑料杯');
+        expect(pack.fragments[0].text).not.toContain('graph LR');
+    });
     test('uses role priority so weak background cannot displace direct or graph evidence', () => {
         const pack = (0, ragContextPack_1.buildRagContextPack)({
             query: 'what is water glass?',
@@ -157,4 +212,100 @@ describe('buildRagContextPack', () => {
             }),
         ]));
     });
+    test('uses graph-conditioned order only as a tie-break inside the same role and score', () => {
+        const pack = (0, ragContextPack_1.buildRagContextPack)({
+            query: 'what is water glass?',
+            fragments: [
+                makeFragment({ fragmentId: 'graph-unmatched', role: 'graph_neighbor_support', score: 0.6 }),
+                makeFragment({ fragmentId: 'graph-matched', role: 'graph_neighbor_support', score: 0.6 }),
+                makeFragment({ fragmentId: 'direct', role: 'direct_support', score: 0.4 }),
+            ],
+            fragmentOrder: ['graph-matched', 'graph-unmatched', 'direct'],
+            sourceDecisions: [],
+            budget: {
+                maxFragments: 3,
+                maxCharsPerFragment: 200,
+                maxTotalChars: 600,
+            },
+        });
+        expect(pack.fragments.map((fragment) => fragment.fragmentId)).toEqual([
+            'direct',
+            'graph-matched',
+            'graph-unmatched',
+        ]);
+    });
+    test('unbounded product mode ignores product caps while retaining explicit runtime limits', () => {
+        const pack = (0, ragContextPack_1.buildRagContextPack)({
+            query: 'what is water glass?',
+            fragments: Array.from({ length: 4 }, (_, index) => makeFragment({
+                fragmentId: `unbounded_${index}`,
+                role: 'parent_context',
+                text: `Section ${index}: ${'water glass evidence '.repeat(12)}`,
+                sourceBoundary: 'full_document',
+            })),
+            sourceDecisions: [],
+            budget: {
+                maxFragments: 1,
+                maxCharsPerFragment: 100,
+                maxTotalChars: 120,
+                productCapDisabled: true,
+                runtimeMaxFragments: 8,
+                runtimeMaxCharsPerFragment: 900,
+                runtimeMaxTotalChars: 10000,
+            },
+        });
+        expect(pack.fragments).toHaveLength(4);
+        expect(pack.budget.productCapDisabled).toBe(true);
+        expect(pack.sourceDecisions).not.toEqual(expect.arrayContaining([
+            expect.objectContaining({ reason: 'max_fragments_exceeded' }),
+        ]));
+    });
+    test('preserves the configured max tier instead of applying the legacy 200-fragment/100k cap', () => {
+        const pack = (0, ragContextPack_1.buildRagContextPack)({
+            query: 'max budget probe',
+            fragments: Array.from({ length: 260 }, (_, index) => makeFragment({
+                fragmentId: `max_tier_${index}`,
+                role: 'direct_support',
+                text: `Max tier evidence ${index}.`,
+                sourceBoundary: 'full_document',
+            })),
+            sourceDecisions: [],
+            budget: {
+                maxFragments: 256,
+                maxCharsPerFragment: 16000,
+                maxTotalChars: 256000,
+            },
+        });
+        expect(pack.budget.maxFragments).toBe(256);
+        expect(pack.budget.maxTotalChars).toBe(256000);
+        expect(pack.fragments).toHaveLength(256);
+    });
+    test('unbounded mode reports a runtime fragment stop instead of silently dropping content', () => {
+        const pack = (0, ragContextPack_1.buildRagContextPack)({
+            query: 'what is water glass?',
+            fragments: Array.from({ length: 4 }, (_, index) => makeFragment({
+                fragmentId: `runtime_limited_${index}`,
+                role: 'parent_context',
+                text: `Runtime section ${index}: water glass evidence.`,
+                sourceBoundary: 'full_document',
+            })),
+            sourceDecisions: [],
+            budget: {
+                maxFragments: 1,
+                maxCharsPerFragment: 100,
+                maxTotalChars: 120,
+                productCapDisabled: true,
+                runtimeMaxFragments: 2,
+                runtimeMaxCharsPerFragment: 900,
+                runtimeMaxTotalChars: 10000,
+            },
+        });
+        expect(pack.fragments).toHaveLength(2);
+        expect(pack.sourceDecisions).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                status: 'fragment_dropped',
+                reason: 'runtime_fragment_limit_exceeded',
+            }),
+        ]));
+    });
 });

package/dist/src/learning/ragEvidenceQuality.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iterateRagEvidenceClauses = iterateRagEvidenceClauses;
+exports.segmentRagEvidenceClauses = segmentRagEvidenceClauses;
+exports.scoreRagEvidenceClause = scoreRagEvidenceClause;
+function normalizeWhitespace(value) {
+    return String(value || '').replace(/\s+/gu, ' ').trim();
+}
+function isClauseBoundary(source, index) {
+    const character = source[index];
+    if (/\r|\n|;/u.test(character)) {
+        return true;
+    }
+    if (character === '.' && /[\d\s=+\-(]/u.test(source[index - 1] || ' ') && /\d/u.test(source[index + 1] || '')) {
+        return false;
+    }
+    return /[.!?。！？；]/u.test(character);
+}
+/**
+ * Splits source evidence at discourse boundaries while retaining decimal numbers and
+ * mathematical notation. The caller still owns filtering and public-text naturalization.
+ */
+function* iterateRagEvidenceClauses(value) {
+    const source = String(value || '');
+    if (!source) {
+        return;
+    }
+    let start = 0;
+    for (let index = 0; index < source.length; index += 1) {
+        if (!isClauseBoundary(source, index)) {
+            continue;
+        }
+        const includeBoundary = /[.!?。！？]/u.test(source[index]);
+        const clause = normalizeWhitespace(source.slice(start, includeBoundary ? index + 1 : index));
+        if (clause) {
+            yield clause;
+        }
+        start = index + 1;
+    }
+    const remainder = normalizeWhitespace(source.slice(start));
+    if (remainder) {
+        yield remainder;
+    }
+}
+function segmentRagEvidenceClauses(value) {
+    return Array.from(iterateRagEvidenceClauses(value));
+}
+function delimiterBalance(value) {
+    const pairs = { '(': ')', '[': ']', '{': '}', '（': '）', '［': '］', '｛': '｝' };
+    const closing = new Set(Object.values(pairs));
+    const stack = [];
+    for (const character of value) {
+        if (pairs[character]) {
+            stack.push(pairs[character]);
+        }
+        else if (closing.has(character) && stack.pop() !== character) {
+            return false;
+        }
+    }
+    return stack.length === 0;
+}
+function mathDensity(value) {
+    const mathTokens = value.match(/(?:\b\d+(?:\.\d+)?\b|[=<>±×÷∑∫√]|\b(?:sin|cos|log|exp)\b)/giu) || [];
+    return Math.min(1, mathTokens.length / Math.max(6, value.length / 24));
+}
+function documentaryPenalty(value) {
+    return /\b(?:this (?:document|section|table)|the following|as requested|we will|must follow|ignore this)\b/iu.test(value)
+        || /(?:本文档|下表|如下|按照您的要求|忽略本节)/u.test(value)
+        ? 0.35
+        : 0;
+}
+function scoreRagEvidenceClause(value) {
+    const clause = normalizeWhitespace(value);
+    const hasTerminalPunctuation = /[.!?。！？]$/u.test(clause);
+    const hasBalancedDelimiters = delimiterBalance(clause);
+    const density = mathDensity(clause);
+    const penalty = documentaryPenalty(clause);
+    const lengthScore = clause.length < 8
+        ? -0.3
+        : clause.length <= 420
+            ? 0.25
+            : -Math.min(0.25, (clause.length - 420) / 2400);
+    const score = Math.max(0, Math.min(1, 0.35
+        + (hasTerminalPunctuation ? 0.15 : -0.08)
+        + (hasBalancedDelimiters ? 0.15 : -0.3)
+        + Math.min(0.2, density * 0.2)
+        + lengthScore
+        - penalty));
+    return {
+        score: Number(score.toFixed(4)),
+        hasTerminalPunctuation,
+        hasBalancedDelimiters,
+        mathDensity: Number(density.toFixed(4)),
+        documentaryPenalty: penalty,
+    };
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ragEvidenceQuality_1 = require("./ragEvidenceQuality");
+describe('ragEvidenceQuality', () => {
+    test('segments prose without splitting decimal mathematical values', () => {
+        expect((0, ragEvidenceQuality_1.segmentRagEvidenceClauses)('The coefficient is 0.75; heat transfer follows the wall.')).toEqual([
+            'The coefficient is 0.75',
+            'heat transfer follows the wall.',
+        ]);
+    });
+    test('scores complete balanced mathematical evidence above documentary prose', () => {
+        const evidence = (0, ragEvidenceQuality_1.scoreRagEvidenceClause)('The thermal flux is q = kA(T1 - T2) / L, so thickness changes the exchange rate.');
+        const documentary = (0, ragEvidenceQuality_1.scoreRagEvidenceClause)('This document will explain the following table as requested.');
+        expect(evidence.hasBalancedDelimiters).toBe(true);
+        expect(evidence.mathDensity).toBeGreaterThan(0);
+        expect(evidence.score).toBeGreaterThan(documentary.score);
+        expect(documentary.documentaryPenalty).toBeGreaterThan(0);
+    });
+    test('preserves leading decimal measurements without joining numbered sentences', () => {
+        expect((0, ragEvidenceQuality_1.segmentRagEvidenceClauses)('The offset is -.25 ms. The duration is .5 s; 1. Next observation.')).toEqual([
+            'The offset is -.25 ms.', 'The duration is .5 s', '1.', 'Next observation.',
+        ]);
+    });
+    test('penalizes unbalanced mathematical fragments', () => {
+        const quality = (0, ragEvidenceQuality_1.scoreRagEvidenceClause)('The flux is q = kA(T1 - T2 / L.');
+        expect(quality.hasBalancedDelimiters).toBe(false);
+        expect(quality.score).toBeLessThan(0.5);
+    });
+});

package/dist/src/learning/ragPublicText.js

@@ -1,14 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.omitFencedMarkdownPayload = omitFencedMarkdownPayload;
+exports.extractPublicMermaidEvidenceLabels = extractPublicMermaidEvidenceLabels;
 exports.naturalizeRagPublicEvidenceClause = naturalizeRagPublicEvidenceClause;
+exports.shouldRejectPublicEvidenceClause = shouldRejectPublicEvidenceClause;
 exports.shouldRejectCompareProcedureEvidenceClause = shouldRejectCompareProcedureEvidenceClause;
+const answerTaskPlan_1 = require("./answerTaskPlan");
 function normalizeWhitespace(value) {
     return String(value || '').replace(/\s+/g, ' ').trim();
 }
-const LEADING_SOURCE_LABEL_PATTERN = /^(?:prerequisites?|preconditions?|requirements?|background|context|mechanism|reasoning boundary|downstream checks?|downstream consequences?|failure modes?|mitigation(?: neighbor)?|graph caveat|caveat|evidence|summary|note)\s*[:\uFF1A-]\s*/iu;
+function omitFencedMarkdownPayload(value) {
+    return String(value || '')
+        .replace(/```[\s\S]*?```/gu, ' ')
+        .replace(/```[\s\S]*$/u, ' ');
+}
+function normalizeMermaidLabel(value) {
+    return normalizeWhitespace(String(value || '')
+        .replace(/<br\s*\/?>/giu, ' ')
+        .replace(/\\n/gu, ' ')
+        .replace(/["`*_~#|{}]/gu, ' '));
+}
+/**
+ * Converts diagram node labels into evidence text while keeping Mermaid syntax out of public answers.
+ */
+function extractPublicMermaidEvidenceLabels(value) {
+    const labels = [];
+    const append = (candidate) => {
+        const label = normalizeMermaidLabel(candidate);
+        if (label && !labels.includes(label)) {
+            labels.push(label);
+        }
+    };
+    const source = String(value || '');
+    const fences = source.matchAll(/```mermaid\s*([\s\S]*?)(?:```|$)/giu);
+    for (const fence of fences) {
+        const body = String(fence[1] || '');
+        body.replace(/\[([^\]]+)\]/gu, (_match, label) => {
+            append(label);
+            return '';
+        });
+        body.replace(/"([^"]+)"/gu, (_match, label) => {
+            append(label);
+            return '';
+        });
+    }
+    return labels;
+}
+const LEADING_SOURCE_LABEL_PATTERN = /^(?:(?:prerequisites?|preconditions?|requirements?|background|context|mechanism|reasoning boundary|downstream checks?|downstream consequences?|failure modes?|mitigation(?: neighbor)?|graph caveat|caveat|evidence|summary|note|material science)\s*[:\uFF1A-]\s*|(?:核心概念(?:及其数学基础)?|材料科学|技术参数)(?:\s*[:\uFF1A-]\s*|\s+))/iu;
 const PRESERVED_LEADING_LABEL_PATTERN = /^(?:step|phase|stage|section)\s*\d+\s*[:\uFF1A-]/iu;
 function naturalizeRagPublicEvidenceClause(value) {
-    let normalized = normalizeWhitespace(value);
+    let normalized = normalizeWhitespace(omitFencedMarkdownPayload(value)
+        .replace(/^\s*[-+*]\s+/gmu, '')
+        .replace(/\s+\*\s+(?=\$|\*\*|[\u3400-\u9fff])/gu, ' ')
+        .replace(/\*\*([^*]+)\*\*/gu, '$1')
+        .replace(/([+\-]\/)\s+(?=\d)/gu, '$1')
+        .replace(/(\d)\.\s+(?=\d)/gu, '$1.')
+        .replace(/^(?:#{1,6})\s+/u, ''));
+    const tableStart = normalized.search(/\s\|\s*[^|]+\s*\|/u);
+    if (tableStart >= 0) {
+        normalized = normalizeWhitespace(normalized.slice(0, tableStart));
+    }
     if (!normalized || PRESERVED_LEADING_LABEL_PATTERN.test(normalized)) {
         return normalized;
     }
@@ -24,15 +75,27 @@ function naturalizeRagPublicEvidenceClause(value) {
     }
     return normalized;
 }
+function shouldRejectPublicEvidenceClause(value) {
+    const normalized = normalizeWhitespace(value);
+    // A bare wiki link identifies a note, but supplies no factual statement for answer coverage.
+    return /^(?:(?:\d+[.)]|[-*+])?\s*\[\[[^\]]+\]\][\s,;、，；.!。]*)+$/u.test(normalized)
+        || /\b(?:distractor|must not guide|do not use|ignore this (?:section|evidence)|must (?:compare|resolve)|before publishing)\b/iu.test(normalized)
+        || /\b(?:this|the)\s+(?:clause|sentence|paragraph)\b[^.!?]{0,120}\bpublic\s+(?:definition|answer)\s+budget\b/iu.test(normalized)
+        || /\b(?:the following table|the table below)\b/iu.test(normalized)
+        || /(?:下表|以下表格|表中)(?:列出|展示|给出|包含)/u.test(normalized)
+        || /(?:参数\s*\(Parameter\)|Parameter).{0,160}(?:单位\s*\(Unit\)|Unit).{0,160}:---/iu.test(normalized)
+        || /(?:遵从您的指示|所有推理过程|最终输出|仅基于标题|根据您的要求生成|本技术文档旨在)/u.test(normalized);
+}
 function shouldRejectCompareProcedureEvidenceClause(value, query) {
     const normalizedClause = normalizeWhitespace(value).toLowerCase();
     const normalizedQuery = normalizeWhitespace(query).toLowerCase();
     if (!normalizedClause) {
         return false;
     }
-    if (/\b(?:procedure|procedural|workflow|runbook|steps?|step\s*\d+|sequence)\b/u.test(normalizedQuery)) {
+    if ((0, answerTaskPlan_1.isProcedureRequest)(normalizedQuery)) {
         return false;
     }
-    return /\b(?:procedure|workflow|runbook|steps?|step\s*\d+)\b/u.test(normalizedClause)
+    return /^(?:(?:procedure|workflow|runbook)\s*[:\uFF1A-]|(?:step\s*\d+|steps?|步骤\s*\d+)\b)/u.test(normalizedClause)
+        || /\b(?:follow|execute|perform)\s+(?:this|the following)\s+(?:procedure|workflow|steps?)\b/u.test(normalizedClause)
         || /\bprocedural\b.{0,80}\bsequence\b/u.test(normalizedClause);
 }