noteconnection 1.8.0 → 1.9.0

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

@@ -44,6 +44,70 @@ describe('KnowledgeLearningPlatform', () => {
         nowIso = '2026-03-31T08:00:00.000Z';
         platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform(() => new Date(nowIso));
     });
+    test('resolves adaptive full budgets from validated host capability and projects mobile to slim', async () => {
+        const extendedPlatform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({
+            nowProvider: () => new Date(nowIso),
+            autoPersist: false,
+            responseBudgetCapability: { memoryClass: 'high', workload: 'large' },
+        });
+        await extendedPlatform.ingestKnowledge({
+            incremental: true,
+            documents: [{
+                    documentId: 'doc_adaptive_budget_probe',
+                    sourcePath: 'Knowledge_Base/adaptive/budget-probe.md',
+                    workspaceId: 'adaptive',
+                    corpusId: 'adaptive',
+                    language: 'en',
+                    content: '# Adaptive Budget Probe\n\nA bounded report budget should select the extended tier for a large high-memory host.',
+                }],
+        });
+        const extendedResponse = await extendedPlatform.agentConversation({
+            userId: 'adaptive-budget-user',
+            sessionId: 'adaptive-budget-extended',
+            message: 'what is adaptive budget probe?',
+            responseMode: 'full',
+            persistMemory: false,
+            scope: {
+                workspaceId: 'adaptive',
+                corpusId: 'adaptive',
+                sourcePathPrefixes: ['Knowledge_Base/adaptive'],
+            },
+        });
+        expect(extendedResponse.responseBudget?.tier).toBe('extended');
+        expect(extendedResponse.trace.responseBudget?.rag?.maxFragments).toBe(160);
+        expect(extendedResponse.summary.responseBudgetTier).toBe('extended');
+        const maxPlatform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform({
+            nowProvider: () => new Date(nowIso),
+            autoPersist: false,
+            responseBudgetCapability: { memoryClass: 'high', workload: 'max' },
+        });
+        const maxResponse = await maxPlatform.agentConversation({
+            userId: 'adaptive-budget-user',
+            sessionId: 'adaptive-budget-max',
+            message: 'what is adaptive budget probe?',
+            responseMode: 'full',
+            persistMemory: false,
+        });
+        expect(maxResponse.responseBudget?.tier).toBe('max');
+        expect(maxResponse.responseBudget?.reportMaxChars).toBe(160000);
+        const mobileResponse = await extendedPlatform.agentConversation({
+            userId: 'adaptive-budget-user',
+            sessionId: 'adaptive-budget-mobile',
+            message: 'what is adaptive budget probe?',
+            responseMode: 'full',
+            responseBudgetMode: 'unbounded',
+            responseProfile: 'mobile_compact',
+            persistMemory: false,
+            scope: {
+                workspaceId: 'adaptive',
+                corpusId: 'adaptive',
+                sourcePathPrefixes: ['Knowledge_Base/adaptive'],
+            },
+        });
+        expect(mobileResponse.responseMode).toBe('slim');
+        expect(mobileResponse.responseBudget?.tier).toBe('standard');
+        expect(mobileResponse.responseBudget?.productCapDisabled).toBe(false);
+    });
     test('ingest supports staleness detection and temporal supersede edges', async () => {
         const firstIngest = await platform.ingestKnowledge({
             incremental: true,
@@ -279,6 +343,104 @@ describe('KnowledgeLearningPlatform', () => {
         expect(queryResult.trace.latencyMs).toBeGreaterThanOrEqual(0);
         expect(queryResult.trace.evidenceCoverageRatio).toBeGreaterThan(0);
     });
+    test('workspace inspection exposes an additive source inventory for hydration reconciliation', async () => {
+        await platform.ingestKnowledge({
+            incremental: true,
+            documents: [
+                {
+                    documentId: 'doc_inventory_a',
+                    sourcePath: 'Knowledge_Base/waterglass/water-glass.md',
+                    language: 'en',
+                    content: '# Water Glass\nA scoped source.',
+                },
+                {
+                    documentId: 'doc_inventory_b',
+                    sourcePath: 'Knowledge_Base/waterglass/Amorphous ice.md',
+                    language: 'zh',
+                    content: '## 非晶冰\nAmorphous ice is an amorphous solid water phase.',
+                },
+            ],
+        });
+        const inspection = await platform.inspectKnowledgeWorkspaceRequest({
+            query: '非晶冰',
+            scope: {
+                sourcePathPrefixes: ['Knowledge_Base/waterglass'],
+            },
+            includeSourceInventory: true,
+        });
+        expect(inspection.sourceInventory).toEqual(expect.objectContaining({
+            documentCount: 2,
+            sourcePaths: expect.arrayContaining([
+                'Knowledge_Base/waterglass/water-glass.md',
+                'Knowledge_Base/waterglass/Amorphous ice.md',
+            ]),
+        }));
+    });
+    test('query planner resolves a Chinese section title inside an English-named source document', async () => {
+        await platform.ingestKnowledge({
+            incremental: true,
+            documents: [{
+                    documentId: 'doc_amorphous_ice',
+                    sourcePath: 'Knowledge_Base/waterglass/Amorphous ice.md',
+                    language: 'zh',
+                    content: [
+                        '## 非晶冰',
+                        '非晶冰（Amorphous ice）是水的一种固态形式。',
+                        '',
+                        '### 核心概念与数学基础',
+                        '其结构可用 $g(r)$ 描述。',
+                    ].join('\n'),
+                }],
+        });
+        const queryResult = await platform.queryKnowledge({
+            query: '什么是非晶冰？我应该通过哪些知识点学习？',
+            topK: 4,
+            scope: {
+                sourcePathPrefixes: ['Knowledge_Base/waterglass'],
+            },
+        });
+        expect(queryResult.trace.planner?.titleHitDocumentIds).toContain('doc_amorphous_ice');
+        expect(queryResult.items[0]?.atom.title).toBe('非晶冰');
+    });
+    test('compound agent conversation releases a complete subject definition with math markup', async () => {
+        const content = [
+            '## 非晶冰',
+            '非晶冰（Amorphous ice）是水的一种固态形式，其分子排列缺乏长程有序结构。',
+            '',
+            '### 核心概念与数学基础',
+            '其结构可用径向分布函数 $g(r)$ 描述。',
+            '',
+            '对于由 N 个粒子组成的系统：',
+            '$$ g(r) = \\frac{V}{N^2} \\left\\langle \\sum_{i=1}^{N} \\sum_{j \\ne i}^{N} \\delta(\\mathbf{r} - (\\mathbf{r}_i - \\mathbf{r}_j)) \\right\\rangle $$',
+        ].join('\n');
+        await platform.ingestKnowledge({
+            incremental: true,
+            documents: [{
+                    documentId: 'doc_compound_amorphous_ice',
+                    sourcePath: 'Knowledge_Base/waterglass/Amorphous ice.md',
+                    language: 'zh',
+                    content,
+                }],
+        });
+        const response = await platform.agentConversation({
+            userId: 'compound_answer_user',
+            sessionId: 'compound_answer_session',
+            message: '什么是非晶冰？我应该通过哪些知识点学习？',
+            answerLanguage: 'zh',
+            topK: 8,
+            persistMemory: false,
+            scope: {
+                sourcePathPrefixes: ['Knowledge_Base/waterglass'],
+            },
+        });
+        expect(response.answer).toContain('非晶冰（Amorphous ice）是水的一种固态形式');
+        expect(response.answer).toContain('$g(r)$');
+        expect(response.answer).toContain('$$');
+        expect(response.answer).not.toMatch(/###\s+(?!建议学习路径)/u);
+        expect(response.answer).not.toContain('标');
+        expect(response.answer).not.toContain('水杯');
+        expect(response.answerReleaseReview?.decision).not.toBe('abstain');
+    });
     test('query temporal validity preserves supersession edge details after document updates', async () => {
         await platform.ingestKnowledge({
             incremental: true,
@@ -1580,22 +1742,22 @@ describe('KnowledgeLearningPlatform', () => {
         }));
         expect(structuredBlock && 'overviewMarkdown' in structuredBlock
             ? String(structuredBlock.overviewMarkdown || '')
-            : '').toContain('## Answer Context');
+            : '').toContain('## 回答上下文');
         expect(structuredBlock && 'explanationMarkdown' in structuredBlock
             ? String(structuredBlock.explanationMarkdown || '')
-            : '').toContain('## Explanation');
+            : '').toContain('## 说明');
         expect(structuredBlock && 'evidenceMarkdown' in structuredBlock
             ? String(structuredBlock.evidenceMarkdown || '')
-            : '').toContain('## Evidence Summary');
+            : '').toContain('## 证据摘要');
         expect(structuredBlock && 'explanationMarkdown' in structuredBlock
             ? String(structuredBlock.explanationMarkdown || '')
-            : '').toContain('best scoped anchor');
+            : '').toContain('最佳范围锚点');
         expect(structuredBlock && 'nextActionsMarkdown' in structuredBlock
             ? String(structuredBlock.nextActionsMarkdown || '')
-            : '').toContain('## Next Actions');
+            : '').toContain('## 下一步行动');
         expect(structuredBlock && 'nextActionsMarkdown' in structuredBlock
             ? String(structuredBlock.nextActionsMarkdown || '')
-            : '').toContain('Persist the latest user focus to scoped conversation memory');
+            : '').toContain('记录本回合的用户关注点');
         expect(response.trace.usedScope.corpusId).toBe('optics');
         expect(response.summary.appliedMemoryCount).toBeGreaterThan(0);
         const persistedMemory = await platform.searchConversationMemory({
@@ -1644,10 +1806,36 @@ describe('KnowledgeLearningPlatform', () => {
             persistMemory: false,
         });
         expect(response.answer).toMatch(/^A water glass is/i);
+        expect(response.answer).toContain('soda-lime glass');
+        expect(response.answer).toContain('conduction and convection');
         expect(response.answer).not.toContain('The strongest scoped match is');
         expect(response.knowledgePoints).toHaveLength(1);
         expect(response.summary.returnedKnowledgePoints).toBe(1);
         expect(response.citations.length).toBeGreaterThanOrEqual(2);
+        expect(response.graphAnswerPlan).toEqual(expect.objectContaining({
+            intent: 'definition',
+            anchorAtomId: expect.any(String),
+        }));
+        expect(response.graphAnswerPlan?.requiredRoles).toEqual(expect.arrayContaining([
+            'definition',
+            'boundary',
+            'mechanism',
+        ]));
+        expect(response.graphAnswerCoverage).toEqual(expect.objectContaining({
+            passed: true,
+            missingRequiredClaimIds: [],
+            coverageScore: 1,
+        }));
+        expect(response.graphAnswerPlan).toEqual(response.answerReleaseReview?.publicGraphAnswerPlan);
+        expect(response.graphAnswerCoverage).toEqual(response.answerReleaseReview?.graphAnswerCoverage);
+        expect(response.knowledgeRun?.graphAnswerPlan).toEqual(response.graphAnswerPlan);
+        expect(response.knowledgeRun?.graphAnswerCoverage).toEqual(response.graphAnswerCoverage);
+        expect(response.trace.graphAnswerPlan).toEqual(response.graphAnswerPlan);
+        expect(response.trace.graphAnswerCoverage).toEqual(response.graphAnswerCoverage);
+        expect(response.trace.ragContextPack?.graphConditioning).toEqual(expect.objectContaining({
+            strategy: 'graph_answer_plan',
+            matchedClaimCount: expect.any(Number),
+        }));
         const groupedPoint = response.knowledgePoints[0];
         expect(groupedPoint.title).toBe('Water Glass');
         expect(groupedPoint.documentId).toBe('doc_water_glass_grouped');
@@ -1657,6 +1845,35 @@ describe('KnowledgeLearningPlatform', () => {
         expect(groupedPoint.citations.length).toBeGreaterThanOrEqual(2);
         expect(new Set(groupedPoint.citations.map((citation) => citation.documentId))).toEqual(new Set(['doc_water_glass_grouped']));
     });
+    test('agent conversation fails closed when a semantically adjacent document is not the requested subject', async () => {
+        await platform.ingestKnowledge({
+            incremental: true,
+            documents: [
+                {
+                    documentId: 'doc_water_glass_adjacent',
+                    sourcePath: 'Knowledge_Base/waterglass/water glass.md',
+                    language: 'zh',
+                    content: [
+                        '# 水杯 (water glass)',
+                        '水杯是由透明非晶态玻璃和水组成的容器。',
+                        '玻璃的非晶态结构影响其光学与热学性质。',
+                    ].join('\n'),
+                },
+            ],
+        });
+        const response = await platform.agentConversation({
+            userId: 'agent_subject_drift_user',
+            sessionId: 'session_subject_drift',
+            message: '什么是非晶冰？我应该通过哪些知识点学习？',
+            topK: 8,
+            persistMemory: false,
+        });
+        expect(response.answer).toContain('非晶冰');
+        expect(response.answer).not.toContain('水杯是由透明非晶态玻璃和水组成的容器');
+        expect(response.answerReleaseReview?.decision).toBe('abstain');
+        expect(response.answerReleaseReview?.failedGateIds).toContain('query_subject_alignment');
+        expect(response.answerReleaseReview?.publicGraphAnswerPlan?.claims || []).toHaveLength(0);
+    });
     test('agent conversation recovers a title-like knowledge point when the active scope misses another corpus', async () => {
         await platform.ingestKnowledge({
             incremental: true,
@@ -1827,6 +2044,8 @@ describe('KnowledgeLearningPlatform', () => {
                 usedFallback: true,
             }),
         }));
+        expect(knowledgeRunArtifact?.payload?.graphAnswerPlan).toEqual(knowledgeRunArtifact?.payload?.answerReleaseReview?.publicGraphAnswerPlan);
+        expect(knowledgeRunArtifact?.payload?.graphAnswerCoverage).toEqual(knowledgeRunArtifact?.payload?.answerReleaseReview?.graphAnswerCoverage);
         const reviewCards = (flashcardArtifact?.payload || {}).reviewCards || [];
         expect(reviewCards).toHaveLength(1);
         const followUp = await platform.executeWorkflowArtifactReviewFollowUp({
@@ -2323,6 +2542,24 @@ describe('KnowledgeLearningPlatform', () => {
         });
         expect(causalResponse.trace.ragContextPack?.sourceBoundary).toBe('full_document');
         expect(deepResponse.trace.ragContextPack?.sourceBoundary).toBe('full_document');
+        expect(baseResponse.trace.graphExpansion).toEqual({
+            enabled: false,
+            reason: 'ordinary_query',
+            maxSteps: 0,
+            executedSteps: 0,
+            maxNeighbors: 6,
+            selectedNeighborCount: 0,
+            maxPathDepth: 6,
+        });
+        expect(deepResponse.trace.graphExpansion).toEqual(expect.objectContaining({
+            enabled: true,
+            reason: 'explicit_depth_request',
+            maxSteps: 1,
+            maxNeighbors: 8,
+            maxPathDepth: 8,
+        }));
+        expect(deepResponse.trace.graphExpansion?.executedSteps).toBeLessThanOrEqual(1);
+        expect(deepResponse.trace.graphExpansion?.selectedNeighborCount).toBeLessThanOrEqual(8);
     });
     test('agent conversation uses optional LLM sufficiency judge for borderline legacy source windows', async () => {
         const savedAt = '2026-07-05T00:00:00.000Z';

package/dist/src/learning/KnowledgeWorkspaceConversationRegression.js

@@ -33,6 +33,7 @@ exports.KNOWLEDGE_WORKSPACE_CONVERSATION_REGRESSION_CASES = freezeRegressionCase
         preloadTargets: ['waterglass'],
         activeTarget: 'waterglass',
         query: '什么是waterglass?',
+        answerLanguage: 'zh',
         expected: {
             minCitations: 1,
             scopeSource: 'explicit_request',
@@ -52,10 +53,21 @@ exports.KNOWLEDGE_WORKSPACE_CONVERSATION_REGRESSION_CASES = freezeRegressionCase
                 '遵从您的要求',
                 'all reasoning',
                 'final output',
+                '下表列出了',
+                '参数 (Parameter)',
+                ':---',
+                'PET Plastic Cup',
+                'Metal Cup',
+                'Context pa',
+                'Comparison of Fluid Containment Technologies',
+                'subsequent branch',
+                '核心概念及其数学基础',
             ],
             ragSourceBoundary: 'full_document',
             requiredRagRoles: ['direct_support', 'parent_context', 'graph_neighbor_support'],
             acceptedRagSufficiencyStatuses: ['sufficient', 'borderline'],
+            requireCompleteGraphAnswerCoverage: true,
+            requireGraphAnswerPlanOrder: true,
         },
     },
     {
@@ -64,6 +76,7 @@ exports.KNOWLEDGE_WORKSPACE_CONVERSATION_REGRESSION_CASES = freezeRegressionCase
         preloadTargets: ['waterglass'],
         activeTarget: 'waterglass',
         query: '什么是water glass',
+        answerLanguage: 'zh',
         expected: {
             minCitations: 1,
             scopeSource: 'explicit_request',
@@ -83,10 +96,16 @@ exports.KNOWLEDGE_WORKSPACE_CONVERSATION_REGRESSION_CASES = freezeRegressionCase
                 '遵从您的要求',
                 'all reasoning',
                 'final output',
+                '下表列出了',
+                '参数 (Parameter)',
+                ':---',
+                '核心概念及其数学基础',
             ],
             ragSourceBoundary: 'full_document',
             requiredRagRoles: ['direct_support', 'parent_context', 'graph_neighbor_support'],
             acceptedRagSufficiencyStatuses: ['sufficient', 'borderline'],
+            requireCompleteGraphAnswerCoverage: true,
+            requireGraphAnswerPlanOrder: true,
         },
     },
     {
@@ -101,15 +120,20 @@ exports.KNOWLEDGE_WORKSPACE_CONVERSATION_REGRESSION_CASES = freezeRegressionCase
             acceptedAnswerReleaseDecisions: ['release', 'revise'],
             plannerTitleLikeQueries: ['water glass', 'plastic cup'],
             primarySourcePath: 'Knowledge_Base/waterglass/water glass.md',
-            answerMustContain: ['glass', 'plastic'],
+            answerMustCoverConcepts: ['glass_material', 'plastic'],
             answerMustNotContain: [
                 'No scoped knowledge points matched',
                 'retrieval_candidates_below_threshold',
+                '消色差透镜',
+                '数学优化',
             ],
             ragSourceBoundary: 'full_document',
             requiredRagRoles: ['direct_support', 'parent_context', 'graph_neighbor_support'],
             acceptedRagSufficiencyStatuses: ['sufficient', 'borderline'],
             requireScopedDocumentIds: false,
+            requireCompleteGraphAnswerCoverage: true,
+            requireGraphAnswerPlanOrder: true,
+            requiredGraphAnswerRoles: ['contrast'],
         },
     },
     {

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

@@ -44,6 +44,7 @@ function deriveScopedConversationRequest(caseEntry) {
         userId: `regression_user_${caseEntry.id}`,
         sessionId: `regression_session_${caseEntry.id}`,
         message: caseEntry.query,
+        answerLanguage: caseEntry.answerLanguage || 'auto',
         persistMemory: false,
         topK: Number.isInteger(caseEntry.topK) && Number(caseEntry.topK) > 0
             ? Number(caseEntry.topK)
@@ -2681,11 +2682,8 @@ describe('KnowledgeWorkspaceConversationRegression', () => {
     });
     test('registers waterglass RAG claim-gate and preamble-leak runtime acceptance', () => {
         const expectedWaterglassReleaseAcceptance = expect.objectContaining({
-            runtimeAnswerReleaseDecision: 'revise',
-            runtimeRequiredFailedGateIds: expect.arrayContaining([
-                'query_intent_alignment',
-                'rag_claim_citation_support',
-            ]),
+            requireCompleteGraphAnswerCoverage: true,
+            requireGraphAnswerPlanOrder: true,
             answerMustNotContain: expect.arrayContaining([
                 '所有推理过程',
                 '最终输出',
@@ -3813,6 +3811,16 @@ describe('KnowledgeWorkspaceConversationRegression', () => {
             expected.answerMustNotContain?.forEach((fragment) => {
                 expect(response.answer).not.toContain(fragment);
             });
+            if (caseEntry.id.startsWith('waterglass_explicit_scope_')) {
+                const publicAnswer = String(response.answer || '');
+                expect(publicAnswer).not.toMatch(/(?:Plastic Cup|Metal Cup|Comparison of Fluid Containment|Context pa|紧邻前置节点包括|后续分支包括)/iu);
+                expect(publicAnswer).not.toMatch(/\.\.\.$|(?:and|or|with|between|from|to|is|are|以及|并且|其中|通常在|范围为|分别为|性能)\s*$/iu);
+                expect(publicAnswer).not.toContain('```');
+                expect((publicAnswer.match(/(?<!\\)\$/gu) || []).length % 2).toBe(0);
+                expect((publicAnswer.match(/(?<!\\)\$\$/gu) || []).length % 2).toBe(0);
+                expect(response.assistantBlocks?.filter((block) => block.type === 'structured_answer')).toHaveLength(1);
+                expect(response.assistantBlocks?.find((block) => block.type === 'structured_answer')).toEqual(expect.objectContaining({ directAnswer: response.answer }));
+            }
             if (expected.ragSourceBoundary) {
                 expect(response.trace.ragContextPack).toEqual(expect.objectContaining({
                     sourceBoundary: expected.ragSourceBoundary,

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;
+        }
+    });
+});