noteconnection 1.8.0 → 1.9.0

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

@@ -220,11 +220,18 @@ function requestBinary(port, method, requestPath, payload, extraHeaders) {
                         parsed = text;
                     }
                 }
-                resolve({
+                const response = {
                     status: res.statusCode || 0,
                     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);
@@ -369,7 +376,7 @@ describe('server migration settings routes', () => {
         expect(response.status).toBe(200);
         expect(response.body.folders).toEqual(['financial', 'legal']);
     });
-    test.skip('returns runtime diagnostics with wasm parity state and no auth token exposure', async () => {
+    test('returns runtime diagnostics with wasm parity state and no auth token exposure', async () => {
         const response = await requestJson(port, 'GET', '/api/runtime-diagnostics');
         expect(response.status).toBe(200);
         expect(response.body).toEqual(expect.objectContaining({
@@ -433,7 +440,7 @@ describe('server migration settings routes', () => {
         const serverSource = fs.readFileSync(serverSourcePath, 'utf8');
         expect(serverSource).not.toMatch(/fs\.(existsSync|mkdirSync|readdirSync|writeFileSync|readFileSync|statSync|accessSync)\b/);
     });
-    test.skip('merges available targets from folders and cached graph artifacts', async () => {
+    test('merges available targets from folders and cached graph artifacts', async () => {
         const response = await requestJson(port, 'GET', '/api/available-targets');
         expect(response.status).toBe(200);
         expect(response.body.targets).toEqual(['financial', 'legal', 'robotics']);
@@ -443,20 +450,20 @@ describe('server migration settings routes', () => {
         expect(response.status).toBe(200);
         expect(response.body.content).toContain('Inside KB root');
     });
-    test.skip('serves /api/content for legacy Knowledge_Base-style paths', async () => {
+    test('serves /api/content for legacy Knowledge_Base-style paths', async () => {
         const legacyPath = 'C:\\snapshot\\NoteConnection_app\\Knowledge_Base\\financial\\overview.md';
         const response = await requestJson(port, 'GET', `/api/content?path=${encodeURIComponent(legacyPath)}`);
         expect(response.status).toBe(200);
         expect(response.body.content).toContain('Financial Overview');
     });
-    test.skip('rejects /api/content requests outside configured KB root', async () => {
+    test('rejects /api/content requests outside configured KB root', async () => {
         const response = await requestJson(port, 'GET', `/api/content?path=${encodeURIComponent(outsideFilePath)}`);
         expect(response.status).toBe(403);
         expect(response.body).toEqual(expect.objectContaining({
             error: expect.stringContaining('outside configured knowledge base')
         }));
     });
-    test.skip('check-cache and restore-cache endpoints work for named targets', async () => {
+    test('check-cache and restore-cache endpoints work for named targets', async () => {
         const cacheResponse = await requestJson(port, 'GET', '/api/check-cache?target=financial');
         expect(cacheResponse.status).toBe(200);
         expect(cacheResponse.body).toEqual(expect.objectContaining({
@@ -498,7 +505,7 @@ describe('server migration settings routes', () => {
             error: expect.stringContaining('Invalid static file path')
         }));
     });
-    test.skip('deduplicates same build request while first build is in-flight', async () => {
+    test('deduplicates same build request while first build is in-flight', async () => {
         const hold = deferred();
         buildGraphMock.mockImplementationOnce(() => hold.promise);
         const payload = {
@@ -534,7 +541,7 @@ describe('server migration settings routes', () => {
             })
         }));
     });
-    test.skip('returns 409 when a different build request arrives during active build', async () => {
+    test('returns 409 when a different build request arrives during active build', async () => {
         const hold = deferred();
         buildGraphMock.mockImplementationOnce(() => hold.promise);
         const firstRequest = requestJson(port, 'POST', '/api/build', {
@@ -554,7 +561,18 @@ describe('server migration settings routes', () => {
         const firstResponse = await firstRequest;
         expect(firstResponse.status).toBe(200);
     });
-    test.skip('returns 413 when /api/build request body exceeds size limit', async () => {
+    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',
             pad: 'x'.repeat(700 * 1024)
@@ -565,7 +583,7 @@ describe('server migration settings routes', () => {
             error: expect.stringContaining('too large')
         }));
     });
-    test.skip('returns 400 when /api/build request body contains invalid json', async () => {
+    test('returns 400 when /api/build request body contains invalid json', async () => {
         const response = await requestRaw(port, 'POST', '/api/build', '{"target":', {
             'Content-Type': 'application/json'
         });
@@ -643,7 +661,9 @@ describe('server migration settings routes', () => {
         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']
@@ -661,10 +681,29 @@ describe('server migration settings routes', () => {
         }));
         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']
@@ -675,6 +714,254 @@ describe('server migration settings routes', () => {
         });
         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'));
@@ -707,6 +994,121 @@ describe('server migration settings routes', () => {
         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: '   '
@@ -736,7 +1138,7 @@ describe('server migration settings routes', () => {
         expect(response.status).toBe(200);
         expect(response.body.svg).toContain('<svg');
     });
-    test.skip('returns 415 when /api/kb-path request content type is not json', async () => {
+    test('returns 415 when /api/kb-path request content type is not json', async () => {
         const response = await requestRaw(port, 'POST', '/api/kb-path', 'kbPath=/tmp', {
             'Content-Type': 'text/plain'
         });
@@ -745,7 +1147,7 @@ describe('server migration settings routes', () => {
             error: expect.stringContaining('Unsupported Content-Type')
         }));
     });
-    test.skip('accepts binary PNG upload for clipboard copy without base64 JSON payload', async () => {
+    test('accepts binary PNG upload for clipboard copy without base64 JSON payload', async () => {
         const tinyPng = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO7+VwAAAABJRU5ErkJggg==', 'base64');
         const response = await requestBinary(port, 'POST', '/api/clipboard/image-binary', tinyPng, {
             'Content-Type': 'image/png'
@@ -756,7 +1158,7 @@ describe('server migration settings routes', () => {
             transport: 'binary'
         }));
     });
-    test.skip('returns 415 for unsupported binary clipboard content type', async () => {
+    test('returns 415 for unsupported binary clipboard content type', async () => {
         const response = await requestRaw(port, 'POST', '/api/clipboard/image-binary', 'not-a-png', {
             'Content-Type': 'text/plain'
         });
@@ -765,7 +1167,7 @@ describe('server migration settings routes', () => {
             error: expect.stringContaining('Unsupported Content-Type')
         }));
     });
-    test.skip('returns 413 when binary clipboard payload exceeds limit', async () => {
+    test('returns 413 when binary clipboard payload exceeds limit', async () => {
         const oversized = Buffer.alloc(TEST_CLIPBOARD_LIMIT_BYTES + 1, 0x00);
         const response = await requestBinary(port, 'POST', '/api/clipboard/image-binary', oversized, {
             'Content-Type': 'application/octet-stream'