noteconnection 1.7.0 → 1.9.0

package/dist/src/knowledge_projection.contract.test.js

@@ -0,0 +1,134 @@
+"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 path = __importStar(require("path"));
+const contract = require(path.resolve(__dirname, 'frontend', 'knowledge_projection_contract.js'));
+describe('versioned knowledge projection contract', () => {
+    test('creates a body-free projection with identity, provenance, evidence, and bounded adjacency', () => {
+        const projection = contract.createKnowledgeProjection({
+            nodes: [
+                {
+                    id: 'Legacy A',
+                    label: 'A',
+                    content: 'must not be persisted',
+                    sourceUri: 'note://workspace/v1/a.md',
+                    revision: 'sha256:abc',
+                    identityAliases: ['a.md'],
+                    evidenceRefs: ['span:1'],
+                    metadata: { tags: ['algebra'] },
+                },
+                { id: 'B', label: 'B' },
+            ],
+            edges: [
+                { source: 'Legacy A', target: 'B', type: 'explicit-prerequisite', evidenceRefs: ['span:2'] },
+            ],
+        }, { workspaceId: 'mobile-workspace', maxNeighbors: 1 });
+        expect(projection).toEqual(expect.objectContaining({
+            schemaVersion: 1,
+            projectionVersion: 1,
+            workspaceId: 'mobile-workspace',
+        }));
+        expect(projection.nodes[0]).toEqual(expect.objectContaining({
+            sourceUri: 'note://workspace/v1/a.md',
+            revision: 'sha256:abc',
+            evidenceRefs: ['span:1'],
+            tags: ['algebra'],
+        }));
+        expect(projection.nodes[0].content).toBeUndefined();
+        expect(projection.edges[0]).toEqual(expect.objectContaining({
+            kind: 'explicit',
+            provenance: 'explicit-prerequisite',
+            sourceUri: 'note://workspace/v1/a.md',
+            targetUri: '',
+            evidenceRefs: ['span:2'],
+        }));
+        expect(projection.adjacency).toEqual(expect.arrayContaining([
+            expect.objectContaining({ nodeId: 'Legacy A', outgoing: ['B'] }),
+        ]));
+    });
+    test('replays the same serialized projection and rejects unknown future schemas', () => {
+        const projection = contract.createKnowledgeProjection({
+            nodes: [{ id: 'A', sourceUri: 'note://workspace/v1/a.md' }],
+            edges: [],
+        });
+        const replayed = contract.replayKnowledgeProjection(JSON.stringify(projection));
+        expect(replayed).toEqual(projection);
+        expect(() => contract.replayKnowledgeProjection({ schemaVersion: contract.schemaVersion + 1, nodes: [], edges: [] }))
+            .toThrow(/Unsupported knowledge projection schema version/);
+        expect(() => contract.replayKnowledgeProjection({ schemaVersion: 0, nodes: [], edges: [] }))
+            .toThrow(/Unsupported knowledge projection schema version/);
+    });
+    test('preserves graph-level identity metadata when no override is supplied', () => {
+        const projection = contract.createKnowledgeProjection({
+            workspaceId: 'source-workspace',
+            revision: 'sha256:graph',
+            nodes: [{ id: 'A' }],
+            edges: [],
+        });
+        expect(projection.workspaceId).toBe('source-workspace');
+        expect(projection.revision).toBe('sha256:graph');
+    });
+    test('fails closed on normalized identity collisions and invalid edge endpoints', () => {
+        expect(() => contract.createKnowledgeProjection({
+            nodes: [{ id: 'A' }, { id: 'a' }],
+            edges: [],
+        })).toThrow(/duplicate node id/i);
+        expect(() => contract.createKnowledgeProjection({
+            nodes: [{ id: 'A' }],
+            edges: [{ source: 'A', target: 'missing', type: 'explicit-next' }],
+        })).toThrow(/invalid node/i);
+        expect(() => contract.createKnowledgeProjection({
+            nodes: [
+                { id: 'A', canonicalId: 'notes/a' },
+                { id: 'B', canonicalId: 'NOTES/A' },
+            ],
+            edges: [],
+        })).toThrow(/duplicate canonical node id/i);
+    });
+    test('preserves distinct provenance for same-endpoint edges', () => {
+        const projection = contract.createKnowledgeProjection({
+            nodes: [{ id: 'A' }, { id: 'B' }],
+            edges: [
+                { source: 'A', target: 'B', type: 'wiki-link', provenance: 'wiki-link' },
+                { source: 'A', target: 'B', type: 'markdown-link', provenance: 'markdown-link' },
+            ],
+        });
+        expect(projection.edges).toHaveLength(2);
+        expect(projection.edges.map((edge) => edge.provenance)).toEqual([
+            'wiki-link',
+            'markdown-link',
+        ]);
+    });
+});

package/dist/src/knowledge_projection_store.test.js

@@ -0,0 +1,200 @@
+"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 os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const projectionContract = require(path.resolve(__dirname, 'frontend', 'knowledge_projection_contract.js'));
+const projectionStore = require(path.resolve(__dirname, 'frontend', 'knowledge_projection_store.js'));
+const exactAnalyzer = require(path.resolve(__dirname, 'frontend', 'mobile_exact_analyzer.js'));
+function createFixture() {
+    return projectionContract.createKnowledgeProjection({
+        workspaceId: 'fixture-workspace',
+        revision: 'sha256:fixture',
+        nodes: [
+            { id: 'A', label: 'Algebra', sourceUri: 'note://workspace/v1/algebra.md', identityAliases: ['algebra.md'] },
+            { id: 'B', label: 'Basics', sourceUri: 'note://workspace/v1/basics.md' },
+            { id: 'C', label: 'Calculus', sourceUri: 'note://workspace/v1/calculus.md' },
+        ],
+        edges: [
+            { source: 'A', target: 'B', type: 'explicit-prerequisite', evidenceRefs: ['span:a-b'] },
+            { source: 'B', target: 'C', type: 'explicit-prerequisite', evidenceRefs: ['span:b-c'] },
+        ],
+    });
+}
+describe('cross-host knowledge projection store', () => {
+    test('replays identical schema, metadata, search, neighbors, and path results', async () => {
+        const fixture = createFixture();
+        let persisted = JSON.stringify(fixture);
+        const hostStores = ['web', 'tauri', 'capacitor', 'android'].map((host) => ({
+            host,
+            store: projectionStore.createProjectionStore({
+                read: async () => persisted,
+                write: async (serialized) => {
+                    persisted = serialized;
+                },
+            }),
+        }));
+        const baseline = {
+            projection: fixture,
+            metadata: await hostStores[0].store.metadata(),
+            search: exactAnalyzer.createMobileExactIndex(fixture).searchExact('Algebra', 10),
+            neighbors: exactAnalyzer.createMobileExactIndex(fixture).neighbors('A', 10),
+            path: exactAnalyzer.createMobileExactIndex(fixture).shortestPath('A', 'C', 8, 100),
+        };
+        for (const { host, store } of hostStores) {
+            const projection = await store.load();
+            const index = exactAnalyzer.createMobileExactIndex(projection);
+            expect(projection).toEqual(baseline.projection);
+            expect(await store.metadata()).toEqual(baseline.metadata);
+            expect(index.searchExact('Algebra', 10)).toEqual(baseline.search);
+            expect(index.neighbors('A', 10)).toEqual(baseline.neighbors);
+            expect(index.shortestPath('A', 'C', 8, 100)).toEqual(baseline.path);
+            expect(host).toMatch(/web|tauri|capacitor|android/);
+        }
+    });
+    test('keeps a successful in-memory projection available during adapter failure', async () => {
+        const fixture = createFixture();
+        const store = projectionStore.createProjectionStore({
+            read: async () => { throw new Error('storage temporarily unavailable'); },
+            initialProjection: fixture,
+        });
+        await expect(store.load()).resolves.toEqual(fixture);
+        await expect(store.metadata()).resolves.toEqual(expect.objectContaining({
+            nodeCount: 3,
+            edgeCount: 2,
+        }));
+    });
+    test('fails closed on an unknown future schema instead of silently downgrading', async () => {
+        const store = projectionStore.createProjectionStore({
+            read: async () => JSON.stringify({ schemaVersion: 2, nodes: [], edges: [] }),
+        });
+        await expect(store.load()).rejects.toThrow(/Unsupported knowledge projection schema version/);
+    });
+    test('does not hide a corrupt or future projection behind a stale cache', async () => {
+        const fixture = createFixture();
+        const store = projectionStore.createProjectionStore({
+            initialProjection: fixture,
+            read: async () => JSON.stringify({ schemaVersion: 2, nodes: [], edges: [] }),
+        });
+        await expect(store.load()).rejects.toThrow(/Unsupported knowledge projection schema version/);
+        await expect(store.metadata()).rejects.toThrow(/Unsupported knowledge projection schema version/);
+    });
+    test('reopens an app-local file projection with identical analysis results', async () => {
+        const fixture = createFixture();
+        const tempRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'noteconnection-projection-'));
+        const projectionPath = path.join(tempRoot, 'graph_data.json');
+        const createStore = () => projectionStore.createFileProjectionStore({
+            fileName: projectionPath,
+            readFile: async (fileName) => await fs.promises.readFile(fileName, 'utf8'),
+            writeAtomic: async (fileName, serialized) => {
+                const temporaryPath = `${fileName}.tmp-${process.pid}-${Date.now()}`;
+                await fs.promises.writeFile(temporaryPath, serialized, 'utf8');
+                await fs.promises.rename(temporaryPath, fileName);
+            },
+        });
+        try {
+            const firstStore = createStore();
+            expect(firstStore.kind).toBe('file-persistent');
+            await firstStore.save(fixture);
+            const reopenedStore = createStore();
+            const replayed = await reopenedStore.load();
+            const baselineIndex = exactAnalyzer.createMobileExactIndex(fixture);
+            const replayedIndex = exactAnalyzer.createMobileExactIndex(replayed);
+            expect(replayed).toEqual(fixture);
+            expect(await reopenedStore.metadata()).toEqual(await firstStore.metadata());
+            expect(replayedIndex.searchExact('Algebra', 10)).toEqual(baselineIndex.searchExact('Algebra', 10));
+            expect(replayedIndex.neighbors('A', 10)).toEqual(baselineIndex.neighbors('A', 10));
+            expect(replayedIndex.shortestPath('A', 'C', 8, 100)).toEqual(baselineIndex.shortestPath('A', 'C', 8, 100));
+        }
+        finally {
+            await fs.promises.rm(tempRoot, { recursive: true, force: true });
+        }
+    });
+    test('keeps the last committed file when an atomic write fails', async () => {
+        const fixture = createFixture();
+        const tempRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'noteconnection-projection-'));
+        const projectionPath = path.join(tempRoot, 'graph_data.json');
+        let failWrites = false;
+        const createStore = () => projectionStore.createFileProjectionStore({
+            fileName: projectionPath,
+            readFile: async (fileName) => await fs.promises.readFile(fileName, 'utf8'),
+            writeAtomic: async (fileName, serialized) => {
+                if (failWrites) {
+                    throw new Error('storage unavailable');
+                }
+                const temporaryPath = `${fileName}.tmp-${process.pid}-${Date.now()}`;
+                await fs.promises.writeFile(temporaryPath, serialized, 'utf8');
+                await fs.promises.rename(temporaryPath, fileName);
+            },
+        });
+        try {
+            const committedStore = createStore();
+            await committedStore.save(fixture);
+            failWrites = true;
+            await expect(committedStore.save({ ...fixture, revision: 'sha256:next' })).rejects.toThrow(/storage unavailable/);
+            const reopenedStore = createStore();
+            await expect(reopenedStore.load()).resolves.toEqual(fixture);
+        }
+        finally {
+            await fs.promises.rm(tempRoot, { recursive: true, force: true });
+        }
+    });
+    test('rejects truncated app-local files instead of replaying partial JSON', async () => {
+        const tempRoot = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'noteconnection-projection-'));
+        const projectionPath = path.join(tempRoot, 'graph_data.json');
+        try {
+            await fs.promises.writeFile(projectionPath, '{"schemaVersion":1,"nodes":[', 'utf8');
+            const store = projectionStore.createFileProjectionStore({
+                fileName: projectionPath,
+                readFile: async (fileName) => await fs.promises.readFile(fileName, 'utf8'),
+            });
+            await expect(store.load()).rejects.toThrow(/Knowledge projection JSON is invalid/);
+        }
+        finally {
+            await fs.promises.rm(tempRoot, { recursive: true, force: true });
+        }
+    });
+    test('rejects an incomplete app-local adapter instead of silently switching to memory', () => {
+        expect(() => projectionStore.createFileProjectionStore({
+            fileName: 'graph_data.json',
+        })).toThrow(/readFile adapter is required/);
+        expect(() => projectionStore.createFileProjectionStore({
+            fileName: 'graph_data.json',
+            readFile: async () => '',
+            write: async () => undefined,
+        })).toThrow(/must use the writeAtomic adapter/);
+    });
+});

package/dist/src/learning/AnswerQualityEvaluation.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANSWER_QUALITY_CATEGORIES = exports.ANSWER_QUALITY_MEASUREMENT_PROTOCOL = void 0;
+exports.parseAnswerQualityCorpus = parseAnswerQualityCorpus;
+exports.measureAnswerQuality = measureAnswerQuality;
+exports.summarizeAnswerQuality = summarizeAnswerQuality;
+// Legacy reports without a protocol field used the release label and a narrower no-answer vocabulary.
+exports.ANSWER_QUALITY_MEASUREMENT_PROTOCOL = 'answer-quality-public-surface-v3';
+exports.ANSWER_QUALITY_CATEGORIES = [
+    'definition', 'comparison', 'causal', 'multi_step', 'conflict', 'missing_evidence', 'topic_drift', 'math', 'noisy_headings',
+];
+function parseAnswerQualityCorpus(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        throw new TypeError('Expected an answer-quality corpus object');
+    const corpus = input;
+    if (corpus.schemaVersion !== 1 || !corpus.version || !corpus.backend || !Array.isArray(corpus.cases) || !corpus.cases.length) {
+        throw new TypeError('Incomplete answer-quality corpus contract');
+    }
+    const caseIds = new Set();
+    const documentIds = new Set();
+    const sourceContents = new Map();
+    for (const entry of corpus.cases) {
+        if (!entry.id || caseIds.has(entry.id) || !['calibration', 'evaluation'].includes(entry.split)
+            || !['en', 'zh'].includes(entry.language) || !exports.ANSWER_QUALITY_CATEGORIES.includes(entry.category)
+            || typeof entry.query !== 'string' || !entry.query.trim() || !Array.isArray(entry.documents) || !entry.documents.length) {
+            throw new TypeError(`Invalid or duplicate answer-quality case: ${entry.id}`);
+        }
+        caseIds.add(entry.id);
+        for (const document of entry.documents) {
+            if (!document.documentId || documentIds.has(document.documentId) || !document.sourcePath || typeof document.content !== 'string') {
+                throw new TypeError(`Invalid or duplicate document in case ${entry.id}`);
+            }
+            documentIds.add(document.documentId);
+            const content = document.content.replace(/\s+/g, ' ').trim();
+            const previousSplit = sourceContents.get(content);
+            if (previousSplit && previousSplit !== entry.split)
+                throw new TypeError('Calibration/evaluation source leakage');
+            sourceContents.set(content, entry.split);
+        }
+        const reference = entry.reference;
+        if (!reference || !Array.isArray(reference.facts) || !Array.isArray(reference.unsupportedClaims)
+            || typeof reference.expectsConflict !== 'boolean' || typeof reference.expectsAbstention !== 'boolean') {
+            throw new TypeError(`Missing independent references for ${entry.id}`);
+        }
+        const patterns = [];
+        for (const fact of reference.facts) {
+            if (!fact.id || !Array.isArray(fact.patterns) || !fact.patterns.length)
+                throw new TypeError(`Invalid fact in ${entry.id}`);
+            patterns.push(...fact.patterns);
+        }
+        for (const claim of reference.unsupportedClaims) {
+            if (!claim.id)
+                throw new TypeError(`Invalid unsupported-claim probe in ${entry.id}`);
+            patterns.push(claim.pattern);
+        }
+        if (reference.orderedSteps) {
+            if (!Array.isArray(reference.orderedSteps))
+                throw new TypeError(`Invalid ordered steps in ${entry.id}`);
+            patterns.push(...reference.orderedSteps);
+        }
+        for (const pattern of patterns) {
+            if (typeof pattern !== 'string' || !pattern || pattern.length > 512)
+                throw new TypeError(`Invalid reference pattern in ${entry.id}`);
+            new RegExp(pattern, 'iu');
+        }
+    }
+    return corpus;
+}
+function publicAnswerSignalsAbstention(answer) {
+    if (/insufficient (?:local |source )?evidence|no (?:scoped|relevant|matching) (?:knowledge|evidence)|证据不足|没有(?:足够|相关)证据|暂无相关证据/iu.test(answer))
+        return true;
+    if (/\b(?:i|we) (?:cannot|can't|can’t|could not) (?:answer|(?:give|provide) (?:a )?(?:grounded|reliable|supported) answer)/iu.test(answer)
+        || /我(?:暂时)?(?:不能|无法)对“[^”]*”给出有依据的回答/u.test(answer)
+        || /(?:资料|证据|材料|信息)不足以(?:确定|给出|回答)|我(?:暂时)?(?:不能|无法)[^。！？]{0,160}(?:有依据的回答|确定)/u.test(answer))
+        return true;
+    // The missing object must be a measurement. "No data loss" and negative
+    // capability statements are factual answers, not evidence of abstention.
+    const source = String.raw `\b(?:archives?|sources?|notes?|records?|reports?|evidence|documents?|documentation|materials?|datasets?)\b`;
+    const measurement = String.raw `\b(?:measurements?|measured (?:values?|data|melting points?)|measurement (?:data|results?)|melting points?|parameter values?|requested data)\b`;
+    const object = String.raw `\s+(?:(?:a|an|the|any|reliable|available|recorded|relevant|usable|experimental|exact|requested|[\w-]+['’]s)\s+){0,5}`;
+    const absentMeasurement = [
+        `${source}\\s+(?:does not|do not|did not|doesn't|doesn’t|has not|have not)\\s+(?:provide|contain|record|report|specify|document|include|state)\\b${object}${measurement}`,
+        `${source}\\s+(?:contains?|provides?|records?|reports?|includes?|has|have)\\s+no${object}${measurement}`,
+        `${measurement}\\s+(?:has not been|have not been|is not|are not|was not|were not)\\s+(?:recorded|reported|provided|documented|available)\\b`,
+    ];
+    if (absentMeasurement.some(pattern => new RegExp(pattern, 'iu').test(answer)))
+        return true;
+    return /(?:档案|存档|资料|材料|笔记|文档|记录|报告|来源)(?:中|里)?(?:尚未|未|并未)(?:提供|给出|记录|收录|报告|标明|包含|测得)[^，,。！？;；]{0,80}(?:测量(?:值|数据|结果)?|实验数据|参数值|熔点|数值)/u.test(answer)
+        || /(?:档案|存档|资料|材料|笔记|文档|记录|报告|来源)(?:中|里)?(?:没有|暂无)(?:提供|给出|记录|收录|报告|标明|包含)?[^，,。！？;；]{0,80}(?:测量(?:值|数据|结果)?|实验数据|参数值|熔点|数值)/u.test(answer);
+}
+function publicAnswerSignalsEvidenceConflict(answer) {
+    const text = answer.replace(/\b(?:no|without)\s+(?:evidence of\s+)?(?:conflicts?|conflicting|contradictions?|contradictory|inconsistenc(?:y|ies)|inconsistent)\b/giu, '')
+        .replace(/(?:没有|不存在|无)(?:明显)?(?:冲突|矛盾|分歧)/gu, '');
+    // A conflict between sources is different from a fact about write conflicts,
+    // hash collisions or conflict serializability. Require a disclosure about evidence.
+    return /\b(?:sources?|evidence|observations?|measurements?|reports?|statements?)\s+(?:(?:is|are|was|were|remain|remains|appear|appears|seem|seems)\s+)?(?:in\s+conflict|conflict(?:s|ing)?|contradict(?:s|ory)?|disagree(?:s)?|inconsistent)\b/iu.test(text)
+        || /\b(?:conflicting|contradictory|inconsistent)\s+(?:source\s+)?(?:evidence|observations?|measurements?|reports?|statements?|sources?)\b/iu.test(text)
+        || /\b(?:conflict|contradiction|disagreement|inconsistency)\s+(?:between|among)\s+(?:the\s+)?(?:source\s+)?(?:evidence|observations?|measurements?|reports?|statements?|sources?)\b/iu.test(text)
+        || /(?:来源|证据|观测(?:结果)?|测量(?:值|记录))(?:之间|彼此|相互|中的观测|中的记录|中|结果)?(?:存在|出现|发生|有|相互|互相|彼此)?(?:冲突|矛盾|分歧|不一致)/u.test(text)
+        || /(?:报告|记录|陈述)(?:之间|彼此|相互)(?:存在|出现|发生|有)?(?:冲突|矛盾|分歧|不一致)/u.test(text);
+}
+function measureAnswerQuality(entry, response) {
+    const answer = response.answer.replace(/\*\*|`/g, '').replace(/\s+/g, ' ').trim();
+    const matches = (pattern) => new RegExp(pattern, 'iu').test(answer);
+    const coveredFactIds = entry.reference.facts.filter(fact => fact.patterns.some(matches)).map(fact => fact.id);
+    const missingFactIds = entry.reference.facts.filter(fact => !coveredFactIds.includes(fact.id)).map(fact => fact.id);
+    const unsupportedClaimIds = entry.reference.unsupportedClaims.filter(claim => matches(claim.pattern)).map(claim => claim.id);
+    const conflictSignalled = publicAnswerSignalsEvidenceConflict(answer);
+    const abstentionSignalled = publicAnswerSignalsAbstention(answer);
+    let stepOffset = 0;
+    const orderedStepsSatisfied = (entry.reference.orderedSteps || []).every(pattern => {
+        const match = new RegExp(pattern, 'iu').exec(answer.slice(stepOffset));
+        if (!match)
+            return false;
+        stepOffset += match.index + match[0].length;
+        return true;
+    });
+    const displayMathCount = (answer.match(/(?<!\\)\$\$/gu) || []).length;
+    const inlineMathCount = (answer.replace(/(?<!\\)\$\$/gu, '').match(/(?<!\\)\$/gu) || []).length;
+    const balancedMath = displayMathCount % 2 === 0 && inlineMathCount % 2 === 0;
+    const documents = new Set(entry.documents.map(document => document.documentId));
+    const invalidCitationIds = response.citations.filter(citation => !documents.has(citation.documentId)).map(citation => citation.citationId);
+    const passed = !missingFactIds.length && !unsupportedClaimIds.length && orderedStepsSatisfied && balancedMath
+        && !invalidCitationIds.length && conflictSignalled === entry.reference.expectsConflict && abstentionSignalled === entry.reference.expectsAbstention;
+    return {
+        caseId: entry.id, split: entry.split, language: entry.language, category: entry.category,
+        referenceFactCount: entry.reference.facts.length, coveredFactIds, missingFactIds,
+        unsupportedProbeCount: entry.reference.unsupportedClaims.length, unsupportedClaimIds,
+        conflictExpected: entry.reference.expectsConflict, conflictSignalled,
+        abstentionExpected: entry.reference.expectsAbstention, abstentionSignalled,
+        orderedStepsSatisfied, balancedMath, invalidCitationIds, passed,
+    };
+}
+function summarizeAnswerQuality(results) {
+    const count = (predicate) => results.filter(predicate).length;
+    const fraction = (numerator, denominator) => ({ numerator, denominator, rate: denominator ? numerator / denominator : null });
+    const facts = results.reduce((sum, row) => sum + row.referenceFactCount, 0);
+    const covered = results.reduce((sum, row) => sum + row.coveredFactIds.length, 0);
+    const probes = results.reduce((sum, row) => sum + row.unsupportedProbeCount, 0);
+    const unsupported = results.reduce((sum, row) => sum + row.unsupportedClaimIds.length, 0);
+    return {
+        cases: results.length,
+        referenceAcceptance: fraction(count(row => row.passed), results.length),
+        referenceFactCoverage: fraction(covered, facts),
+        unsupportedAssertionProbeHitRate: fraction(unsupported, probes),
+        falseConflictRate: fraction(count(row => !row.conflictExpected && row.conflictSignalled), count(row => !row.conflictExpected)),
+        missedConflictRate: fraction(count(row => row.conflictExpected && !row.conflictSignalled), count(row => row.conflictExpected)),
+        correctAbstentionRate: fraction(count(row => row.abstentionExpected && row.abstentionSignalled), count(row => row.abstentionExpected)),
+        unexpectedAbstentionRate: fraction(count(row => !row.abstentionExpected && row.abstentionSignalled), count(row => !row.abstentionExpected)),
+        unbalancedMathAnswers: count(row => !row.balancedMath),
+        outOfScopeCitations: results.reduce((sum, row) => sum + row.invalidCitationIds.length, 0),
+    };
+}

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

@@ -0,0 +1,118 @@
+"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 AnswerQualityEvaluation_1 = require("./AnswerQualityEvaluation");
+const raw = JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../fixtures/answer-quality/v1.json'), 'utf8'));
+describe('independent answer-quality measurements', () => {
+    test('validates disjoint bilingual calibration/evaluation sets covering every declared category', () => {
+        const corpus = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(raw);
+        expect(corpus.cases.filter(entry => entry.split === 'calibration')).toHaveLength(6);
+        const heldOut = corpus.cases.filter(entry => entry.split === 'evaluation');
+        expect(heldOut).toHaveLength(18);
+        for (const category of AnswerQualityEvaluation_1.ANSWER_QUALITY_CATEGORIES)
+            expect(heldOut.filter(entry => entry.category === category).map(entry => entry.language).sort()).toEqual(['en', 'zh']);
+    });
+    test('the confirmation corpus uses disjoint evaluation documents and subjects', () => {
+        const confirmation = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../fixtures/answer-quality/v2.json'), 'utf8')));
+        const original = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(raw);
+        const queries = new Set(original.cases.map(entry => entry.query));
+        const sourceContents = new Set(original.cases.flatMap(entry => entry.documents.map(document => document.content.replace(/\s+/g, ' ').trim())));
+        for (const entry of confirmation.cases.filter(item => item.split === 'evaluation')) {
+            expect(queries.has(entry.query)).toBe(false);
+            for (const document of entry.documents)
+                expect(sourceContents.has(document.content.replace(/\s+/g, ' ').trim())).toBe(false);
+        }
+        for (const category of AnswerQualityEvaluation_1.ANSWER_QUALITY_CATEGORIES)
+            expect(confirmation.cases.filter(entry => entry.split === 'evaluation' && entry.category === category).map(entry => entry.language).sort()).toEqual(['en', 'zh']);
+    });
+    test('rejects source leakage between calibration and evaluation', () => {
+        const corpus = structuredClone(raw);
+        corpus.cases[6].documents[0].content = corpus.cases[0].documents[0].content;
+        expect(() => (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(corpus)).toThrow('source leakage');
+    });
+    test('does not substitute runtime sufficient claims for independently labelled fact coverage', () => {
+        const entry = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(raw).cases.find(item => item.id === 'eval-idempotency-en');
+        const response = { answer: 'It ensures exactly-once network delivery.', citations: [], answerReleaseReview: { decision: 'release' } };
+        const measurement = (0, AnswerQualityEvaluation_1.measureAnswerQuality)(entry, response);
+        expect(measurement.coveredFactIds).toEqual([]);
+        expect(measurement.unsupportedClaimIds).toEqual(['unsupported-1']);
+        expect(measurement.passed).toBe(false);
+    });
+    test.each([
+        'A write conflict can cause a transaction to retry.',
+        'Conflict serializability preserves an equivalent serial schedule.',
+        '键冲突需要额外的消解策略。',
+        '写写冲突可以用版本校验检测。',
+        'There is no conflict between the source observations.',
+        'There is no conflicting evidence.',
+        '来源之间没有冲突。',
+    ])('does not confuse a domain conflict or its negation with conflicting evidence: %s', answer => {
+        const entry = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(raw).cases[0];
+        expect((0, AnswerQualityEvaluation_1.measureAnswerQuality)(entry, { answer, citations: [] }).conflictSignalled).toBe(false);
+    });
+    test.each([
+        'The source observations conflict; the available evidence does not establish which is correct.',
+        'The measurements disagree.',
+        'The evidence is inconsistent.',
+        'Conflicting evidence for the clock rate: 3 Hz and 8 Hz.',
+        '来源中的观测存在冲突，现有证据无法确定哪一项正确。',
+        '两份报告之间存在矛盾。',
+    ])('recognizes an explicit source disagreement: %s', answer => {
+        const entry = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(raw).cases[0];
+        expect((0, AnswerQualityEvaluation_1.measureAnswerQuality)(entry, { answer, citations: [] }).conflictSignalled).toBe(true);
+    });
+    test('retains explicit denominators and reports undefined rates when no opportunities exist', () => {
+        const entry = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(raw).cases.find(item => item.id === 'eval-missing-en');
+        const measurement = (0, AnswerQualityEvaluation_1.measureAnswerQuality)(entry, { answer: 'Insufficient evidence.', citations: [], answerReleaseReview: { decision: 'abstain' } });
+        const summary = (0, AnswerQualityEvaluation_1.summarizeAnswerQuality)([measurement]);
+        expect(summary.referenceFactCoverage).toEqual({ numerator: 0, denominator: 0, rate: null });
+        expect(summary.correctAbstentionRate).toEqual({ numerator: 1, denominator: 1, rate: 1 });
+        expect(summary.missedConflictRate.rate).toBeNull();
+    });
+    test.each([
+        'The archive does not provide a measured melting point for the sample.',
+        'The notes contain no measurements of the sample temperature.',
+        'The requested measurement has not been recorded in the available sources.',
+        'I cannot give a grounded answer from these notes.',
+        '星云合金记录 存档没有提供星云合金熔点的测量数据。',
+        '现有资料未记录这个样品的测量值。',
+        '笔记中没有该参数的测量结果。',
+        '当前资料不足以确定这个参数的数值。',
+        '我暂时不能对“什么是热预算，它有什么用途？”给出有依据的回答。',
+    ])('recognizes an evidence-based unknown answer independently of its release label: %s', answer => {
+        const entry = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(raw).cases.find(item => item.id === 'eval-missing-en');
+        const measurement = (0, AnswerQualityEvaluation_1.measureAnswerQuality)(entry, { answer, citations: [], answerReleaseReview: { decision: 'release' } });
+        expect(measurement.abstentionSignalled).toBe(true);
+    });
+    test.each([
+        'The journal ensures there is no data loss after acknowledgement.',
+        'The source does not report data loss during the experiment.',
+        'The database does not provide serializable isolation.',
+        'The measured signal is not 12 Hz; it is 18 Hz.',
+        'The archive reports no conflict between these measurements.',
+        '日志确保确认后没有数据丢失。',
+        '资料没有记录任何数据丢失。',
+        '定标频率不是12赫兹，而是18赫兹。',
+        '实验报告中没有数据泄漏。',
+    ])('does not label a factual negation as an unknown answer: %s', answer => {
+        const entry = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(raw).cases.find(item => item.id === 'eval-missing-en');
+        const measurement = (0, AnswerQualityEvaluation_1.measureAnswerQuality)(entry, { answer, citations: [] });
+        expect(measurement.abstentionSignalled).toBe(false);
+    });
+    test('does not use an internal abstain label to claim that the public answer discloses uncertainty', () => {
+        const entry = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(raw).cases.find(item => item.id === 'eval-missing-en');
+        const measurement = (0, AnswerQualityEvaluation_1.measureAnswerQuality)(entry, { answer: 'The melting point is 900 K.', citations: [], answerReleaseReview: { decision: 'abstain' } });
+        expect(measurement.abstentionSignalled).toBe(false);
+    });
+    test('catches reversed procedural steps and unbalanced math', () => {
+        const entry = (0, AnswerQualityEvaluation_1.parseAnswerQualityCorpus)(raw).cases.find(item => item.id === 'eval-replacement-en');
+        const response = { answer: 'Acknowledge then rename, flush the temporary file. $R_1', citations: [] };
+        const measurement = (0, AnswerQualityEvaluation_1.measureAnswerQuality)(entry, response);
+        expect(measurement.orderedStepsSatisfied).toBe(false);
+        expect(measurement.balancedMath).toBe(false);
+    });
+});