noteconnection 1.7.0 → 1.9.0

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const KnowledgeLearningPlatform_1 = require("./KnowledgeLearningPlatform");
+async function measurementEvidence(first, second) {
+    const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({ autoPersist: false });
+    await platform.ingestKnowledge({ relationRecomputeMode: 'none', documents: [
+            { documentId: 'measurement-left', sourcePath: 'quality/measurement-left.md', content: `# Calibration Measurements\n${first}` },
+            { documentId: 'measurement-right', sourcePath: 'quality/measurement-right.md', content: `# Calibration Measurements\n${second}` },
+        ] });
+    return platform.agentConversation({ message: 'Summarize calibration measurements.', responseMode: 'full', persistMemory: false });
+}
+const measurements = [
+    ['different frequencies', 'The calibration rate is 12 Hz.', 'The calibration rate is 18 Hz.', true],
+    ['storage capacity', 'The calibration capacity is 64 MB.', 'The calibration capacity is 128 MB.', true],
+    ['Chinese storage capacity', '定标缓冲区容量是64MB。', '定标缓冲区容量是128MB。', true],
+    ['decimal storage units', 'The calibration capacity is 1 MB.', 'The calibration capacity is 1000000 B.', false],
+    ['binary storage units', 'The calibration capacity is 1 MiB.', 'The calibration capacity is 1048576 B.', false],
+    ['decimal and binary storage units differ', 'The calibration capacity is 1 MB.', 'The calibration capacity is 1 MiB.', true],
+    ['bits and bytes', 'The calibration capacity is 1 B.', 'The calibration capacity is 8 b.', false],
+    ['megabits and megabytes', 'The calibration capacity is 1 MB.', 'The calibration capacity is 8 Mb.', false],
+    ['case-distinct storage units', 'The calibration capacity is 1 MB.', 'The calibration capacity is 1 Mb.', true],
+    ['opposed storage constraint', 'The calibration capacity is 1 MB.', 'The calibration capacity is not 1000000 B.', true],
+    ['Chinese frequencies', '定标频率是12赫兹。', '定标频率是18赫兹。', true],
+    ['day durations', 'The calibration retention period is 7 days.', 'The calibration retention period is 30 days.', true],
+    ['Chinese day durations', '定标记录保留周期是7天。', '定标记录保留周期是30天。', true],
+    ['opposed exact constraints', 'The calibration rate is 12 Hz.', 'The calibration rate is not 12 Hz.', true],
+    ['Chinese opposed constraints', '定标频率是12赫兹。', '定标频率不是12赫兹。', true],
+    ['compatible negative constraint', 'The calibration rate is not 12 Hz.', 'The calibration rate is 18 Hz.', false],
+    ['two exclusions', 'The calibration rate is not 12 Hz.', 'The calibration rate is not 18 Hz.', false],
+    ['Chinese compatible constraint', '定标频率不是12赫兹。', '定标频率是18赫兹。', false],
+    ['equivalent frequency units', 'The calibration rate is 1 kHz.', 'The calibration rate is 1000 Hz.', false],
+    ['equivalent duration units', 'The calibration duration is 1000 ms.', 'The calibration duration is 1 s.', false],
+    ['equivalent length units', 'The calibration length is 12 mm.', 'The calibration length is 1.2 cm.', false],
+    ['equivalent mass units', 'The calibration mass is 1000 mg.', 'The calibration mass is 1 g.', false],
+    ['equivalent temperature units', 'The calibration temperature is 0 °C.', 'The calibration temperature is 273.15 K.', false],
+    ['incompatible dimensions', 'The calibration reading is 5 s.', 'The calibration reading is 5 m.', false],
+    ['Chinese incompatible dimensions', '定标读数是5赫兹。', '定标读数是5毫秒。', false],
+    ['historical headings', '## Current\nThe calibration duration is 12 ms.', '## Historical\nThe calibration duration is 18 ms.', false],
+    ['environment headings', '## Production\nThe calibration duration is 12 ms.', '## Staging\nThe calibration duration is 18 ms.', false],
+    ['Chinese environment headings', '## 生产环境\n定标时长是12毫秒。', '## 测试环境\n定标时长是18毫秒。', false],
+    ['distinct minor versions', 'The calibration duration is 12 ms for version 1.2.', 'The calibration duration is 18 ms for version 1.3.', false],
+    ['same minor version', 'The calibration duration is 12 ms for version 1.2.', 'The calibration duration is 18 ms for version 1.2.', true],
+    ['different subjects', 'The alpha calibration duration is 12 ms.', 'The beta calibration duration is 18 ms.', false],
+    ['scientific notation', 'The calibration rate is 1e3 Hz.', 'The calibration rate is 2e3 Hz.', true],
+    ['scientific equivalence', 'The calibration rate is 1e3 Hz.', 'The calibration rate is 1000 Hz.', false],
+    ['leading decimal magnitudes', 'The calibration duration is .5 s.', 'The calibration duration is .8 s.', true],
+    ['uncertain magnitude', 'The calibration offset is ±12 ms.', 'The calibration offset is 4 ms.', false],
+    ['range constraint', 'The calibration duration is at least 12 ms.', 'The calibration duration is 18 ms.', false],
+    ['tolerance half-width constraints', 'The calibration tolerance is +/-0.10 mm.', 'The calibration tolerance is +/-0.50 mm.', true],
+    ['equivalent tolerance half-widths', 'The calibration tolerance is ±0.10 mm.', 'The calibration tolerance is 0.01 cm.', false],
+    ['Chinese tolerance half-widths', '定标公差为±0.10毫米。', '定标公差为±0.50毫米。', true],
+    ['postfix uncertainty', 'The calibration duration is 12 ms ± 2 ms.', 'The calibration duration is 18 ms.', false],
+    ['postfix range', 'The calibration duration is 12 ms to 20 ms.', 'The calibration duration is 18 ms.', false],
+    ['unrecognized compound dimension', 'The calibration reading is 5 m/s.', 'The calibration reading is 8 m.', false],
+    ['SI symbol case', 'The calibration reading is 5 µM.', 'The calibration reading is 8 µm.', false],
+    ['tiny distinct magnitudes', 'The calibration length is 1e-10 nm.', 'The calibration length is 2e-10 nm.', true],
+    ['equivalent measured capacity', 'The calibration size is 10 mm.', 'The calibration size is 1 cm.', false],
+    ['explicit distinct years', 'The calibration duration is 12 ms in 2023.', 'The calibration duration is 18 ms in 2024.', false],
+    ['explicit same year', 'The calibration duration is 12 ms in 2024.', 'The calibration duration is 18 ms in 2024.', true],
+    ['Chinese distinct years', '定标时长在2023年是12毫秒。', '定标时长在2024年是18毫秒。', false],
+    ['distinct platforms', 'The calibration duration is 12 ms on Linux.', 'The calibration duration is 18 ms on Windows.', false],
+    ['same platform', 'The calibration duration is 12 ms on Linux.', 'The calibration duration is 18 ms on Linux.', true],
+    ['standalone paragraph qualifiers', 'In production. The calibration duration is 12 ms.', 'In staging. The calibration duration is 18 ms.', false],
+    ['matching paragraph qualifiers', 'In production. The calibration duration is 12 ms.', 'In production. The calibration duration is 18 ms.', true],
+    ['ambiguous environment', 'The calibration duration is 12 ms in production or staging.', 'The calibration duration is 18 ms in production.', false],
+    ['ambiguous heading', '## Production and Staging\nThe calibration duration is 12 ms.', '## Production\nThe calibration duration is 18 ms.', false],
+];
+describe('measurement evidence comparability', () => {
+    test.each(measurements)('%s', async (_name, first, second, conflictExpected) => {
+        const response = await measurementEvidence(first, second);
+        const conflicts = response.trace.ragContextPack?.fragments.filter(fragment => fragment.role === 'conflict') || [];
+        expect(conflicts.length > 0).toBe(conflictExpected);
+        for (const fragment of conflicts) {
+            expect(fragment.citationIds).toHaveLength(2);
+            expect(fragment.sourceBoundary).toBe('full_document');
+        }
+    });
+});

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

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const KnowledgeLearningPlatform_1 = require("./KnowledgeLearningPlatform");
+const AnswerQualityEvaluation_1 = require("./AnswerQualityEvaluation");
+// V3's first confirmation is archived. These observed cases are now regression evidence.
+const corpus = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../fixtures/answer-quality/v3.json'), 'utf8')));
+const cases = corpus.cases.filter(entry => [
+    'cal-dag-en', 'cal-dag-zh', 'cal-retention-en', 'v3-retry-budget-en', 'v3-idempotency-zh',
+    'v3-sets-en', 'v3-index-swap-en', 'v3-memory-fences-en', 'v3-transaction-isolation-zh',
+    'v3-channels-zh', 'v3-checksum-en', 'v3-stable-reference-zh',
+].includes(entry.id));
+const observedV4 = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../fixtures/answer-quality/v4.json'), 'utf8')));
+cases.push(...observedV4.cases.filter(entry => ['v4-receives-en', 'v4-content-addressing-en'].includes(entry.id)));
+const observedV5 = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../fixtures/answer-quality/v5.json'), 'utf8')));
+cases.push(...observedV5.cases.filter(entry => ['v5-iterator-en', 'v5-reentrant-lock-zh', 'v5-replication-zh'].includes(entry.id)));
+const observedV6 = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../fixtures/answer-quality/v6.json'), 'utf8')));
+cases.push(...observedV6.cases.filter(entry => ['v6-locking-en', 'v6-queue-en', 'v6-repeatable-command-en', 'v6-read-isolation-zh'].includes(entry.id)));
+const observedV1 = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../fixtures/answer-quality/v1.json'), 'utf8')));
+const observedV2 = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../fixtures/answer-quality/v2.json'), 'utf8')));
+cases.push(...observedV1.cases.filter(entry => ['eval-capacity-en', 'eval-capacity-zh', 'eval-math-zh'].includes(entry.id)));
+cases.push(...observedV2.cases.filter(entry => entry.id === 'confirm-collections-zh'));
+describe.each(['slim', 'full'])('public answer contracts in %s', responseMode => {
+    test('keeps an unrelated Chinese sentence out after an explicit comparison subject', async () => {
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({ autoPersist: false });
+        await platform.ingestKnowledge({ relationRecomputeMode: 'none', documents: [
+                { documentId: 'mutable', sourcePath: 'quality/mutable.md', content: '# 可变向量\n可变向量允许原地修改元素。火星有两颗卫星。' },
+                { documentId: 'fixed', sourcePath: 'quality/fixed.md', content: '# 不可变向量\n不可变向量不允许原地修改元素。' },
+            ] });
+        const response = await platform.agentConversation({ message: '比较可变向量和不可变向量。', answerLanguage: 'zh', responseMode, persistMemory: false });
+        if (responseMode === 'slim')
+            expect(response.answer).not.toContain('火星');
+        expect(response.answer).toContain('不允许原地修改元素');
+    });
+    test('treats a requested table concept as subject matter', async () => {
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({ autoPersist: false });
+        await platform.ingestKnowledge({ relationRecomputeMode: 'none', documents: [
+                { documentId: 'dispatch-table', sourcePath: 'quality/dispatch.md', content: '# Dispatch Table\nA dispatch table maps operation codes to executable targets.' },
+            ] });
+        const response = await platform.agentConversation({ message: 'What is a dispatch table?', answerLanguage: 'en', responseMode, persistMemory: false });
+        expect(response.answer).toContain('maps operation codes');
+        expect(response.answerReleaseReview?.decision).not.toBe('abstain');
+    });
+    test('keeps a short Chinese definition and its supported constraint', async () => {
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({ autoPersist: false });
+        await platform.ingestKnowledge({ relationRecomputeMode: 'none', documents: [
+                { documentId: 'mutex', sourcePath: 'quality/mutex.md', content: '# 互斥锁\n互斥锁保护临界区。同一时刻只有一个持有者。' },
+            ] });
+        const response = await platform.agentConversation({ message: '什么是互斥锁？', answerLanguage: 'zh', responseMode, persistMemory: false });
+        expect(response.answer).toContain('保护临界区');
+        expect(response.answer).toContain('同一时刻只有一个持有者');
+    });
+    test('rejects an attribute assertion about a different entity', async () => {
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({ autoPersist: false });
+        await platform.ingestKnowledge({ relationRecomputeMode: 'none', documents: [
+                { documentId: 'helium', sourcePath: 'quality/helium.md', content: '# Helium Log\nThe Helium log retention period is 9 days.' },
+            ] });
+        const response = await platform.agentConversation({ message: 'What is the retention period for the Titanium log?', answerLanguage: 'en', responseMode, persistMemory: false });
+        expect(response.answerReleaseReview?.decision).toBe('abstain');
+        expect(response.answer).not.toMatch(/9 days/iu);
+    });
+    test.each(cases)('$id preserves the requested evidence and its ordering', async (entry) => {
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({ autoPersist: false });
+        await platform.ingestKnowledge({ documents: entry.documents, relationRecomputeMode: 'none' });
+        const response = await platform.agentConversation({ message: entry.query, answerLanguage: entry.language, responseMode,
+            persistMemory: false, scope: { documentIds: entry.documents.map(document => document.documentId) } });
+        expect(response.answerReleaseReview?.decision).not.toBe('abstain');
+        for (const fact of entry.reference.facts) {
+            expect({ id: fact.id, covered: fact.patterns.some(pattern => new RegExp(pattern, 'iu').test(response.answer)) })
+                .toEqual({ id: fact.id, covered: true });
+        }
+        for (const claim of entry.reference.unsupportedClaims)
+            expect(response.answer).not.toMatch(new RegExp(claim.pattern, 'iu'));
+        let previousEnd = 0;
+        for (const step of entry.reference.orderedSteps || []) {
+            const match = new RegExp(step, 'iu').exec(response.answer.slice(previousEnd));
+            expect(match).not.toBeNull();
+            previousEnd += match.index + match[0].length;
+        }
+    });
+});

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

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const KnowledgeLearningPlatform_1 = require("./KnowledgeLearningPlatform");
+const regressionCorpus = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../fixtures/answer-quality/v2.json'), 'utf8'));
+async function answer(message, documents, language = 'en') {
+    const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({ autoPersist: false });
+    await platform.ingestKnowledge({ documents, relationRecomputeMode: 'none' });
+    const request = { message, answerLanguage: language, responseMode: 'full', persistMemory: false,
+        scope: { documentIds: documents.map(document => document.documentId) } };
+    return { platform, response: await platform.agentConversation(request) };
+}
+describe('public evidence source selection', () => {
+    test.each(['en', 'zh'])('keeps scoped topic distractors out of the %s answer, citations and required claims', async (language) => {
+        const entry = regressionCorpus.cases.find((candidate) => candidate.id === `confirm-wal-${language}`);
+        const { platform, response } = await answer(entry.query, entry.documents, language);
+        const excludedDocumentId = entry.documents[1].documentId;
+        expect(response.answer).not.toMatch(/cardinals|bird.watching|红雀|观鸟/iu);
+        expect(response.answer).toMatch(language === 'en' ? /durable log.*reconstruct/iu : /持久日志重建/u);
+        expect(response.citations.every(citation => citation.documentId !== excludedDocumentId)).toBe(true);
+        expect(response.answerReleaseReview?.auditGraphAnswerPlan?.claims.every(claim => (claim.evidenceRefs.every(reference => reference.sourcePath !== entry.documents[1].sourcePath)))).toBe(true);
+        expect(response.trace.ragContextPack?.sourceDecisions).toContainEqual(expect.objectContaining({
+            documentId: excludedDocumentId, status: 'fragment_dropped', reason: 'query_subject_mismatch', charsRead: 0,
+        }));
+        const retrieval = await platform.queryKnowledge({ query: entry.query, topK: 12,
+            scope: { documentIds: entry.documents.map((document) => document.documentId) } });
+        expect(retrieval.items.some(item => item.atom.documentId === excludedDocumentId)).toBe(true);
+    });
+    test('retains a second source whose body establishes the requested subject', async () => {
+        const { response } = await answer('Explain recovery point objectives.', [
+            { documentId: 'rpo-definition', sourcePath: 'quality/rpo.md', content: '# Recovery Point Objectives\nA recovery point objective bounds the acceptable age of recovered data.' },
+            { documentId: 'rpo-scheduling', sourcePath: 'quality/schedule.md', content: '# Scheduling Policy\nRecovery point objectives determine how frequently snapshots must be taken.' },
+            { documentId: 'business-objectives', sourcePath: 'quality/business.md', content: '# Business Objectives\nBusiness objectives guide revenue targets and quarterly sales reviews.' },
+        ]);
+        expect(response.answer).toMatch(/acceptable age/iu);
+        expect(response.answer).toMatch(/how frequently snapshots/iu);
+        expect(response.answer).not.toMatch(/revenue|quarterly sales/iu);
+        expect(response.citations.map(citation => citation.documentId)).toEqual(expect.arrayContaining(['rpo-definition', 'rpo-scheduling']));
+    });
+    test('retains both comparison operands while rejecting a shared-word distractor', async () => {
+        const { response } = await answer('Compare an exclusive lock and a shared lock.', [
+            { documentId: 'exclusive', sourcePath: 'quality/exclusive.md', content: '# Exclusive Lock\nAn exclusive lock permits only one owner to access the protected resource.' },
+            { documentId: 'shared', sourcePath: 'quality/shared.md', content: '# Shared Lock\nA shared lock permits several readers to access the protected resource concurrently.' },
+            { documentId: 'door', sourcePath: 'quality/door.md', content: '# Door Lock\nA door lock may be painted bright yellow to match a wooden door.' },
+        ]);
+        expect(response.answer).toMatch(/only one owner/iu);
+        expect(response.answer).toMatch(/several readers/iu);
+        expect(response.answer).not.toMatch(/bright yellow|wooden door/iu);
+        expect(response.citations.map(citation => citation.documentId)).not.toContain('door');
+    });
+    test('does not choose a winner among competing observations of the same subject', async () => {
+        const { response } = await answer('What is the Echo clock rate?', [
+            { documentId: 'echo-a', sourcePath: 'quality/echo-a.md', content: '# Echo Clock Rate\nThe Echo clock rate is 4 Hz.' },
+            { documentId: 'echo-b', sourcePath: 'quality/echo-b.md', content: '# Echo Clock Rate Record\nThe Echo clock rate is 9 Hz.' },
+        ]);
+        expect(response.answer).toMatch(/4\s*Hz/iu);
+        expect(response.answer).toMatch(/9\s*Hz/iu);
+        expect(response.citations.map(citation => citation.documentId)).toEqual(expect.arrayContaining(['echo-a', 'echo-b']));
+    });
+});

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const KnowledgeLearningPlatform_1 = require("./KnowledgeLearningPlatform");
+const agentConversationSerialization_1 = require("./agentConversationSerialization");
+async function answerMeasurements(request, first, second) {
+    const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({ autoPersist: false });
+    await platform.ingestKnowledge({ relationRecomputeMode: 'none', documents: [
+            { documentId: 'clock-primary', sourcePath: 'quality/clock-primary.md', content: first },
+            { documentId: 'clock-secondary', sourcePath: 'quality/clock-secondary.md', content: second },
+        ] });
+    return platform.agentConversation({ ...request, persistMemory: false });
+}
+describe('public measurement conflict disclosure', () => {
+    test.each(['slim', 'full'])('keeps conflicting English observations and their citations in %s', async (responseMode) => {
+        const response = await answerMeasurements({ message: 'What is the Echo clock rate?', answerLanguage: 'en', responseMode }, '# Echo Clock Rate\nThe Echo clock rate is 4 Hz.', '# Echo Clock Rate Record\nThe Echo clock rate is 9 Hz.');
+        expect(response.trace.ragContextPack?.fragments.some(fragment => fragment.role === 'conflict')).toBe(true);
+        expect(response.answer).toMatch(/4\s*Hz/iu);
+        expect(response.answer).toMatch(/9\s*Hz/iu);
+        expect(response.answer).toMatch(/conflict|contradict|disagree/iu);
+        expect(response.citations.map(citation => citation.documentId)).toEqual(expect.arrayContaining(['clock-primary', 'clock-secondary']));
+        expect(response.answerReleaseReview?.decision).not.toBe('abstain');
+    });
+    test.each(['slim', 'full'])('keeps conflicting Chinese observations and their citations in %s', async (responseMode) => {
+        const response = await answerMeasurements({ message: '回声时钟频率是多少？', answerLanguage: 'zh', responseMode }, '# 回声时钟频率\n回声时钟频率是4赫兹。', '# 回声时钟频率记录\n回声时钟频率是9赫兹。');
+        expect(response.trace.ragContextPack?.fragments.some(fragment => fragment.role === 'conflict')).toBe(true);
+        expect(response.answer).toContain('4赫兹');
+        expect(response.answer).toContain('9赫兹');
+        expect(response.answer).toMatch(/冲突|矛盾|不一致/u);
+        expect(response.citations.map(citation => citation.documentId)).toEqual(expect.arrayContaining(['clock-primary', 'clock-secondary']));
+        expect(response.answerReleaseReview?.decision).not.toBe('abstain');
+    });
+    test.each(['slim', 'full'])('does not manufacture conflicts between equivalent observations in %s', async (responseMode) => {
+        const response = await answerMeasurements({ message: 'What is the Echo clock rate?', answerLanguage: 'en', responseMode }, '# Echo Clock Rate\nThe Echo clock rate is 1 kHz.', '# Echo Clock Rate Record\nThe Echo clock rate is 1000 Hz.');
+        expect(response.trace.ragContextPack?.fragments.some(fragment => fragment.role === 'conflict')).toBe(false);
+        expect(response.answer).not.toMatch(/conflict|contradict|disagree/iu);
+        expect(response.answer).toMatch(/(?:1\s*kHz|1000\s*Hz)/iu);
+        expect(response.answerReleaseReview?.decision).not.toBe('abstain');
+    });
+    test('retains the same conflict and citations through bounded JSON, SSE and replay', async () => {
+        const response = await answerMeasurements({ message: 'What is the Echo clock rate?', answerLanguage: 'en', responseMode: 'full' }, '# Echo Clock Rate\nThe Echo clock rate is 4 Hz.', '# Echo Clock Rate Record\nThe Echo clock rate is 9 Hz.');
+        response.responseBudget.runtimeGovernor.maxSerializedBytes = 6000;
+        const http = (0, agentConversationSerialization_1.serializeAgentConversationHttpResponse)(response);
+        const event = { type: 'turn_completed', turnId: 'conflict-disclosure', emittedAt: '2026-09-13T00:00:00.000Z', result: response };
+        const live = (0, agentConversationSerialization_1.serializeAgentConversationTurnEvent)('turn_completed', event);
+        const replay = (0, agentConversationSerialization_1.serializeAgentConversationTurnEvent)('turn_completed', { ...event, result: http.result });
+        expect(http.truncated).toBe(true);
+        expect(JSON.parse(live.json).result).toEqual(http.result);
+        expect(JSON.parse(replay.json).result).toEqual(http.result);
+        expect(http.result.answer).toMatch(/observations conflict/iu);
+        expect(http.result.answer).toMatch(/4\s*Hz/iu);
+        expect(http.result.answer).toMatch(/9\s*Hz/iu);
+        expect(http.result.citations.map(citation => citation.documentId)).toEqual(expect.arrayContaining(['clock-primary', 'clock-secondary']));
+    });
+});

package/dist/src/learning/agentConversationExecution.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentConversationExecution = exports.AgentConversationExecutionError = exports.DEFAULT_AGENT_CONVERSATION_EXECUTION_POLICY = void 0;
+exports.normalizeAgentConversationExecutionPolicy = normalizeAgentConversationExecutionPolicy;
+const promises_1 = require("fs/promises");
+const async_hooks_1 = require("async_hooks");
+const agentResponseBudget_1 = require("./agentResponseBudget");
+exports.DEFAULT_AGENT_CONVERSATION_EXECUTION_POLICY = Object.freeze({
+    timeoutMs: 180000,
+    maxSourceBytes: 4 * 1024 * 1024,
+    maxTotalSourceBytes: 16 * 1024 * 1024,
+    maxPendingTurns: 8,
+    maxSourceLines: 16384,
+    maxSourceFacts: 4096,
+});
+class AgentConversationExecutionError extends Error {
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'AgentConversationExecutionError';
+        this.statusCode = code === 'runtime_turn_capacity' ? 429
+            : code === 'runtime_timeout' ? 504
+                : code === 'runtime_cancelled' ? 499 : 413;
+    }
+}
+exports.AgentConversationExecutionError = AgentConversationExecutionError;
+function normalizeAgentConversationExecutionPolicy(input = {}) {
+    const policy = { ...exports.DEFAULT_AGENT_CONVERSATION_EXECUTION_POLICY };
+    for (const key of Object.keys(policy)) {
+        const candidate = input[key];
+        if (candidate === undefined)
+            continue;
+        if (!Number.isFinite(candidate) || candidate < 1) {
+            throw new TypeError(`Invalid agent conversation execution policy: ${key}`);
+        }
+        policy[key] = Math.min(policy[key], Math.floor(candidate));
+    }
+    policy.maxSourceBytes = Math.min(policy.maxSourceBytes, policy.maxTotalSourceBytes);
+    return policy;
+}
+/** Owns one turn's cooperative deadline and bounded source I/O, including queued time. */
+class AgentConversationExecution {
+    constructor(budget, policy, parentSignal) {
+        this.budget = budget;
+        this.policy = policy;
+        this.parentSignal = parentSignal;
+        this.active = true;
+        this.controller = new AbortController();
+        this.startedAtMs = Date.now();
+        this.sourceBytes = 0;
+        this.sourceReads = 0;
+        this.processedFragments = 0;
+        this.sourceFacts = 0;
+        this.timeoutMs = Math.min(policy.timeoutMs, budget.runtimeGovernor.timeoutMs);
+        this.budget = { ...budget, runtimeGovernor: { ...budget.runtimeGovernor, timeoutMs: this.timeoutMs } };
+        this.onParentAbort = () => this.controller.abort(new AgentConversationExecutionError('runtime_cancelled'));
+        this.timer = setTimeout(() => {
+            this.controller.abort(new AgentConversationExecutionError('runtime_timeout'));
+        }, this.timeoutMs);
+        this.timer.unref();
+        if (parentSignal?.aborted)
+            this.onParentAbort();
+        else
+            parentSignal?.addEventListener('abort', this.onParentAbort, { once: true });
+    }
+    static async run(options, operation) {
+        const existing = this.current();
+        if (existing) {
+            existing.assertActive();
+            return operation(existing);
+        }
+        const execution = new AgentConversationExecution(options.budget, options.policy, options.signal);
+        try {
+            execution.assertActive();
+            // Keep the state lease until cooperative work has actually stopped.
+            // Racing an uncancelled promise would allow it to mutate a later turn.
+            return await this.scope.run(execution, () => operation(execution));
+        }
+        finally {
+            execution.active = false;
+            clearTimeout(execution.timer);
+            options.signal?.removeEventListener('abort', execution.onParentAbort);
+        }
+    }
+    get signal() { return this.controller.signal; }
+    get maxFragmentChars() { return this.budget.rag.maxCharsPerFragment; }
+    get truncationReason() { return this.sourceStop; }
+    static current() {
+        const execution = this.scope.getStore();
+        return execution?.active ? execution : undefined;
+    }
+    isResourceLimit(error) {
+        return error instanceof AgentConversationExecutionError && (error.code === 'runtime_source_bytes_limit'
+            || error.code === 'runtime_total_source_bytes_limit'
+            || error.code === 'runtime_fragment_limit'
+            || error.code === 'runtime_source_lines_limit'
+            || error.code === 'runtime_source_facts_limit');
+    }
+    assertActive() {
+        if (!this.active)
+            throw new AgentConversationExecutionError('runtime_cancelled');
+        if (this.signal.aborted)
+            throw this.signal.reason;
+        const decision = (0, agentResponseBudget_1.applyRuntimeGovernor)({
+            budget: this.budget,
+            startedAtMs: this.startedAtMs, nowMs: Date.now(),
+            processedFragments: this.processedFragments, serializedBytes: 0, reportChars: 0,
+        });
+        if (!decision.allowed) {
+            const code = decision.reason === 'runtime_timeout' ? 'runtime_timeout' : 'runtime_fragment_limit';
+            throw new AgentConversationExecutionError(code);
+        }
+    }
+    async yieldCheckpoint() {
+        this.assertActive();
+        await new Promise(resolve => setImmediate(resolve));
+        this.assertActive();
+    }
+    recordFragment() {
+        if (this.processedFragments >= this.budget.runtimeGovernor.maxFragmentsProcessed) {
+            this.sourceStop = 'runtime_fragment_limit';
+            throw new AgentConversationExecutionError(this.sourceStop);
+        }
+        this.processedFragments++;
+        this.assertActive();
+    }
+    checkSourceLineCount(count) {
+        this.assertActive();
+        if (count > this.policy.maxSourceLines) {
+            this.sourceStop = 'runtime_source_lines_limit';
+            throw new AgentConversationExecutionError(this.sourceStop);
+        }
+    }
+    recordSourceFact() {
+        this.assertActive();
+        if (this.sourceFacts >= this.policy.maxSourceFacts) {
+            this.sourceStop = 'runtime_source_facts_limit';
+            throw new AgentConversationExecutionError(this.sourceStop);
+        }
+        this.sourceFacts++;
+    }
+    acceptSourceText(content) {
+        this.assertActive();
+        const bytes = Buffer.byteLength(content, 'utf8');
+        this.assertSourceFits(bytes, bytes);
+        this.sourceBytes += bytes;
+        this.sourceReads++;
+        return content;
+    }
+    async readSourceFile(filePath) {
+        this.assertActive();
+        const file = await (0, promises_1.open)(filePath, 'r');
+        try {
+            this.assertActive();
+            const stat = await file.stat();
+            if (!stat.isFile())
+                return null;
+            this.assertSourceFits(stat.size, stat.size);
+            const chunks = [];
+            let fileBytes = 0;
+            const stream = file.createReadStream({ autoClose: false, highWaterMark: 64 * 1024, signal: this.signal });
+            try {
+                for await (const chunk of stream) {
+                    this.assertActive();
+                    const bytes = chunk;
+                    fileBytes += bytes.length;
+                    // Check actual bytes too: the file can grow after stat().
+                    this.assertSourceFits(fileBytes, bytes.length);
+                    this.sourceBytes += bytes.length;
+                    chunks.push(bytes);
+                }
+            }
+            catch (error) {
+                this.assertActive();
+                throw error;
+            }
+            this.sourceReads++;
+            return Buffer.concat(chunks, fileBytes).toString('utf8');
+        }
+        finally {
+            await file.close();
+        }
+    }
+    diagnostics() {
+        return {
+            elapsedMs: Math.max(0, Date.now() - this.startedAtMs),
+            timeoutMs: this.timeoutMs,
+            maxSourceBytes: this.policy.maxSourceBytes,
+            maxTotalSourceBytes: this.policy.maxTotalSourceBytes,
+            sourceBytes: this.sourceBytes,
+            sourceReads: this.sourceReads,
+            processedFragments: this.processedFragments,
+            maxSourceLines: this.policy.maxSourceLines,
+            maxSourceFacts: this.policy.maxSourceFacts,
+            sourceFacts: this.sourceFacts,
+            ...(this.sourceStop ? { truncationReason: this.sourceStop } : {}),
+        };
+    }
+    assertSourceFits(fileBytes, additionalBytes) {
+        if (fileBytes > this.policy.maxSourceBytes) {
+            this.sourceStop = 'runtime_source_bytes_limit';
+            throw new AgentConversationExecutionError(this.sourceStop);
+        }
+        if (this.sourceBytes + additionalBytes > this.policy.maxTotalSourceBytes) {
+            this.sourceStop = 'runtime_total_source_bytes_limit';
+            throw new AgentConversationExecutionError(this.sourceStop);
+        }
+    }
+}
+exports.AgentConversationExecution = AgentConversationExecution;
+AgentConversationExecution.scope = new async_hooks_1.AsyncLocalStorage();