noteconnection 1.7.0 → 1.9.0

package/dist/src/server.migration.test.js

@@ -102,7 +102,7 @@ function deferred() {
     });
     return { promise, resolve };
 }
-function requestJson(port, method, requestPath, body) {
+function requestJson(port, method, requestPath, body, extraHeaders) {
     return new Promise((resolve, reject) => {
         const payload = typeof body === 'undefined' ? undefined : JSON.stringify(body);
         const req = http.request({
@@ -113,9 +113,10 @@ function requestJson(port, method, requestPath, body) {
             headers: payload
                 ? {
                     'Content-Type': 'application/json',
-                    'Content-Length': Buffer.byteLength(payload)
+                    'Content-Length': Buffer.byteLength(payload),
+                    ...(extraHeaders || {})
                 }
-                : undefined
+                : (extraHeaders || undefined)
         }, (res) => {
             let text = '';
             res.setEncoding('utf8');
@@ -134,7 +135,8 @@ function requestJson(port, method, requestPath, body) {
                 }
                 resolve({
                     status: res.statusCode || 0,
-                    body: parsed
+                    body: parsed,
+                    headers: res.headers
                 });
             });
         });
@@ -178,7 +180,8 @@ function requestRaw(port, method, requestPath, payload, extraHeaders) {
                 }
                 resolve({
                     status: res.statusCode || 0,
-                    body: parsed
+                    body: parsed,
+                    headers: res.headers
                 });
             });
         });
@@ -217,10 +220,18 @@ function requestBinary(port, method, requestPath, payload, extraHeaders) {
                         parsed = text;
                     }
                 }
-                resolve({
+                const response = {
                     status: res.statusCode || 0,
-                    body: parsed
-                });
+                    body: parsed,
+                    headers: res.headers
+                };
+                // A 413 response can precede upload completion; teardown must wait until the request finishes writing.
+                if (req.writableFinished) {
+                    resolve(response);
+                }
+                else {
+                    req.once('finish', () => resolve(response));
+                }
             });
         });
         req.on('error', reject);
@@ -243,7 +254,10 @@ describe('server migration settings routes', () => {
     let buildGraphMock;
     let renderMathPngMock;
     let renderMermaidPngMock;
+    let collectMermaidRenderStageSnapshotsMock;
+    let normalizeMermaidDefinitionMock;
     let copyPngToClipboardMock;
+    let requestFrontendMermaidRenderMock;
     let originalArgv;
     beforeAll(async () => {
         temp = new TempDir('noteconnection-server');
@@ -284,7 +298,32 @@ describe('server migration settings routes', () => {
             width: 640,
             height: 360
         });
+        collectMermaidRenderStageSnapshotsMock = jest.fn().mockResolvedValue([
+            {
+                stage: 'raw',
+                svg: '<svg xmlns="http://www.w3.org/2000/svg"></svg>',
+                pngBase64: 'raw-stage-png-base64',
+                width: 640,
+                height: 360
+            }
+        ]);
+        normalizeMermaidDefinitionMock = jest.fn((source) => source);
         copyPngToClipboardMock = jest.fn().mockResolvedValue(undefined);
+        requestFrontendMermaidRenderMock = jest.fn().mockResolvedValue({
+            pngBase64: 'frontend-bridge-png-base64',
+            svg: '<svg xmlns="http://www.w3.org/2000/svg"><text>frontend</text></svg>',
+            width: 800,
+            height: 480,
+            renderer: 'frontend-bridge',
+            stages: [
+                {
+                    stage: 'final',
+                    svg: '<svg xmlns="http://www.w3.org/2000/svg"><text>frontend</text></svg>',
+                    width: 800,
+                    height: 480,
+                }
+            ]
+        });
         jest.resetModules();
         originalArgv = [...process.argv];
         process.argv = process.argv.slice(0, 2);
@@ -292,11 +331,15 @@ describe('server migration settings routes', () => {
             buildGraph: buildGraphMock
         }));
         jest.doMock('./core/PathBridge', () => ({
-            PathBridge: jest.fn().mockImplementation(() => ({}))
+            PathBridge: jest.fn().mockImplementation(() => ({
+                requestFrontendMermaidRender: requestFrontendMermaidRenderMock
+            }))
         }));
         jest.doMock('./reader_renderer', () => ({
             renderMathPng: renderMathPngMock,
-            renderMermaidPng: renderMermaidPngMock
+            renderMermaidPng: renderMermaidPngMock,
+            collectMermaidRenderStageSnapshots: collectMermaidRenderStageSnapshotsMock,
+            normalizeMermaidDefinition: normalizeMermaidDefinitionMock
         }));
         jest.doMock('./native_clipboard', () => ({
             copyPngToClipboard: copyPngToClipboardMock
@@ -441,6 +484,13 @@ describe('server migration settings routes', () => {
         expect(typeof response.body).toBe('string');
         expect(response.body).toContain('const graphData');
     });
+    test('returns current KB path when cache-busting query string is present', async () => {
+        const response = await requestJson(port, 'GET', '/api/kb-path?v=12345');
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual(expect.objectContaining({
+            kbPath: kbRoot,
+        }));
+    });
     test('rejects static traversal attempts with raw parent-segment path', async () => {
         const response = await requestJson(port, 'GET', '/../../outside/sensitive.md');
         expect(response.status).toBe(403);
@@ -511,6 +561,17 @@ describe('server migration settings routes', () => {
         const firstResponse = await firstRequest;
         expect(firstResponse.status).toBe(200);
     });
+    test.each(['incremental', 'none', 'full'])('graph build applies the requested %s recompute contract', async (mode) => {
+        const response = await requestJson(port, 'POST', '/api/build', { target: 'financial', relationRecomputeMode: mode });
+        expect(response.status).toBe(200);
+        expect(response.body.sync.summary.resolvedRelationRecomputeMode).toBe(mode);
+    });
+    test('graph build rejects unsupported recompute before construction', async () => {
+        const calls = buildGraphMock.mock.calls.length;
+        const response = await requestJson(port, 'POST', '/api/build', { target: 'financial', relationRecomputeMode: 'auto' });
+        expect(response.status).toBe(400);
+        expect(buildGraphMock.mock.calls.length).toBe(calls);
+    });
     test('returns 413 when /api/build request body exceeds size limit', async () => {
         const oversizedPayload = {
             target: 'financial',
@@ -546,6 +607,519 @@ describe('server migration settings routes', () => {
         expect(response.body.svg).toBeUndefined();
         expect(renderMermaidPngMock).toHaveBeenCalled();
     });
+    test('prefers frontend bridge for /api/render/mermaid when renderer is auto and a frontend bridge is available', async () => {
+        requestFrontendMermaidRenderMock.mockClear();
+        renderMermaidPngMock.mockClear();
+        const response = await requestJson(port, 'POST', '/api/render/mermaid', {
+            source: 'graph TD; A-->B',
+            renderer: 'auto'
+        });
+        expect(response.status).toBe(200);
+        expect(response.body).toEqual(expect.objectContaining({
+            pngBase64: 'frontend-bridge-png-base64',
+            width: 800,
+            height: 480,
+            renderer: 'frontend-bridge'
+        }));
+        expect(requestFrontendMermaidRenderMock).toHaveBeenCalledWith(expect.objectContaining({
+            source: 'graph TD; A-->B',
+            theme: 'dark',
+            includeStages: false,
+            includeSvg: false
+        }));
+        expect(renderMermaidPngMock).not.toHaveBeenCalled();
+    });
+    test('suppresses svg for Godot export profile even when includeSvg is requested', async () => {
+        const response = await requestJson(port, 'POST', '/api/render/mermaid', {
+            source: 'graph TD; A-->B',
+            renderer: 'local',
+            includeSvg: true,
+            exportProfileId: 'godot-path-mode'
+        });
+        expect(response.status).toBe(200);
+        expect(response.body.svg).toBeUndefined();
+        expect(response.body.materialization).toEqual(expect.objectContaining({
+            exportProfileId: 'godot-path-mode',
+            vectorSuppressed: true,
+            responseArtifact: 'png'
+        }));
+    });
+    test('conversation route uses turn-cache inline flow with scoped grounded response and replay headers', async () => {
+        const ingestResponse = await requestJson(port, 'POST', '/api/knowledge/ingest', {
+            incremental: true,
+            documents: [
+                {
+                    documentId: 'doc_server_conversation',
+                    sourcePath: 'Knowledge_Base/optics/absorption.md',
+                    language: 'zh',
+                    content: '# 吸收\n吸收系数与光学衰减决定材料中的能量损失。'
+                }
+            ]
+        });
+        expect(ingestResponse.status).toBe(200);
+        const turnId = 'turn_test_conversation_scope';
+        const firstResponse = await requestJson(port, 'POST', '/api/knowledge/conversation', {
+            userId: 'server_conversation_user',
+            sessionId: 'server_session_scope',
+            activeTarget: 'optics',
+            message: '解释吸收系数和光学衰减',
+            answerLanguage: 'zh',
+            scope: {
+                corpusId: 'optics',
+                languages: ['zh']
+            },
+            persistMemory: true
+        }, {
+            'X-Agent-Conversation-Turn-Id': turnId
+        });
+        expect(firstResponse.status).toBe(200);
+        expect(firstResponse.headers?.['x-agent-conversation-turn-id']).toBe(turnId);
+        expect(firstResponse.headers?.['x-agent-conversation-replay']).toBe('miss');
+        expect(firstResponse.body.result.trace.usedScope).toEqual(expect.objectContaining({
+            corpusId: 'optics',
+            source: 'scoped'
+        }));
+        expect(firstResponse.body.result.citations.length).toBeGreaterThan(0);
+        expect(firstResponse.body.result.summary.appliedMemoryCount).toBeGreaterThan(0);
+        expect(firstResponse.body.result.assistantBlocks).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                type: 'structured_answer',
+                title: '可信回答',
+                nextActionsMarkdown: expect.stringContaining('## 下一步行动'),
+            }),
+            expect.objectContaining({ type: 'knowledge_run_summary', title: '知识运行' }),
+            expect.objectContaining({ type: 'citations', title: '引用' }),
+            expect.objectContaining({ type: 'knowledge_actions', title: '知识操作' }),
+        ]));
+        const firstStructuredBlock = firstResponse.body.result.assistantBlocks.find((block) => block.type === 'structured_answer');
+        expect(String(firstStructuredBlock?.overviewMarkdown || '')).toContain('## 回答上下文');
+        expect(String(firstStructuredBlock?.explanationMarkdown || '')).toContain('## 说明');
+        expect(String(firstStructuredBlock?.evidenceMarkdown || '')).toContain('## 证据摘要');
+        expect(firstResponse.body.result.assistantBlocks).toEqual(expect.arrayContaining([
+            expect.objectContaining({ type: 'system_notice', text: expect.stringContaining('未召回') }),
+        ]));
+        const replayResponse = await requestJson(port, 'POST', '/api/knowledge/conversation', {
+            userId: 'server_conversation_user',
+            sessionId: 'server_session_scope',
+            activeTarget: 'optics',
+            message: '解释吸收系数和光学衰减',
+            answerLanguage: 'zh',
+            scope: {
+                corpusId: 'optics',
+                languages: ['zh']
+            },
+            persistMemory: true
+        }, {
+            'X-Agent-Conversation-Turn-Id': turnId
+        });
+        expect(replayResponse.status).toBe(200);
+        expect(replayResponse.headers?.['x-agent-conversation-replay']).toBe('hit');
+        expect(replayResponse.body.result.assistantBlocks).toEqual(expect.arrayContaining([
+            expect.objectContaining({ type: 'knowledge_run_summary', title: '知识运行' }),
+            expect.objectContaining({ type: 'citations', title: '引用' }),
+            expect.objectContaining({ type: 'knowledge_actions', title: '知识操作' }),
+            expect.objectContaining({ type: 'system_notice', text: expect.stringContaining('未召回') }),
+        ]));
+        const languageConflictResponse = await requestJson(port, 'POST', '/api/knowledge/conversation', {
+            userId: 'server_conversation_user',
+            sessionId: 'server_session_scope',
+            activeTarget: 'optics',
+            message: '解释吸收系数和光学衰减',
+            answerLanguage: 'en',
+            scope: {
+                corpusId: 'optics',
+                languages: ['zh']
+            },
+            persistMemory: true
+        }, {
+            'X-Agent-Conversation-Turn-Id': turnId
+        });
+        expect(languageConflictResponse.status).toBe(422);
+        expect(languageConflictResponse.body).toEqual(expect.objectContaining({
+            errorCode: 'turn_id_conflict',
+        }));
+    });
+    test('conversation turn cache separates full and slim response modes', async () => {
+        const ingestResponse = await requestJson(port, 'POST', '/api/knowledge/ingest', {
+            incremental: true,
+            documents: [{
+                    documentId: 'doc_server_response_mode',
+                    sourcePath: 'Knowledge_Base/response-mode/mode.md',
+                    language: 'en',
+                    workspaceId: 'response-mode',
+                    corpusId: 'response-mode',
+                    content: '# Response Mode Probe\nA response mode probe is a bounded technical fixture used to verify answer detail selection.\n\n## Thermal model\nThe temperature field follows $$\\frac{\\partial T}{\\partial t}=\\alpha\\nabla^2 T$$.',
+                }],
+        });
+        expect(ingestResponse.status).toBe(200);
+        const baseRequest = {
+            userId: 'server_response_mode_user',
+            sessionId: 'server_response_mode_session',
+            message: 'what is response mode probe?',
+            scope: {
+                workspaceId: 'response-mode',
+                corpusId: 'response-mode',
+                sourcePathPrefixes: ['Knowledge_Base/response-mode'],
+            },
+            persistMemory: false,
+        };
+        const fullResponse = await requestJson(port, 'POST', '/api/knowledge/conversation', { ...baseRequest, responseMode: 'full' }, { 'X-Agent-Conversation-Turn-Id': 'turn_response_mode_full' });
+        expect(fullResponse.status).toBe(200);
+        expect(fullResponse.body.result.responseMode).toBe('full');
+        expect(fullResponse.body.result.answer).toContain('Thermal model');
+        const slimResponse = await requestJson(port, 'POST', '/api/knowledge/conversation', { ...baseRequest, responseMode: 'slim' }, { 'X-Agent-Conversation-Turn-Id': 'turn_response_mode_slim' });
+        expect(slimResponse.status).toBe(200);
+        expect(slimResponse.body.result.responseMode).toBe('slim');
+        expect(slimResponse.body.result.answer).not.toContain('## Thermal model');
+        const fullReplay = await requestJson(port, 'POST', '/api/knowledge/conversation', { ...baseRequest, responseMode: 'full' }, { 'X-Agent-Conversation-Turn-Id': 'turn_response_mode_full' });
+        expect(fullReplay.status).toBe(200);
+        expect(fullReplay.headers?.['x-agent-conversation-replay']).toBe('hit');
+        expect(fullReplay.body.result.responseMode).toBe('full');
+        const definitionAliasResponse = await requestJson(port, 'POST', '/api/knowledge/conversation', { ...baseRequest, response_mode: 'definition' }, { 'X-Agent-Conversation-Turn-Id': 'turn_response_mode_definition_alias' });
+        expect(definitionAliasResponse.status).toBe(200);
+        expect(definitionAliasResponse.body.result.responseMode).toBe('slim');
+        const comprehensiveAliasResponse = await requestJson(port, 'POST', '/api/knowledge/conversation', { ...baseRequest, detailMode: 'comprehensive' }, { 'X-Agent-Conversation-Turn-Id': 'turn_response_mode_comprehensive_alias' });
+        expect(comprehensiveAliasResponse.status).toBe(200);
+        expect(comprehensiveAliasResponse.body.result.responseMode).toBe('full');
+        expect(comprehensiveAliasResponse.body.result.answer).toContain('Thermal model');
+    });
+    test('disconnect cancels a running turn once and its cached failure cannot write memory on replay', async () => {
+        const { KnowledgeLearningPlatform } = require('./learning/KnowledgeLearningPlatform');
+        const started = deferred();
+        const cancelled = deferred();
+        const run = jest.spyOn(KnowledgeLearningPlatform.prototype, 'runAgentConversation').mockImplementationOnce(async (...args) => {
+            const signal = args[1];
+            started.resolve();
+            return await new Promise((_resolve, reject) => {
+                const abort = () => { cancelled.resolve(); reject(signal.reason); };
+                if (signal.aborted)
+                    abort();
+                else
+                    signal.addEventListener('abort', abort, { once: true });
+            });
+        });
+        const payload = { userId: 'disconnected-user', message: 'Financial overview' };
+        const client = http.request({ host: '127.0.0.1', port, path: '/api/knowledge/conversation', method: 'POST', headers: {
+                'content-type': 'application/json', accept: 'text/event-stream', 'x-agent-conversation-turn-id': 'turn_disconnect_regression',
+            } }, response => response.resume());
+        client.on('error', () => undefined);
+        try {
+            client.end(JSON.stringify(payload));
+            await started.promise;
+            client.destroy();
+            await cancelled.promise;
+            const replay = await requestJson(port, 'POST', '/api/knowledge/conversation', payload, { 'x-agent-conversation-turn-id': 'turn_disconnect_regression' });
+            expect(replay.status).toBe(499);
+            expect(replay.body.errorCode).toBe('runtime_cancelled');
+            expect(run).toHaveBeenCalledTimes(1);
+            const memory = await requestJson(port, 'POST', '/api/knowledge/conversation-memory/search', { userId: 'disconnected-user', query: 'Financial overview' });
+            expect(memory.body.result.entries).toHaveLength(0);
+        }
+        finally {
+            client.destroy();
+            run.mockRestore();
+        }
+    });
+    test('conversation budget mode is adaptive by default, supports unbounded desktop full, and stays isolated in cache', async () => {
+        const baseRequest = {
+            userId: 'server_response_budget_user',
+            sessionId: 'server_response_budget_session',
+            message: 'what is water glass?',
+            responseMode: 'full',
+            persistMemory: false,
+        };
+        const adaptiveResponse = await requestJson(port, 'POST', '/api/knowledge/conversation', baseRequest, { 'X-Agent-Conversation-Turn-Id': 'turn_response_budget_adaptive' });
+        expect(adaptiveResponse.status).toBe(200);
+        expect(adaptiveResponse.body.result.responseBudget).toEqual(expect.objectContaining({
+            mode: 'adaptive',
+            tier: 'standard',
+            productCapDisabled: false,
+        }));
+        expect(adaptiveResponse.body.result.summary).toEqual(expect.objectContaining({
+            responseBudgetMode: 'adaptive',
+            responseBudgetTier: 'standard',
+        }));
+        const unboundedResponse = await requestJson(port, 'POST', '/api/knowledge/conversation', { ...baseRequest, responseBudgetMode: 'unbounded' }, { 'X-Agent-Conversation-Turn-Id': 'turn_response_budget_unbounded' });
+        expect(unboundedResponse.status).toBe(200);
+        expect(unboundedResponse.body.result.responseBudget).toEqual(expect.objectContaining({
+            mode: 'unbounded',
+            tier: 'unbounded',
+            productCapDisabled: true,
+        }));
+        expect(unboundedResponse.body.result.responseBudget.rag.productCapDisabled).toBe(true);
+        expect(unboundedResponse.body.result.summary.responseBudgetMode).toBe('unbounded');
+        const cacheConflict = await requestJson(port, 'POST', '/api/knowledge/conversation', { ...baseRequest, responseBudgetMode: 'unbounded' }, { 'X-Agent-Conversation-Turn-Id': 'turn_response_budget_adaptive' });
+        expect(cacheConflict.status).toBe(422);
+        expect(cacheConflict.body).toEqual(expect.objectContaining({ errorCode: 'turn_id_conflict' }));
+        const mobileResponse = await requestJson(port, 'POST', '/api/knowledge/conversation', { ...baseRequest, responseBudgetMode: 'unbounded', responseProfile: 'mobile_compact' }, { 'X-Agent-Conversation-Turn-Id': 'turn_response_budget_mobile' });
+        expect(mobileResponse.status).toBe(200);
+        expect(mobileResponse.body.result.responseMode).toBe('slim');
+        expect(mobileResponse.body.result.responseProfile).toBe('mobile_compact');
+        expect(mobileResponse.body.result.responseBudget).toBeUndefined();
+        expect(mobileResponse.body.result.summary.responseBudgetMode).toBe('adaptive');
+    });
+    test('disconnecting one joined consumer does not cancel the remaining consumer or duplicate execution', async () => {
+        const { KnowledgeLearningPlatform } = require('./learning/KnowledgeLearningPlatform');
+        const original = KnowledgeLearningPlatform.prototype.runAgentConversation;
+        const started = deferred();
+        const held = deferred();
+        let signal;
+        const run = jest.spyOn(KnowledgeLearningPlatform.prototype, 'runAgentConversation').mockImplementationOnce(async function (...args) {
+            signal = args[1];
+            started.resolve();
+            await held.promise;
+            return original.apply(this, args);
+        });
+        const before = await requestJson(port, 'GET', '/api/knowledge/conversation/turn-cache/diagnostics');
+        const previousJoins = before.body.result.counters.inFlightJoinCount;
+        const payload = { userId: 'joined-consumer', message: 'Financial overview', persistMemory: false };
+        const headers = { 'x-agent-conversation-turn-id': 'turn_joined_consumer' };
+        const client = http.request({ host: '127.0.0.1', port, path: '/api/knowledge/conversation', method: 'POST', headers: {
+                ...headers, 'content-type': 'application/json', accept: 'text/event-stream',
+            } }, response => response.resume());
+        client.on('error', () => undefined);
+        let second;
+        try {
+            client.end(JSON.stringify(payload));
+            await started.promise;
+            second = requestJson(port, 'POST', '/api/knowledge/conversation', payload, headers);
+            const deadline = Date.now() + 2000;
+            let joins = previousJoins;
+            while (joins === previousJoins && Date.now() < deadline) {
+                joins = (await requestJson(port, 'GET', '/api/knowledge/conversation/turn-cache/diagnostics')).body.result.counters.inFlightJoinCount;
+                if (joins === previousJoins)
+                    await new Promise(resolve => setTimeout(resolve, 5));
+            }
+            expect(joins).toBeGreaterThan(previousJoins);
+            client.destroy();
+            await new Promise(resolve => setTimeout(resolve, 25));
+            expect(signal?.aborted).toBe(false);
+            held.resolve();
+            expect((await second).status).toBe(200);
+            expect(run).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            held.resolve();
+            client.destroy();
+            await second;
+            run.mockRestore();
+        }
+    });
+    test('conversation JSON and SSE responses preserve an explicit Chinese answer language for an English no-match query', async () => {
+        const requestPayload = {
+            userId: 'server_language_no_match_user',
+            sessionId: 'server_language_no_match_session',
+            activeTarget: 'empty-language-contract',
+            message: 'what is water glass?',
+            answerLanguage: 'zh',
+            scope: {
+                corpusId: 'empty-language-contract',
+                sourcePathPrefixes: ['Knowledge_Base/empty-language-contract']
+            },
+            persistMemory: false
+        };
+        const jsonResponse = await requestJson(port, 'POST', '/api/knowledge/conversation', requestPayload, {
+            'X-Agent-Conversation-Turn-Id': 'turn_language_no_match_json'
+        });
+        expect(jsonResponse.status).toBe(200);
+        expect(jsonResponse.body.result.answer).toContain('当前范围');
+        expect(jsonResponse.body.result.answer).toContain('我暂时不能');
+        expect(jsonResponse.body.result.assistantBlocks).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                type: 'structured_answer',
+                title: '可信回答'
+            }),
+            expect.objectContaining({ type: 'knowledge_run_summary', title: '知识运行' }),
+            expect.objectContaining({ type: 'system_notice', text: expect.stringContaining('未召回') }),
+        ]));
+        const jsonStructuredBlock = jsonResponse.body.result.assistantBlocks.find((block) => block.type === 'structured_answer');
+        expect(String(jsonStructuredBlock?.overviewMarkdown || '')).toContain('## 回答上下文');
+        expect(String(jsonStructuredBlock?.explanationMarkdown || '')).toContain('## 说明');
+        expect(String(jsonStructuredBlock?.evidenceMarkdown || '')).toContain('## 证据摘要');
+        const sseResponse = await requestJson(port, 'POST', '/api/knowledge/conversation', requestPayload, {
+            Accept: 'text/event-stream',
+            'X-Agent-Conversation-Turn-Id': 'turn_language_no_match_sse'
+        });
+        expect(sseResponse.status).toBe(200);
+        expect(String(sseResponse.headers?.['content-type'] || '')).toContain('text/event-stream');
+        const completedPayload = String(sseResponse.body || '')
+            .split(/\n\n/)
+            .map((eventChunk) => eventChunk.split(/\n/).find((line) => line.startsWith('data: ')))
+            .filter((line) => Boolean(line))
+            .map((line) => JSON.parse(line.slice('data: '.length)))
+            .find((event) => event && event.type === 'turn_completed');
+        expect(completedPayload?.result?.answer).toContain('当前范围');
+        expect(completedPayload?.result?.answer).toContain('我暂时不能');
+        expect(completedPayload?.result?.assistantBlocks).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                type: 'structured_answer',
+                title: '可信回答'
+            }),
+            expect.objectContaining({ type: 'knowledge_run_summary', title: '知识运行' }),
+            expect.objectContaining({ type: 'system_notice', text: expect.stringContaining('未召回') }),
+        ]));
+        const sseStructuredBlock = completedPayload?.result?.assistantBlocks?.find((block) => block.type === 'structured_answer');
+        expect(String(sseStructuredBlock?.overviewMarkdown || '')).toContain('## 回答上下文');
+        expect(String(sseStructuredBlock?.explanationMarkdown || '')).toContain('## 说明');
+        expect(String(sseStructuredBlock?.evidenceMarkdown || '')).toContain('## 证据摘要');
+    });
+    test('conversation route auto-hydrates the active knowledge target when the learning workspace store is empty', async () => {
+        temp.mkdir(path.join('project', 'Knowledge_Base', 'waterglass'));
+        temp.file(path.join('project', 'Knowledge_Base', 'waterglass', 'water glass.md'), '# Water Glass\nwater glass 是一个装有水的玻璃容器系统。');
+        const response = await requestJson(port, 'POST', '/api/knowledge/conversation', {
+            userId: 'server_auto_hydrate_user',
+            sessionId: 'server_auto_hydrate_session',
+            activeTarget: 'waterglass',
+            message: '什么是waterglass?',
+            persistMemory: false
+        }, {
+            'X-Agent-Conversation-Turn-Id': 'turn_auto_hydrate_scope'
+        });
+        expect(response.status).toBe(200);
+        expect(response.body.result.trace.usedScope).toEqual(expect.objectContaining({
+            workspaceId: 'waterglass',
+            corpusId: 'waterglass',
+            source: 'scoped',
+        }));
+        expect(response.body.result.trace.workspaceReadiness).toEqual(expect.objectContaining({
+            status: 'ready',
+            workspaceId: 'waterglass',
+        }));
+        expect(response.body.result.trace.planner).toEqual(expect.objectContaining({
+            titleLikeQueries: expect.arrayContaining(['water glass', 'waterglass']),
+        }));
+        expect(response.body.result.citations.length).toBeGreaterThan(0);
+        const answer = String(response.body.result.answer || '');
+        expect(answer.toLowerCase()).toContain('water glass');
+        expect(answer).not.toContain('Grounded by');
+        expect(answer).not.toContain('Key evidence');
+    });
+    test('conversation route returns a bounded mobile projection without internal diagnostics', async () => {
+        const ingestResponse = await requestJson(port, 'POST', '/api/knowledge/ingest', {
+            incremental: true,
+            documents: [
+                {
+                    documentId: 'doc_mobile_amorphous_ice',
+                    sourcePath: 'Knowledge_Base/mobile-waterglass/amorphous-ice.md',
+                    language: 'en',
+                    content: '# Amorphous Ice\nAmorphous ice is a solid form of water without long-range crystalline order.\n\n## Structure\nIts structure is described by the radial distribution function $g(r)$.',
+                },
+            ],
+        });
+        expect(ingestResponse.status).toBe(200);
+        const response = await requestJson(port, 'POST', '/api/knowledge/conversation', {
+            userId: 'mobile_projection_user',
+            sessionId: 'mobile_projection_session',
+            message: 'what is amorphous ice?',
+            responseMode: 'full',
+            responseProfile: 'mobile_compact',
+            persistMemory: false,
+        }, {
+            'X-Agent-Conversation-Turn-Id': 'turn_mobile_projection',
+        });
+        expect(response.status).toBe(200);
+        const result = response.body.result;
+        expect(result).toEqual(expect.objectContaining({
+            responseMode: 'slim',
+            responseProfile: 'mobile_compact',
+            mobileProjection: expect.objectContaining({
+                schemaVersion: 1,
+                primarySubject: expect.stringContaining('Amorphous Ice'),
+                directAnswer: expect.stringContaining('Amorphous ice'),
+            }),
+            assistantBlocks: [],
+            knowledgePoints: [],
+            citations: [],
+            recalledMemories: [],
+            memoryActions: [],
+        }));
+        expect(result.trace).toBeUndefined();
+        expect(JSON.stringify(result)).not.toContain('ragContextPack');
+        expect(JSON.stringify(result)).not.toContain('knowledgeRun');
+        const jsonReplayResponse = await requestJson(port, 'POST', '/api/knowledge/conversation', {
+            userId: 'mobile_projection_user',
+            sessionId: 'mobile_projection_session',
+            message: 'what is amorphous ice?',
+            responseMode: 'full',
+            responseProfile: 'mobile_compact',
+            persistMemory: false,
+        }, {
+            'X-Agent-Conversation-Turn-Id': 'turn_mobile_projection',
+        });
+        expect(jsonReplayResponse.status).toBe(200);
+        expect(jsonReplayResponse.headers?.['x-agent-conversation-replay']).toBe('hit');
+        expect(jsonReplayResponse.body.result).toEqual(expect.objectContaining({
+            responseMode: 'slim',
+            responseProfile: 'mobile_compact',
+            assistantBlocks: [],
+            knowledgePoints: [],
+            citations: [],
+        }));
+        expect(jsonReplayResponse.body.result.trace).toBeUndefined();
+        const parseCompletedMobileEvent = (body) => String(body || '')
+            .split(/\n\n/)
+            .map((eventChunk) => eventChunk.split(/\n/).find((line) => line.startsWith('data: ')))
+            .filter((line) => Boolean(line))
+            .map((line) => JSON.parse(line.slice('data: '.length)))
+            .find((event) => event && event.type === 'turn_completed');
+        const sseInitialResponse = await requestJson(port, 'POST', '/api/knowledge/conversation', {
+            userId: 'mobile_projection_user',
+            sessionId: 'mobile_projection_session',
+            message: 'what is amorphous ice?',
+            responseMode: 'full',
+            responseProfile: 'mobile_compact',
+            persistMemory: false,
+        }, {
+            Accept: 'text/event-stream',
+            'X-Agent-Conversation-Turn-Id': 'turn_mobile_projection_sse',
+        });
+        expect(sseInitialResponse.status).toBe(200);
+        expect(String(sseInitialResponse.headers?.['content-type'] || '')).toContain('text/event-stream');
+        expect(sseInitialResponse.headers?.['x-agent-conversation-replay']).toBe('miss');
+        const sseInitialCompleted = parseCompletedMobileEvent(sseInitialResponse.body);
+        expect(sseInitialCompleted?.result).toEqual(expect.objectContaining({
+            responseMode: 'slim',
+            responseProfile: 'mobile_compact',
+            assistantBlocks: [],
+            knowledgePoints: [],
+            citations: [],
+        }));
+        expect(sseInitialCompleted?.result?.trace).toBeUndefined();
+        expect(JSON.stringify(sseInitialCompleted?.result || {})).not.toContain('ragContextPack');
+        const sseReplayResponse = await requestJson(port, 'POST', '/api/knowledge/conversation', {
+            userId: 'mobile_projection_user',
+            sessionId: 'mobile_projection_session',
+            message: 'what is amorphous ice?',
+            responseMode: 'full',
+            responseProfile: 'mobile_compact',
+            persistMemory: false,
+        }, {
+            Accept: 'text/event-stream',
+            'X-Agent-Conversation-Turn-Id': 'turn_mobile_projection_sse',
+        });
+        expect(sseReplayResponse.status).toBe(200);
+        expect(sseReplayResponse.headers?.['x-agent-conversation-replay']).toBe('hit');
+        const sseReplayCompleted = parseCompletedMobileEvent(sseReplayResponse.body);
+        expect(sseReplayCompleted?.result).toEqual(expect.objectContaining({
+            responseMode: 'slim',
+            responseProfile: 'mobile_compact',
+            assistantBlocks: [],
+            knowledgePoints: [],
+            citations: [],
+        }));
+        expect(sseReplayCompleted?.result?.trace).toBeUndefined();
+    });
+    test('returns 400 from /api/render/math when expression is empty', async () => {
+        const response = await requestJson(port, 'POST', '/api/render/math', {
+            expression: '   '
+        });
+        expect(response.status).toBe(400);
+        expect(response.body).toEqual(expect.objectContaining({
+            success: false,
+            error: 'Missing expression'
+        }));
+        expect(renderMathPngMock).not.toHaveBeenCalled();
+    });
     test('returns svg from /api/render/mermaid when includeSvg is explicitly enabled', async () => {
         const response = await requestJson(port, 'POST', '/api/render/mermaid', {
             source: 'graph TD; A-->B',