noteconnection 1.8.0 → 1.9.1

package/dist/src/agent_workspace.frontend.test.js

@@ -1137,6 +1137,30 @@ function createWorkspaceHtml() {
                     <select id="agent-workspace-scope-select"></select>
                     <div id="agent-workspace-scope-summary"></div>
                   </div>
+                  <div class="agent-answer-language-control">
+                    <label for="agent-workspace-answer-language-select">Answer language</label>
+                    <select id="agent-workspace-answer-language-select">
+                      <option value="en">English</option>
+                      <option value="zh">中文</option>
+                    </select>
+                    <div id="agent-workspace-answer-language-summary"></div>
+                  </div>
+                  <div class="agent-response-mode-control">
+                    <label for="agent-workspace-response-mode-select">Answer detail</label>
+                    <select id="agent-workspace-response-mode-select">
+                      <option value="slim">Slim</option>
+                      <option value="full">Full report</option>
+                    </select>
+                    <div id="agent-workspace-response-mode-summary"></div>
+                  </div>
+                  <div class="agent-response-budget-control" data-agent-desktop-only="true">
+                    <label for="agent-workspace-response-budget-select">Full report budget</label>
+                    <select id="agent-workspace-response-budget-select">
+                      <option value="adaptive">Adaptive</option>
+                      <option value="unbounded">No product cap</option>
+                    </select>
+                    <div id="agent-workspace-response-budget-summary"></div>
+                  </div>
                   <input id="agent-workspace-user-id" value="path_user_default" />
                   <div id="agent-workspace-chat-messages"></div>
                   <div id="agent-workspace-knowledge-points"></div>
@@ -1188,6 +1212,7 @@ function createBaseSandbox(dom) {
     const sandbox = {
         window: dom.window,
         document: dom.window.document,
+        localStorage: dom.window.localStorage,
         console: {
             log: jest.fn(),
             warn: jest.fn(),
@@ -4157,7 +4182,6 @@ describe('workspace panes controller', () => {
         const toolbarRule = styles.match(/\.agent-workspace-drawer-toolbar\s*\{[^}]*\}/)?.[0] || '';
         const workspaceScopeRule = styles.match(/\.agent-scope-control--workspace\s*\{[^}]*\}/)?.[0] || '';
         const scopeStyle = styles.match(/\.agent-scope-control\s*\{[^}]*\}/)?.[0] || '';
-        const chatPaneRule = styles.match(/\.agent-chat-pane\s*\{[^}]*\}/)?.[0] || '';
         const knowledgePointsRule = styles.match(/\.agent-knowledge-points\s*\{[^}]*\}/)?.[0] || '';
         const knowledgeCardHeaderRule = styles.match(/\.agent-knowledge-card-header\s*\{[^}]*\}/)?.[0] || '';
         const knowledgeMenuButtonRule = styles.match(/\.agent-knowledge-menu-button\s*\{[^}]*\}/)?.[0] || '';
@@ -4165,8 +4189,6 @@ describe('workspace panes controller', () => {
         expect(toolbarRule).toContain('grid-template-columns: minmax(180px, 1fr) auto');
         expect(workspaceScopeRule).toContain('grid-template-columns: minmax(94px, auto) minmax(0, 1fr)');
         expect(scopeStyle).not.toContain('position: sticky');
-        expect(chatPaneRule).toContain('display: grid');
-        expect(chatPaneRule).toContain('grid-template-rows:');
         expect(knowledgePointsRule).toContain('overflow-y: auto');
         expect(knowledgeCardHeaderRule).toContain('grid-template-columns: minmax(0, 1fr) 44px');
         expect(knowledgeMenuButtonRule).toContain('width: 44px');
@@ -4290,12 +4312,8 @@ describe('workspace panes controller', () => {
         expect(chatPaneRule).toContain('overflow-x: hidden');
         expect(chatPaneRule).toContain('overflow-y: auto');
         expect(chatPaneRule).not.toContain('overflow: hidden');
-        expect(chatPaneRule).toContain('display: grid');
-        expect(chatPaneRule).toContain('grid-template-rows:');
-        expect(chatPaneRule).toContain('minmax(128px, 0.62fr)');
-        expect(chatPaneRule).toContain('max-height: calc(100vh - 142px)');
+        // The browser verifier measures readable transcript height with optional controls present.
         expect(chatMessagesRule).toContain('overflow-y: auto');
-        expect(chatMessagesRule).toContain('min-height: 0');
         expect(knowledgePointsRule).toContain('overflow-y: auto');
         expect(knowledgePointsRule).toContain('min-height: 0');
         expect(knowledgePointsRule).toContain('scrollbar-gutter: stable');
@@ -6112,6 +6130,289 @@ describe('agent workspace learning-path integration', () => {
             corpusId: 'waterglass',
             sourcePathPrefixes: ['Knowledge_Base/waterglass'],
         });
+        expect(requestBody.answerLanguage).toBe('en');
+    });
+    test('uses the software language by default and preserves an explicit answer-language override in requests', async () => {
+        const { document, window, fetchMock, } = loadAgentWorkspaceHarness({ withI18n: true });
+        if (!fetchMock) {
+            throw new Error('expected fetch mock');
+        }
+        const completedTurn = (turnId) => createSseResponse([
+            {
+                event: 'turn_completed',
+                payload: {
+                    type: 'turn_completed',
+                    turnId,
+                    emittedAt: '2026-08-24T00:00:00.000Z',
+                    result: {
+                        assistantMessage: 'scoped response',
+                        citations: [],
+                        recalledMemories: [],
+                        memoryActions: [],
+                        knowledgePoints: [],
+                        summary: {
+                            generatedAt: '2026-08-24T00:00:00.000Z',
+                            topK: 6,
+                            returnedKnowledgePoints: 0,
+                            returnedCitations: 0,
+                            recalledMemoryCount: 0,
+                            queryEvidenceCoverageRatioPct: 0,
+                        },
+                    },
+                },
+            },
+        ]);
+        fetchMock.mockImplementationOnce(async () => completedTurn('turn_answer_language_default'));
+        fetchMock.mockImplementationOnce(async () => completedTurn('turn_answer_language_override'));
+        const selector = document.getElementById('agent-workspace-answer-language-select');
+        await window.i18n.setLanguage('zh');
+        expect(selector.value).toBe('zh');
+        const input = document.getElementById('agent-workspace-chat-input');
+        input.value = 'what is water glass?';
+        await window.NoteConnectionAgentWorkspace.sendConversation();
+        expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body || '{}')).answerLanguage).toBe('zh');
+        selector.value = 'en';
+        selector.dispatchEvent(new window.Event('change', { bubbles: true }));
+        expect(window.localStorage.getItem('nc_agent_answer_language')).toBe('en');
+        await window.i18n.setLanguage('zh');
+        expect(selector.value).toBe('en');
+        input.value = 'what is water glass?';
+        await window.NoteConnectionAgentWorkspace.sendConversation();
+        expect(JSON.parse(String(fetchMock.mock.calls[1]?.[1]?.body || '{}')).answerLanguage).toBe('en');
+    });
+    test('persists slim/full answer detail and sends the selected mode', async () => {
+        const { document, window, fetchMock } = loadAgentWorkspaceHarness({ withI18n: true });
+        if (!fetchMock) {
+            throw new Error('expected fetch mock');
+        }
+        const response = () => createSseResponse([
+            {
+                event: 'turn_completed',
+                payload: {
+                    type: 'turn_completed',
+                    turnId: 'turn_response_mode',
+                    emittedAt: '2026-09-03T00:00:00.000Z',
+                    result: {
+                        responseMode: 'full',
+                        assistantMessage: 'full report',
+                        answer: 'full report',
+                        citations: [],
+                        recalledMemories: [],
+                        memoryActions: [],
+                        knowledgePoints: [],
+                        summary: {
+                            generatedAt: '2026-09-03T00:00:00.000Z',
+                            topK: 6,
+                            returnedKnowledgePoints: 0,
+                            returnedCitations: 0,
+                            recalledMemoryCount: 0,
+                            queryEvidenceCoverageRatioPct: 0,
+                        },
+                    },
+                },
+            },
+        ]);
+        fetchMock.mockImplementationOnce(async () => response());
+        const selector = document.getElementById('agent-workspace-response-mode-select');
+        expect(selector.value).toBe('slim');
+        selector.value = 'full';
+        selector.dispatchEvent(new window.Event('change', { bubbles: true }));
+        expect(window.localStorage.getItem('nc_agent_response_mode')).toBe('full');
+        expect(String(document.getElementById('agent-workspace-response-mode-summary')?.textContent || '')).toContain('Complete');
+        const input = document.getElementById('agent-workspace-chat-input');
+        input.value = 'what is water glass?';
+        await window.NoteConnectionAgentWorkspace.sendConversation();
+        expect(JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body || '{}')).responseMode).toBe('full');
+        selector.value = 'slim';
+        selector.dispatchEvent(new window.Event('change', { bubbles: true }));
+        input.value = 'what is water glass?';
+        await window.NoteConnectionAgentWorkspace.sendConversation();
+        expect(JSON.parse(String(fetchMock.mock.calls[1]?.[1]?.body || '{}')).responseMode).toBe('slim');
+    });
+    test('persists adaptive/unbounded full-report budget and sends it only on desktop', async () => {
+        const { document, window, fetchMock } = loadAgentWorkspaceHarness({ withI18n: true });
+        if (!fetchMock) {
+            throw new Error('expected fetch mock');
+        }
+        const response = () => createSseResponse([{
+                event: 'turn_completed',
+                payload: {
+                    type: 'turn_completed',
+                    turnId: 'turn_response_budget_ui',
+                    emittedAt: '2026-09-03T00:00:00.000Z',
+                    result: {
+                        responseMode: 'full',
+                        responseBudget: { mode: 'unbounded', tier: 'unbounded', productCapDisabled: true },
+                        assistantMessage: 'full report',
+                        answer: 'full report',
+                        citations: [],
+                        recalledMemories: [],
+                        memoryActions: [],
+                        knowledgePoints: [],
+                        summary: {
+                            generatedAt: '2026-09-03T00:00:00.000Z',
+                            topK: 6,
+                            returnedKnowledgePoints: 0,
+                            returnedCitations: 0,
+                            recalledMemoryCount: 0,
+                            queryEvidenceCoverageRatioPct: 0,
+                        },
+                    },
+                },
+            }]);
+        fetchMock.mockImplementationOnce(async () => response());
+        Object.defineProperty(window.navigator, 'deviceMemory', { configurable: true, value: 8 });
+        Object.defineProperty(window.navigator, 'hardwareConcurrency', { configurable: true, value: 8 });
+        const budgetSelector = document.getElementById('agent-workspace-response-budget-select');
+        expect(budgetSelector.value).toBe('adaptive');
+        budgetSelector.value = 'unbounded';
+        budgetSelector.dispatchEvent(new window.Event('change', { bubbles: true }));
+        expect(window.localStorage.getItem('nc_agent_response_budget_mode')).toBe('unbounded');
+        const input = document.getElementById('agent-workspace-chat-input');
+        input.value = 'what is water glass?';
+        await window.NoteConnectionAgentWorkspace.sendConversation();
+        const desktopRequest = JSON.parse(String(fetchMock.mock.calls[0]?.[1]?.body || '{}'));
+        expect(desktopRequest.responseBudgetMode).toBe('unbounded');
+        expect(desktopRequest.responseBudgetCapability).toEqual({ memoryClass: 'high', workload: 'max' });
+        window.__NC_RUNTIME_CAPS = { platform: 'capacitor-android', supports_sidecar: false };
+        fetchMock.mockImplementationOnce(async () => response());
+        window.NoteConnectionAgentWorkspace.init();
+        const control = budgetSelector.closest('[data-agent-desktop-only]');
+        expect(control.hidden).toBe(true);
+        input.value = 'what is water glass?';
+        await window.NoteConnectionAgentWorkspace.sendConversation();
+        const mobileRequest = JSON.parse(String(fetchMock.mock.calls[1]?.[1]?.body || '{}'));
+        expect(mobileRequest.responseBudgetMode).toBeUndefined();
+        expect(mobileRequest.responseProfile).toBe('mobile_compact');
+    });
+    test('uses the bounded local exact path on native mobile and exposes only the compact projection', async () => {
+        const { document, window, fetchMock, } = loadAgentWorkspaceHarness({ withI18n: true });
+        if (!fetchMock) {
+            throw new Error('expected fetch mock');
+        }
+        window.__NC_RUNTIME_CAPS = {
+            platform: 'capacitor-android',
+            supports_sidecar: false,
+        };
+        const matches = [
+            { id: 'amorphous_ice', label: '非晶冰', sourceUri: 'Knowledge_Base/waterglass/amorphous-ice.md' },
+            { id: 'water_structure', label: '水分子与氢键网络', sourceUri: 'Knowledge_Base/waterglass/amorphous-ice.md' },
+            { id: 'radial_distribution', label: '径向分布函数 g(r)', sourceUri: 'Knowledge_Base/waterglass/amorphous-ice.md' },
+        ];
+        const queriedTerms = [];
+        const queryKnowledgeBaseExact = jest.fn(async ({ query }) => {
+            queriedTerms.push(query);
+            return { matches: query === '非晶冰' ? matches : [] };
+        });
+        const readContent = jest.fn(async () => [
+            '# 非晶冰',
+            '',
+            '非晶冰是水的一种缺乏长程有序的固态形式。',
+            '',
+            '## 常见用例与性能指标',
+            '该章节不应进入移动端直接回答。',
+        ].join('\n'));
+        window.NoteConnectionStorage = {
+            createProvider: () => ({ queryKnowledgeBaseExact, readContent }),
+        };
+        const input = document.getElementById('agent-workspace-chat-input');
+        input.value = '什么是非晶冰？我应该通过哪些知识点学习？';
+        await window.NoteConnectionAgentWorkspace.sendConversation();
+        expect(queryKnowledgeBaseExact).toHaveBeenCalled();
+        expect(queriedTerms).toContain('非晶冰');
+        expect(readContent).toHaveBeenCalledWith('Knowledge_Base/waterglass/amorphous-ice.md');
+        expect(fetchMock).not.toHaveBeenCalled();
+        const result = window.__NC_LAST_AGENT_CONVERSATION_RESULT;
+        expect(result).toEqual(expect.objectContaining({
+            responseProfile: 'mobile_compact',
+            mobileProjection: expect.objectContaining({
+                primarySubject: '非晶冰',
+                directAnswer: '非晶冰是水的一种缺乏长程有序的固态形式。',
+                route: expect.arrayContaining([
+                    expect.objectContaining({ title: '非晶冰', role: 'core' }),
+                    expect.objectContaining({ title: '水分子与氢键网络' }),
+                ]),
+            }),
+        }));
+        expect(result.knowledgePoints).toEqual([]);
+        expect(result.citations).toEqual([]);
+        expect(result.trace).toBeUndefined();
+        expect(JSON.stringify(result)).not.toContain('该章节不应进入移动端直接回答');
+        const renderedAssistant = Array.from(document.querySelectorAll('.agent-chat-message-assistant')).map((node) => String(node.textContent || '')).join('\n');
+        expect(renderedAssistant).toContain('建议学习路径');
+        expect(renderedAssistant).toContain('水分子与氢键网络');
+    });
+    test('falls back to the bounded remote projection when the native exact index has no match', async () => {
+        const { document, window, fetchMock, } = loadAgentWorkspaceHarness({ withI18n: true });
+        if (!fetchMock) {
+            throw new Error('expected fetch mock');
+        }
+        window.__NC_RUNTIME_CAPS = {
+            platform: 'capacitor-android',
+            supports_sidecar: false,
+        };
+        const queryKnowledgeBaseExact = jest.fn(async () => ({ matches: [] }));
+        window.NoteConnectionStorage = {
+            createProvider: () => ({ queryKnowledgeBaseExact }),
+        };
+        fetchMock.mockImplementationOnce(async (_url, init) => {
+            const request = JSON.parse(String(init?.body || '{}'));
+            expect(request.responseProfile).toBe('mobile_compact');
+            return createSseResponse([
+                {
+                    event: 'turn_completed',
+                    payload: {
+                        type: 'turn_completed',
+                        turnId: 'turn_remote_mobile_projection',
+                        emittedAt: '2026-08-01T00:00:00.000Z',
+                        result: {
+                            responseProfile: 'mobile_compact',
+                            assistantMessage: '非晶冰是缺乏长程有序的水的固态形式。',
+                            answer: '非晶冰是缺乏长程有序的水的固态形式。',
+                            mobileProjection: {
+                                schemaVersion: 1,
+                                primarySubject: '非晶冰',
+                                directAnswer: '非晶冰是缺乏长程有序的水的固态形式。',
+                                route: [
+                                    { nodeId: 'water', title: '水分子与氢键网络', role: 'prerequisite', order: 1 },
+                                    { nodeId: 'ice', title: '非晶冰', role: 'core', order: 2 },
+                                ],
+                                citations: [],
+                            },
+                            assistantBlocks: [],
+                            knowledgePoints: [],
+                            citations: [],
+                            recalledMemories: [],
+                            memoryActions: [],
+                            summary: {
+                                generatedAt: '2026-08-01T00:00:00.000Z',
+                                topK: 6,
+                                returnedKnowledgePoints: 2,
+                                returnedCitations: 0,
+                                recalledMemoryCount: 0,
+                                appliedMemoryCount: 0,
+                                queryEvidenceCoverageRatioPct: 100,
+                            },
+                        },
+                    },
+                },
+            ]);
+        });
+        const input = document.getElementById('agent-workspace-chat-input');
+        input.value = '什么是非晶冰？';
+        await window.NoteConnectionAgentWorkspace.sendConversation();
+        expect(queryKnowledgeBaseExact).toHaveBeenCalled();
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(String(fetchMock.mock.calls[0]?.[1]?.headers?.Accept || '')).toBe('text/event-stream');
+        const result = window.__NC_LAST_AGENT_CONVERSATION_RESULT;
+        expect(result).toEqual(expect.objectContaining({
+            responseProfile: 'mobile_compact',
+            mobileProjection: expect.objectContaining({ primarySubject: '非晶冰' }),
+        }));
+        expect(result.trace).toBeUndefined();
+        const renderedAssistant = Array.from(document.querySelectorAll('.agent-chat-message-assistant')).map((node) => String(node.textContent || '')).join('\n');
+        expect(renderedAssistant).toContain('建议学习路径');
+        expect(renderedAssistant).toContain('非晶冰');
     });
     test('prefers SSE turn streaming for conversation and renders the completed turn payload', async () => {
         const { document, window, fetchMock, } = loadAgentWorkspaceHarness();
@@ -6669,6 +6970,9 @@ describe('agent workspace learning-path integration', () => {
         }));
         window.marked = {
             parse: jest.fn((markdown) => {
+                if (markdown.includes('Scoped Answer')) {
+                    return '<p>Scoped Answer with inline math $E=mc^2$ and display math $$\\frac{\\partial T}{\\partial t}=\\alpha\\nabla^2 T$$.</p>';
+                }
                 if (markdown.includes('## Answer Context')) {
                     return ('<h2>Answer Context</h2>'
                         + '<ul><li>Relevant knowledge points: <strong>1</strong></li></ul>');
@@ -6713,7 +7017,7 @@ describe('agent workspace learning-path integration', () => {
                                 blockId: 'block_structured_answer_1',
                                 type: 'structured_answer',
                                 title: 'Grounded Answer',
-                                directAnswer: 'Scoped Answer',
+                                directAnswer: 'Scoped Answer with inline math $E=mc^2$ and display math $$\\frac{\\partial T}{\\partial t}=\\alpha\\nabla^2 T$$.',
                                 overviewMarkdown: '## Answer Context\n\n- Relevant knowledge points: **1**\n- Citations returned: **1**\n- Scoped memories recalled: **0**',
                                 explanationMarkdown: '## Explanation\n\n**Blocks Citation** is the current best scoped anchor.\n\nInline math $E=mc^2$ and a diagram:\n\n```mermaid\ngraph TD;A-->B;\n```',
                                 evidenceMarkdown: '## Evidence Summary\n\n1. **Blocks Citation** (Knowledge_Base/optics/blocks.md:18)\n   - Scoped snippet',
@@ -6836,6 +7140,12 @@ describe('agent workspace learning-path integration', () => {
                                     },
                                 ],
                             },
+                            {
+                                blockId: 'block_knowledge_actions_1',
+                                type: 'knowledge_actions',
+                                title: 'Knowledge Actions',
+                                atomIds: ['atom_blocks_1'],
+                            },
                         ],
                         citations: [
                             {
@@ -6905,13 +7215,45 @@ describe('agent workspace learning-path integration', () => {
         expect(assistantNode?.querySelector('[data-structured-answer-section="overviewMarkdown"]')).toBeNull();
         expect(assistantNode?.querySelector('[data-structured-answer-section="explanationMarkdown"]')).toBeNull();
         expect(assistantNode?.querySelector('[data-structured-answer-section="evidenceMarkdown"]')).toBeNull();
+        expect(assistantNode?.querySelector('[data-structured-answer-section="nextActionsMarkdown"]')).toBeNull();
         expect(String(assistantNode?.textContent || '')).not.toContain('Answer Context');
         expect(String(assistantNode?.textContent || '')).not.toContain('Evidence Summary');
+        expect(String(assistantNode?.textContent || '')).not.toContain('Explanation');
         expect(String(assistantNode?.textContent || '')).not.toContain('Knowledge Run');
+        expect(String(assistantNode?.textContent || '')).not.toContain('Knowledge Actions');
         expect(String(assistantNode?.textContent || '')).not.toContain('Inspect Run');
-        expect(renderMathInElement).not.toHaveBeenCalled();
-        expect(window.mermaid.initialize).not.toHaveBeenCalled();
+        expect(String(assistantNode?.querySelector('[data-structured-answer-section="directAnswer"]')?.textContent || '')).toContain('$E=mc^2$');
+        expect(String(assistantNode?.querySelector('[data-structured-answer-section="directAnswer"]')?.textContent || '')).toContain('$$\\frac{\\partial T}{\\partial t}=\\alpha\\nabla^2 T$$');
+        expect(renderMathInElement).toHaveBeenCalledTimes(1);
+        expect(window.mermaid.initialize).toHaveBeenCalledTimes(1);
         expect(mermaidRender).not.toHaveBeenCalled();
+        const nextActionsToggle = assistantNode?.querySelector('[data-structured-answer-next-actions-toggle]');
+        expect(nextActionsToggle).not.toBeNull();
+        expect(nextActionsToggle?.getAttribute('aria-expanded')).toBe('false');
+        expect(nextActionsToggle?.getAttribute('aria-label')).toBe('Show next actions');
+        expect(assistantNode?.querySelector('[data-structured-answer-next-actions-panel]')).toBeNull();
+        nextActionsToggle?.click();
+        await Promise.resolve();
+        expect(nextActionsToggle?.getAttribute('aria-expanded')).toBe('true');
+        expect(nextActionsToggle?.getAttribute('aria-label')).toBe('Hide next actions');
+        expect(assistantNode?.querySelector('[data-structured-answer-next-actions-panel]')).not.toBeNull();
+        expect(String(assistantNode?.textContent || '')).toContain('Next Actions');
+        expect(renderMathInElement).toHaveBeenCalled();
+        nextActionsToggle?.click();
+        expect(nextActionsToggle?.getAttribute('aria-expanded')).toBe('false');
+        expect(assistantNode?.querySelector('[data-structured-answer-next-actions-panel]')).toBeNull();
+        const markdownRuntime = window.NoteConnectionMarkdownRuntime;
+        const renderMarkdownInto = markdownRuntime.renderMarkdownInto;
+        markdownRuntime.renderMarkdownInto = jest.fn((container, markdown) => {
+            if (markdown.includes('## Next Actions')) {
+                return Promise.reject(new Error('next actions renderer failure'));
+            }
+            return renderMarkdownInto(container, markdown);
+        });
+        nextActionsToggle?.click();
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(nextActionsToggle?.getAttribute('aria-expanded')).toBe('false');
+        expect(assistantNode?.querySelector('[data-structured-answer-next-actions-panel]')).toBeNull();
         expect(window.NoteConnectionAgentWorkspace.getLastConversationResult()?.assistantBlocks?.[0]).toEqual(expect.objectContaining({
             overviewMarkdown: expect.stringContaining('## Answer Context'),
             evidenceMarkdown: expect.stringContaining('## Evidence Summary'),
@@ -6924,6 +7266,63 @@ describe('agent workspace learning-path integration', () => {
             ]),
         }));
     });
+    test('keeps non-public assistant blocks out of the chat release surface', async () => {
+        const { document, window, fetchMock } = loadAgentWorkspaceHarness({ withI18n: true });
+        if (!fetchMock) {
+            throw new Error('expected fetch mock');
+        }
+        fetchMock.mockImplementationOnce(async () => createSseResponse([
+            {
+                event: 'turn_completed',
+                payload: {
+                    type: 'turn_completed',
+                    turnId: 'turn_public_projection_only',
+                    emittedAt: '2026-04-13T00:02:00.000Z',
+                    result: {
+                        assistantMessage: 'Grounded Answer fallback',
+                        answer: 'Grounded Answer fallback',
+                        assistantBlocks: [
+                            {
+                                blockId: 'structured_public',
+                                type: 'structured_answer',
+                                title: 'Grounded Answer',
+                                directAnswer: 'Public answer.',
+                                knowledgePointCount: 0,
+                                citationCount: 0,
+                                recalledMemoryCount: 0,
+                            },
+                            { blockId: 'metadata_markdown', type: 'main_markdown', markdown: '# Answer Context' },
+                            { blockId: 'metadata_html', type: 'html_artifact', title: 'Evidence Summary', html: '<p>leak</p>' },
+                            { blockId: 'metadata_notice', type: 'system_notice', text: 'internal notice' },
+                            { blockId: 'metadata_citations', type: 'citations', title: 'Citations', citations: [] },
+                            { blockId: 'metadata_actions', type: 'knowledge_actions', title: 'Knowledge Actions', atomIds: [] },
+                        ],
+                        knowledgePoints: [],
+                        citations: [],
+                        recalledMemories: [],
+                        memoryActions: [],
+                        summary: { generatedAt: '2026-04-13T00:02:00.000Z', topK: 6, returnedKnowledgePoints: 0, returnedCitations: 0, recalledMemoryCount: 0, appliedMemoryCount: 0, queryEvidenceCoverageRatioPct: 100 },
+                        trace: {},
+                    },
+                },
+            },
+        ]));
+        const input = document.getElementById('agent-workspace-chat-input');
+        input.value = 'public projection';
+        await window.NoteConnectionAgentWorkspace.sendConversation();
+        const renderedMessages = document.querySelectorAll('.agent-chat-message-rendered.agent-chat-message-assistant');
+        expect(renderedMessages).toHaveLength(1);
+        const assistantNode = renderedMessages[0];
+        expect(assistantNode.querySelectorAll('.agent-chat-structured-answer-card')).toHaveLength(1);
+        expect(assistantNode.querySelectorAll('.agent-chat-render-block-main_markdown')).toHaveLength(0);
+        expect(assistantNode.querySelectorAll('.agent-chat-inline-artifact')).toHaveLength(0);
+        expect(assistantNode.querySelectorAll('.agent-chat-knowledge-run-card')).toHaveLength(0);
+        expect(assistantNode.textContent).toContain('Public answer.');
+        expect(assistantNode.textContent).not.toContain('Answer Context');
+        expect(assistantNode.textContent).not.toContain('Evidence Summary');
+        expect(assistantNode.textContent).not.toContain('internal notice');
+        expect(assistantNode.textContent).not.toContain('Knowledge Actions');
+    });
     test('inspects durable knowledge-run artifacts from structured conversation blocks', async () => {
         const { document, window, fetchMock, } = loadAgentWorkspaceHarness({ withI18n: true });
         if (!fetchMock) {

package/dist/src/android.knowledgebase.picker.contract.test.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+describe('Android knowledge-base picker contract', () => {
+    const repoRoot = path.resolve(__dirname, '..');
+    const templatePath = path.join(repoRoot, 'src-tauri', 'mobile', 'android', 'KnowledgeBasePickerBridge.kt');
+    const patcherPath = path.join(repoRoot, 'scripts', 'apply-tauri-android-pathmode.js');
+    const rustPath = path.join(repoRoot, 'src-tauri', 'src', 'lib.rs');
+    const sourceManagerPath = path.join(repoRoot, 'src', 'frontend', 'source_manager.js');
+    test('uses SAF tree permissions and bounded app-local streaming import', () => {
+        const template = fs.readFileSync(templatePath, 'utf8');
+        expect(template).toContain('ACTION_OPEN_DOCUMENT_TREE');
+        expect(template).toContain('FLAG_GRANT_PERSISTABLE_URI_PERMISSION');
+        expect(template).toContain('takePersistableUriPermission');
+        expect(template).toContain('context.filesDir, "Knowledge_Base"');
+        expect(template).toContain('MAX_DOCUMENT_BYTES');
+        expect(template).toContain('MAX_TOTAL_BYTES');
+        expect(template).toContain('input.copyTo(output, 32 * 1024)');
+        expect(template).toContain('replaceImportedTree');
+        expect(template).toContain('Duplicate import path');
+        expect(template).toContain('knowledge_base_import_journal.v1.json');
+        expect(template).toContain('recoverImportTransaction(activity.applicationContext)');
+        expect(template).toContain('target-backed-up');
+        expect(template).toContain('target-activated');
+        expect(template).toContain('invalid_import_journal');
+        expect(template).toContain('output.fd.sync()');
+        expect(template).toContain('isSafeTransactionPath');
+        expect(template).toContain('isKnownJournalPhase');
+        expect(template).toContain('recovered_previous');
+        expect(template).toContain('importInFlight');
+        expect(template).toContain('import_in_progress');
+        expect(template).toContain('synchronized(importLock)');
+        expect(template).toContain('Retaining import backup for startup recovery');
+        expect(template).toContain('if (!backupRoot.exists())');
+        expect(template).toContain('import_recovery_pending');
+        expect(template).toContain('Unable to restore import backup; retaining journal for retry');
+        expect(template).toContain('orphan_recovery_pending');
+        const importFailureCatch = template.match(/Log\.e\(TAG, "Knowledge base import failed"[\s\S]*?writeResult\(resultFile, "failed", "", error\.message \?: "import_failed"\)/)?.[0];
+        expect(importFailureCatch).toBeDefined();
+        expect(importFailureCatch).not.toContain('backupRoot.deleteRecursively()');
+        expect(template).not.toContain('readText()');
+    });
+    test('patches picker bridge into mobile-slim without enabling Godot', () => {
+        const patcher = fs.readFileSync(patcherPath, 'utf8');
+        expect(patcher).toContain('KnowledgeBasePickerBridge.kt');
+        expect(patcher).toContain('patchKnowledgeBasePicker');
+        expect(patcher).toContain('KnowledgeBasePickerBridge.bindActivity(this)');
+        expect(patcher).toContain('removePathmodeAssets');
+    });
+    test('exposes additive request/poll commands and enables the Android capability', () => {
+        const rust = fs.readFileSync(rustPath, 'utf8');
+        const sourceManager = fs.readFileSync(sourceManagerPath, 'utf8');
+        expect(rust).toContain('request_android_knowledge_base_picker');
+        expect(rust).toContain('consume_android_knowledge_base_picker_result');
+        expect(rust).toContain('kb_import_mode: "android-saf-copy"');
+        expect(sourceManager).toContain("request_kb_path_change");
+        expect(sourceManager).toContain("poll_kb_path_change");
+        expect(sourceManager).toContain('Timed out waiting for Android knowledge base import.');
+    });
+    test('keeps Android slim packaging size-first and clears stale generated outputs', () => {
+        const runner = fs.readFileSync(path.join(repoRoot, 'scripts', 'run-tauri-android.js'), 'utf8');
+        expect(runner).toContain("CARGO_PROFILE_RELEASE_OPT_LEVEL || 'z'");
+        expect(runner).toContain('CARGO_PROFILE_RELEASE_CODEGEN_UNITS, 1');
+        expect(runner).toContain("CARGO_PROFILE_RELEASE_LTO || 'thin'");
+        expect(runner).toContain('cleanAndroidSlimOutputs');
+        expect(runner).toContain('!includeGodotPathmode');
+    });
+});