noteconnection 1.8.0 → 1.9.0

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphConditionedContext_1 = require("./graphConditionedContext");
+function makeFragment(overrides = {}) {
+    return {
+        fragmentId: 'fragment-default',
+        role: 'background',
+        text: 'evidence',
+        documentId: 'document-1',
+        sourcePath: 'notes/topic.md',
+        headingPath: [],
+        charCount: 8,
+        tokenEstimate: 2,
+        truncated: false,
+        citationIds: [],
+        relationEdgeIds: [],
+        score: 0.5,
+        sourceBoundary: 'direct_span_only',
+        ...overrides,
+    };
+}
+function makePlan() {
+    return {
+        intent: 'causal',
+        depth: 'standard',
+        anchorAtomId: 'atom-anchor',
+        leadClaimId: 'claim-required',
+        claims: [{
+                claimId: 'claim-required',
+                role: 'mechanism',
+                required: true,
+                priority: 100,
+                statement: 'The planned mechanism is supported by the graph.',
+                subjectAtomId: 'atom-anchor',
+                supportingAtomIds: ['atom-support'],
+                supportingEdgeIds: ['edge-support'],
+                evidenceRefs: [{
+                        evidenceId: 'evidence-1',
+                        atomId: 'atom-support',
+                        sourcePath: 'notes/topic.md',
+                        citationIds: ['citation-1'],
+                        text: 'evidence',
+                    }],
+                confidence: 0.95,
+            }],
+        requiredRoles: ['mechanism'],
+        omittedCandidates: [],
+    };
+}
+describe('conditionRagFragmentsByGraphPlan', () => {
+    test('prefers fragments matched by required graph atoms and relation edges', () => {
+        const fragments = [
+            makeFragment({
+                fragmentId: 'neighbor-unmatched',
+                role: 'graph_neighbor_support',
+                atomId: 'atom-other',
+                relationEdgeIds: ['edge-other'],
+            }),
+            makeFragment({
+                fragmentId: 'neighbor-matched',
+                role: 'graph_neighbor_support',
+                atomId: 'atom-support',
+                relationEdgeIds: ['edge-support'],
+            }),
+            makeFragment({
+                fragmentId: 'anchor-direct',
+                role: 'direct_support',
+                atomId: 'atom-anchor',
+            }),
+        ];
+        const result = (0, graphConditionedContext_1.conditionRagFragmentsByGraphPlan)({
+            fragments,
+            graphAnswerPlan: makePlan(),
+        });
+        expect(result.fragmentOrder.indexOf('neighbor-matched'))
+            .toBeLessThan(result.fragmentOrder.indexOf('neighbor-unmatched'));
+        expect(result.trace.strategy).toBe('graph_answer_plan');
+        expect(result.trace.matchedClaimCount).toBe(1);
+        expect(result.trace.matchedFragmentCount).toBe(2);
+        expect(result.trace.selectedAtomIds).toEqual(['atom-anchor', 'atom-support']);
+        expect(result.trace.selectedEdgeIds).toEqual(['edge-support']);
+    });
+    test('keeps input order and exposes an explicit fallback when no plan exists', () => {
+        const fragments = [
+            makeFragment({ fragmentId: 'second' }),
+            makeFragment({ fragmentId: 'first' }),
+        ];
+        const result = (0, graphConditionedContext_1.conditionRagFragmentsByGraphPlan)({ fragments });
+        expect(result.fragmentOrder).toEqual(['second', 'first']);
+        expect(result.trace).toEqual({
+            strategy: 'none',
+            matchedClaimCount: 0,
+            matchedFragmentCount: 0,
+            selectedAtomIds: [],
+            selectedEdgeIds: [],
+            fallbackReason: 'no_graph_answer_plan',
+        });
+    });
+});

package/dist/src/learning/graphContextAssembler.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.assembleAgentConversationGraphContext = assembleAgentConversationGraphContext;
 exports.buildAgentConversationGraphContextFromKnowledgePoints = buildAgentConversationGraphContextFromKnowledgePoints;
 const store_1 = require("./store");
+const answerTaskPlan_1 = require("./answerTaskPlan");
 function normalizeGraphComparableTitle(value) {
     return normalizeWhitespace(String(value || '').toLowerCase());
 }
@@ -105,21 +106,10 @@ function classifyConversationIntent(message) {
     if (!normalized) {
         return 'generic';
     }
-    if (normalized.includes('compare')
-        || normalized.includes('difference')
-        || normalized.includes('vs')
-        || normalized.includes('区分')
-        || normalized.includes('对比')) {
+    if ((0, answerTaskPlan_1.isComparisonRequest)(normalized)) {
         return 'compare';
     }
-    if (normalized.includes('how to')
-        || normalized.includes('how do')
-        || normalized.includes('steps')
-        || normalized.includes('plan')
-        || normalized.includes('如何')
-        || normalized.includes('怎么')
-        || normalized.includes('步骤')
-        || normalized.includes('方案')) {
+    if ((0, answerTaskPlan_1.isProcedureRequest)(normalized)) {
         return 'how_to';
     }
     if (normalized.includes('what is')

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

@@ -722,7 +722,7 @@ describe('assembleAgentConversationGraphContext', () => {
             outDegree: 2,
         }));
     });
-    test('prioritizes contrast successors over procedural sequence nodes for compare intent', async () => {
+    test.each(['compare water glass and plastic cup', '比较 water glass 和 plastic cup'])('prioritizes contrast successors over procedural sequence nodes: %s', async (message) => {
         const atoms = [
             createAtom({
                 id: 'atom_water_glass',
@@ -779,7 +779,7 @@ describe('assembleAgentConversationGraphContext', () => {
             }),
         ];
         const result = await (0, graphContextAssembler_1.assembleAgentConversationGraphContext)({
-            message: 'compare water glass and plastic cup',
+            message,
             usedScope: globalScope,
             knowledgePoints,
             store: new InMemoryOpsStore(atoms, edges),

package/dist/src/learning/graphExpansionPolicy.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGraphExpansionPolicy = resolveGraphExpansionPolicy;
+const EXPLICIT_DEPTH_PATTERN = /\b(?:deep|detailed|comprehensive|thorough|in-depth|in depth|in detail|fully|complete|research)\b|深入|深度|详细|详尽|完整|充分|展开|研究/u;
+function resolveGraphExpansionPolicy(message) {
+    const explicitDepthRequested = EXPLICIT_DEPTH_PATTERN.test(String(message || '').toLowerCase());
+    return explicitDepthRequested
+        ? {
+            enabled: true,
+            reason: 'explicit_depth_request',
+            maxSteps: 1,
+            maxNeighbors: 8,
+            maxPathDepth: 8,
+        }
+        : {
+            enabled: false,
+            reason: 'ordinary_query',
+            maxSteps: 0,
+            maxNeighbors: 6,
+            maxPathDepth: 6,
+        };
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphExpansionPolicy_1 = require("./graphExpansionPolicy");
+describe('resolveGraphExpansionPolicy', () => {
+    test.each([
+        'what is water glass',
+        'explain water glass',
+        '为什么杯壁会传热',
+    ])('keeps ordinary questions on deterministic bounded retrieval: %s', (message) => {
+        expect((0, graphExpansionPolicy_1.resolveGraphExpansionPolicy)(message)).toEqual({
+            enabled: false,
+            reason: 'ordinary_query',
+            maxSteps: 0,
+            maxNeighbors: 6,
+            maxPathDepth: 6,
+        });
+    });
+    test.each([
+        'explain water glass in detail',
+        'perform a deep analysis of water glass',
+        'research the complete thermal mechanism',
+        '详细解释水杯的热交换机制',
+        '深入研究杯壁与环境的关系',
+    ])('enables one replayable bounded expansion for explicit depth: %s', (message) => {
+        expect((0, graphExpansionPolicy_1.resolveGraphExpansionPolicy)(message)).toEqual({
+            enabled: true,
+            reason: 'explicit_depth_request',
+            maxSteps: 1,
+            maxNeighbors: 8,
+            maxPathDepth: 8,
+        });
+    });
+});

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const KnowledgeLearningPlatform_1 = require("./KnowledgeLearningPlatform");
+describe('knowledge document identity metadata', () => {
+    test('deletes a document through its portable source URI after ingest', async () => {
+        const platform = new KnowledgeLearningPlatform_1.KnowledgeLearningPlatform(() => new Date('2026-08-17T00:00:00.000Z'));
+        await platform.ingestKnowledge({
+            incremental: true,
+            documents: [{
+                    documentId: 'legacy_doc',
+                    sourcePath: 'Knowledge_Base/notes/identity.md',
+                    sourceUri: 'note://workspace/v1/notes/identity.md',
+                    revision: 'sha256:identity-revision',
+                    identityAliases: ['identity', 'notes/identity.md'],
+                    content: '# Identity\nPortable identity metadata stays additive.',
+                }],
+        });
+        const deleted = await platform.ingestKnowledge({
+            incremental: true,
+            deletedDocuments: [{ sourceUri: 'note://workspace/v1/notes/identity.md' }],
+        });
+        expect(deleted.summary.deletedDocuments).toBe(1);
+        expect(deleted.staleness[0]?.documentId).toBe('legacy_doc');
+        expect(deleted.staleness[0]?.status).toBe('deleted');
+    });
+});

package/dist/src/learning/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./queryBackend"), exports);
 __exportStar(require("./vectorAccelerationAdapter"), exports);
 __exportStar(require("./runtimeCapability"), exports);
 __exportStar(require("./conversationComposer"), exports);
+__exportStar(require("./agentConversationSerialization"), exports);
 __exportStar(require("./ragSufficiencyProviderJudge"), exports);
 __exportStar(require("./errors"), exports);
 __exportStar(require("./domains"), exports);

package/dist/src/learning/mobileAnswerProjection.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOBILE_ANSWER_PROJECTION_SCHEMA_VERSION = void 0;
+exports.projectAnswerForMobile = projectAnswerForMobile;
+exports.MOBILE_ANSWER_PROJECTION_SCHEMA_VERSION = 1;
+const MAX_MOBILE_DIRECT_ANSWER_CHARS = 2400;
+const MAX_MOBILE_ROUTE_NODES = 8;
+const MAX_MOBILE_CITATIONS = 4;
+const MAX_MOBILE_TITLE_CHARS = 160;
+const MAX_MOBILE_SOURCE_PATH_CHARS = 320;
+function normalize(value) {
+    return String(value || '').replace(/\s+/gu, ' ').trim();
+}
+function normalizeMarkdown(value) {
+    return String(value || '').replace(/\r\n?/gu, '\n').trim();
+}
+function trimText(value, limit) {
+    const normalized = normalize(value);
+    return normalized.length <= limit ? normalized : `${normalized.slice(0, Math.max(0, limit - 1)).trim()}…`;
+}
+function countDisplayMathDelimiters(value) {
+    return (value.match(/(?<!\\)\$\$/gu) || []).length;
+}
+function trimMarkdown(value, limit) {
+    const normalized = normalizeMarkdown(value);
+    if (normalized.length <= limit) {
+        return normalized;
+    }
+    const suffix = '…';
+    let candidate = normalized.slice(0, Math.max(0, limit - suffix.length)).trimEnd();
+    // Do not publish an answer with an unmatched display-math fence. If a
+    // block crosses the mobile byte/character budget, omit that incomplete
+    // block rather than asking every client to repair malformed Markdown.
+    if (countDisplayMathDelimiters(candidate) % 2 !== 0) {
+        const openingIndex = candidate.lastIndexOf('$$');
+        candidate = openingIndex >= 0 ? candidate.slice(0, openingIndex).trimEnd() : '';
+    }
+    return `${candidate}${suffix}`.trim();
+}
+function stripRouteFromAnswer(answer) {
+    const normalized = normalizeMarkdown(answer);
+    const headingIndex = normalized.search(/(?:^|\n)#{1,6}\s+(?:建议学习路径|推荐学习路径|Suggested learning path)\s*$/imu);
+    const withoutHeadingRoute = headingIndex >= 0
+        ? normalized.slice(0, headingIndex).trimEnd()
+        : normalized;
+    return withoutHeadingRoute
+        .replace(/(?:建议学习路径|推荐学习路径|Suggested learning path)\s*[:：][^\n]*(?:\n[^\n]*)*$/iu, '')
+        .replace(/([。.!?])\1+/gu, '$1')
+        .trim();
+}
+function resolveTaskPlan(response) {
+    return response.answerTaskPlan
+        || response.graphAnswerPlan?.answerTaskPlan
+        || response.trace?.answerTaskPlan
+        || response.knowledgeRun?.answerTaskPlan;
+}
+function projectCitation(citation) {
+    const citationId = normalize(citation.citationId);
+    const title = trimText(citation.title, MAX_MOBILE_TITLE_CHARS);
+    const sourcePath = trimText(citation.sourcePath, MAX_MOBILE_SOURCE_PATH_CHARS);
+    if (!citationId || !title || !sourcePath) {
+        return null;
+    }
+    return {
+        citationId,
+        title,
+        sourcePath,
+        ...(Number.isFinite(Number(citation.startLine)) ? { startLine: Number(citation.startLine) } : {}),
+        ...(Number.isFinite(Number(citation.endLine)) ? { endLine: Number(citation.endLine) } : {}),
+    };
+}
+function projectAnswerForMobile(response) {
+    const taskPlan = resolveTaskPlan(response);
+    const structuredAnswerBlock = (response.assistantBlocks || [])
+        .find((block) => block && block.type === 'structured_answer');
+    const directAnswer = trimMarkdown(stripRouteFromAnswer(String(response.answer
+        || response.assistantMessage
+        || (structuredAnswerBlock && 'directAnswer' in structuredAnswerBlock
+            ? structuredAnswerBlock.directAnswer
+            : '')
+        || '')), MAX_MOBILE_DIRECT_ANSWER_CHARS);
+    const route = (taskPlan?.learningRoute || [])
+        .slice()
+        .sort((left, right) => left.order - right.order)
+        .slice(0, MAX_MOBILE_ROUTE_NODES)
+        .map((node) => ({
+        nodeId: trimText(node.nodeId, MAX_MOBILE_TITLE_CHARS),
+        title: trimText(node.title, MAX_MOBILE_TITLE_CHARS),
+        role: node.role,
+        order: Math.max(1, Math.floor(Number(node.order) || 1)),
+    }))
+        .filter((node) => Boolean(node.nodeId && node.title));
+    const citations = (response.citations || [])
+        .slice(0, MAX_MOBILE_CITATIONS)
+        .map(projectCitation)
+        .filter((citation) => Boolean(citation));
+    return {
+        schemaVersion: exports.MOBILE_ANSWER_PROJECTION_SCHEMA_VERSION,
+        primarySubject: trimText(taskPlan?.primarySubject || '', MAX_MOBILE_TITLE_CHARS),
+        directAnswer,
+        route,
+        citations,
+    };
+}

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mobileAnswerProjection_1 = require("./mobileAnswerProjection");
+describe('mobile answer projection', () => {
+    test('keeps a bounded task result and drops internal RAG payloads', () => {
+        const response = {
+            answer: '非晶冰是水的一种缺乏长程有序的固态形式。建议学习路径：1. 水分子与氢键网络 -> 2. 非晶冰 -> 3. 径向分布函数 g(r)。',
+            assistantMessage: 'same',
+            answerTaskPlan: {
+                schemaVersion: '1',
+                primarySubject: '非晶冰',
+                requestedDepth: 'standard',
+                subtasks: [
+                    { subtaskId: 'definition', kind: 'definition', subject: '非晶冰', required: true, expectedOutput: 'direct_answer' },
+                    { subtaskId: 'learning_route', kind: 'learning_route', subject: '非晶冰', required: true, expectedOutput: 'ordered_nodes' },
+                ],
+                learningRoute: [
+                    { nodeId: 'water', title: '水分子与氢键网络', role: 'prerequisite', order: 1, orderingBasis: 'source_order', evidenceRefs: ['e1'], reason: '基础' },
+                    { nodeId: 'ice', title: '非晶冰', role: 'core', order: 2, orderingBasis: 'source_order', evidenceRefs: ['e2'], reason: '核心' },
+                    { nodeId: 'rdf', title: '径向分布函数 g(r)', role: 'mechanism', order: 3, orderingBasis: 'source_order', evidenceRefs: ['e3'], reason: '机制' },
+                ],
+            },
+            citations: [
+                {
+                    citationId: 'e1', atomId: 'water', documentId: 'doc', sourcePath: 'Knowledge_Base/waterglass/water.md', title: '水分子', snippet: 'full source text should not be copied', startLine: 2, endLine: 3, score: 0.9,
+                },
+            ],
+            trace: {
+                ragContextPack: { fragments: [{ text: 'large internal source body' }] },
+            },
+        };
+        const projection = (0, mobileAnswerProjection_1.projectAnswerForMobile)(response);
+        expect(projection).toEqual(expect.objectContaining({
+            schemaVersion: 1,
+            primarySubject: '非晶冰',
+            directAnswer: '非晶冰是水的一种缺乏长程有序的固态形式。',
+            route: [
+                expect.objectContaining({ title: '水分子与氢键网络', role: 'prerequisite', order: 1 }),
+                expect.objectContaining({ title: '非晶冰', role: 'core', order: 2 }),
+                expect.objectContaining({ title: '径向分布函数 g(r)', role: 'mechanism', order: 3 }),
+            ],
+            citations: [expect.objectContaining({ title: '水分子', sourcePath: 'Knowledge_Base/waterglass/water.md' })],
+        }));
+        expect(JSON.stringify(projection)).not.toContain('large internal source body');
+        expect(JSON.stringify(projection)).not.toContain('full source text should not be copied');
+    });
+    test('preserves display-math Markdown while removing the appended learning route', () => {
+        const response = {
+            answer: [
+                '非晶冰是缺乏长程有序的水的固态形式。',
+                '',
+                '$$',
+                'g(r) = \\frac{1}{4\\pi r^2\\rho} \\frac{dN}{dr}',
+                '$$',
+                '',
+                '### 建议学习路径',
+                '',
+                '1. **水分子**（前置）',
+            ].join('\n'),
+            assistantMessage: 'fallback',
+            citations: [],
+            answerTaskPlan: {
+                schemaVersion: '1',
+                primarySubject: '非晶冰',
+                requestedDepth: 'standard',
+                subtasks: [
+                    { subtaskId: 'definition', kind: 'definition', subject: '非晶冰', required: true, expectedOutput: 'direct_answer' },
+                    { subtaskId: 'learning_route', kind: 'learning_route', subject: '非晶冰', required: true, expectedOutput: 'ordered_nodes' },
+                ],
+                learningRoute: [],
+            },
+        };
+        const projection = (0, mobileAnswerProjection_1.projectAnswerForMobile)(response);
+        expect(projection.directAnswer).toContain('$$\ng(r) = \\frac{1}{4\\pi r^2\\rho} \\frac{dN}{dr}\n$$');
+        expect(projection.directAnswer).not.toContain('建议学习路径');
+        expect((projection.directAnswer.match(/(?<!\\)\$\$/gu) || []).length % 2).toBe(0);
+    });
+    test('does not leave an unmatched display-math fence when the mobile budget truncates an answer', () => {
+        const longPrefix = '说明。'.repeat(500);
+        const response = {
+            answer: `${longPrefix}\n\n$$\nE = mc^2\n$$`,
+            assistantMessage: '',
+            citations: [],
+        };
+        const projection = (0, mobileAnswerProjection_1.projectAnswerForMobile)(response);
+        expect(projection.directAnswer.length).toBeLessThanOrEqual(2400);
+        expect((projection.directAnswer.match(/(?<!\\)\$\$/gu) || []).length % 2).toBe(0);
+    });
+    test('uses the response-level answer as the canonical release over a stale structured block', () => {
+        const response = {
+            answer: 'Canonical released answer for the subject.',
+            assistantMessage: 'Canonical released answer for the subject.',
+            assistantBlocks: [{
+                    blockId: 'stale',
+                    type: 'structured_answer',
+                    directAnswer: 'Stale block answer that must not win.',
+                }],
+            citations: [],
+        };
+        expect((0, mobileAnswerProjection_1.projectAnswerForMobile)(response).directAnswer).toBe('Canonical released answer for the subject.');
+    });
+});

package/dist/src/learning/queryBackend.js

@@ -42,6 +42,7 @@ exports.listGraphQueryBackendCatalog = listGraphQueryBackendCatalog;
 const crypto_1 = require("crypto");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const graphClaimMatcher_1 = require("./graphClaimMatcher");
 function evaluateAnnRunbookHealth(params) {
     const checks = [];
     const threshold = params.failureThreshold ?? 3;
@@ -295,7 +296,9 @@ function buildAtomSemanticTokens(atom) {
         .slice(0, SEMANTIC_KEYWORD_TOKEN_LIMIT));
     const titleTokens = extractSemanticTokens(atom.title, SEMANTIC_TITLE_TOKEN_LIMIT);
     const contentTokens = extractSemanticTokens(atom.content, SEMANTIC_CONTENT_TOKEN_LIMIT);
-    return uniqueTokens([...keywordTokens, ...titleTokens, ...contentTokens]);
+    const conceptTokens = (0, graphClaimMatcher_1.semanticFeatures)(`${atom.title} ${atom.content}`)
+        .filter((feature) => feature.startsWith('concept:'));
+    return uniqueTokens([...keywordTokens, ...titleTokens, ...contentTokens, ...conceptTokens]);
 }
 function buildQuerySemanticTokens(context) {
     const directTokens = uniqueTokens((context.queryTokens || [])
@@ -303,7 +306,9 @@ function buildQuerySemanticTokens(context) {
         .filter((token) => token.length > 0));
     const variantTokens = buildQueryTextVariants(context).flatMap((variant) => (extractSemanticTokens(variant, SEMANTIC_QUERY_TOKEN_LIMIT)));
     const fallbackTokens = extractSemanticTokens(context.query, SEMANTIC_QUERY_TOKEN_LIMIT);
-    return uniqueTokens([...directTokens, ...variantTokens, ...fallbackTokens]).slice(0, SEMANTIC_QUERY_TOKEN_LIMIT);
+    const conceptTokens = (0, graphClaimMatcher_1.semanticFeatures)(buildQueryTextVariants(context).join(' '))
+        .filter((feature) => feature.startsWith('concept:'));
+    return uniqueTokens([...directTokens, ...variantTokens, ...fallbackTokens, ...conceptTokens]).slice(0, SEMANTIC_QUERY_TOKEN_LIMIT);
 }
 function computeJaccard(left, right) {
     if (!left.length || !right.length) {
@@ -986,8 +991,10 @@ const DEFAULT_LOCAL_VECTOR_ACCELERATION_ADAPTER = {
 async function selectLocalVectorAnnCandidates(params) {
     const adapterId = String(params.accelerationAdapter?.id || '').trim() || LOCAL_VECTOR_ACCELERATION_ADAPTER_ID;
     try {
+        params.signal?.throwIfAborted();
         if (typeof params.accelerationAdapter.syncIndex === 'function') {
             await params.accelerationAdapter.syncIndex({
+                signal: params.signal,
                 atomCount: params.index.atomCount,
                 tokenToAtomIds: params.index.tokenToAtomIds,
                 signatureBuckets: params.index.signatureBuckets,
@@ -997,7 +1004,9 @@ async function selectLocalVectorAnnCandidates(params) {
                 indexSignature: params.index.signature,
             });
         }
+        params.signal?.throwIfAborted();
         const rawSelection = await params.accelerationAdapter.selectCandidates({
+            signal: params.signal,
             atomCount: params.index.atomCount,
             queryTokens: [...params.queryTokens],
             queryWeights: params.queryWeights,
@@ -1010,6 +1019,7 @@ async function selectLocalVectorAnnCandidates(params) {
             embeddingDimension: params.index.documentFrequency.size,
             indexSignature: params.index.signature,
         });
+        params.signal?.throwIfAborted();
         const mode = (rawSelection?.mode === 'token_prefilter'
             || rawSelection?.mode === 'token_signature_prefilter'
             || rawSelection?.mode === 'full_scan') ? rawSelection.mode : 'full_scan';
@@ -1029,6 +1039,7 @@ async function selectLocalVectorAnnCandidates(params) {
         };
     }
     catch (error) {
+        params.signal?.throwIfAborted();
         const normalizedError = String(error?.message || error || 'unknown_error')
             .replace(/\s+/g, ' ')
             .trim()
@@ -1054,7 +1065,11 @@ class LocalHybridGraphQueryBackend {
         const querySemanticTokens = buildQuerySemanticTokens(context);
         const graphFeatureIndex = buildGraphFeatureIndex(context, querySemanticTokens);
         const candidates = [];
-        context.atoms.forEach((atom) => {
+        for (const [candidateIndex, atom] of context.atoms.entries()) {
+            if (context.signal && candidateIndex % 128 === 0) {
+                await new Promise(resolve => setImmediate(resolve));
+                context.signal.throwIfAborted();
+            }
             const titleLower = atom.title.toLowerCase();
             const contentLower = atom.content.toLowerCase();
             const keywordMatches = context.queryTokens.filter((token) => atom.keywords.includes(token)).length;
@@ -1071,7 +1086,7 @@ class LocalHybridGraphQueryBackend {
                     score: Number(clamp(score, 0, 100).toFixed(4)),
                 });
             }
-        });
+        }
         candidates.sort((left, right) => right.score - left.score);
         const maxCandidates = Math.max(context.topK, Math.min(context.atoms.length, context.topK * 4));
         return {
@@ -1102,7 +1117,11 @@ class KeywordOnlyGraphQueryBackend {
     async query(context) {
         const queryVariants = buildQueryTextVariants(context);
         const candidates = [];
-        context.atoms.forEach((atom) => {
+        for (const [candidateIndex, atom] of context.atoms.entries()) {
+            if (context.signal && candidateIndex % 128 === 0) {
+                await new Promise(resolve => setImmediate(resolve));
+                context.signal.throwIfAborted();
+            }
             const titleLower = atom.title.toLowerCase();
             const contentLower = atom.content.toLowerCase();
             const keywordMatches = context.queryTokens.filter((token) => atom.keywords.includes(token)).length;
@@ -1115,7 +1134,7 @@ class KeywordOnlyGraphQueryBackend {
                     score: Number(clamp(score, 0, 100).toFixed(4)),
                 });
             }
-        });
+        }
         candidates.sort((left, right) => right.score - left.score);
         const maxCandidates = Math.max(context.topK, Math.min(context.atoms.length, context.topK * 4));
         return {
@@ -1190,6 +1209,7 @@ class LocalVectorGraphQueryBackend {
         let annCandidateSelection;
         try {
             annCandidateSelection = await selectLocalVectorAnnCandidates({
+                signal: context.signal,
                 index,
                 queryTokens: querySemanticTokens,
                 queryWeights,
@@ -1265,10 +1285,14 @@ class LocalVectorGraphQueryBackend {
             representationStrictMode: this.localVectorAccelerationRepresentationStrict,
         };
         const candidates = [];
-        atomIdsToScore.forEach((atomId) => {
+        for (const [candidateIndex, atomId] of atomIdsToScore.entries()) {
+            if (context.signal && candidateIndex % 128 === 0) {
+                await new Promise(resolve => setImmediate(resolve));
+                context.signal.throwIfAborted();
+            }
             const entry = index.entriesByAtomId.get(atomId);
             if (!entry) {
-                return;
+                continue;
             }
             const cosineSimilarity = computeCosineSimilarity(queryWeights, entry.weights);
             const semanticOverlap = computeJaccard(querySemanticTokens, entry.tokens);
@@ -1278,13 +1302,13 @@ class LocalVectorGraphQueryBackend {
                 : 0;
             const score = (cosineSimilarity * 4.2) + (semanticOverlap * 1.1) + graphFeatureBonus + signatureBonus;
             if (score <= 0) {
-                return;
+                continue;
             }
             candidates.push({
                 atomId,
                 score: Number(clamp(score, 0, 100).toFixed(4)),
             });
-        });
+        }
         candidates.sort((left, right) => right.score - left.score);
         const maxCandidates = Math.max(context.topK, Math.min(context.atoms.length, context.topK * 4));
         return {

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

@@ -135,6 +135,27 @@ describe('query backend factory', () => {
         expect(result.trace?.retrievalModes).toContain('semantic_similarity');
         expect(result.trace?.modeWeights?.semantic).toBeGreaterThan(0);
     });
+    test('local hybrid backend reuses multilingual graph concepts for comparison retrieval', async () => {
+        const backend = (0, queryBackend_1.createGraphQueryBackend)({ backend: 'local_hybrid' });
+        const atoms = [
+            makeAtom('water_glass_definition', '水杯', '水杯是透明玻璃容器。', ['水杯', '玻璃'], 'zh'),
+            makeAtom('container_material_comparison', '材料比较', '塑料杯与玻璃水杯相比更轻、更有韧性，但刚度和透明度较低。', ['塑料杯', '玻璃水杯', '比较'], 'zh'),
+        ];
+        const result = await backend.query({
+            request: {
+                query: 'compare water glass and plastic cup',
+                topK: 2,
+            },
+            query: 'compare water glass and plastic cup',
+            queryTokens: ['compare', 'water', 'glass', 'plastic', 'cup'],
+            queryVariants: ['water glass', 'plastic cup'],
+            asOf: '2026-01-01T00:00:00.000Z',
+            topK: 2,
+            atoms,
+            activeEdges: [],
+        });
+        expect(result.candidates.map((candidate) => candidate.atomId)).toContain('container_material_comparison');
+    });
     test('local vector backend includes vector similarity mode', async () => {
         const backend = (0, queryBackend_1.createGraphQueryBackend)({ backend: 'local_vector' });
         const atoms = [