noteconnection 1.7.0 → 1.9.0

package/dist/src/notemd.diagram.pipeline.test.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Diagram Pipeline unit tests — validates intent inference, planner,
+ * spec validation, and response parser (all pure functions).
+ */
+const intent_1 = require("./notemd/diagram/intent");
+const planner_1 = require("./notemd/diagram/planner");
+const diagramSpec_1 = require("./notemd/diagram/diagramSpec");
+const diagramSpecResponseParser_1 = require("./notemd/diagram/diagramSpecResponseParser");
+const diagramSpecPrompt_1 = require("./notemd/diagram/prompts/diagramSpecPrompt");
+// ── Intent Inference ──
+describe('Diagram Intent Inference', () => {
+    test('empty content defaults to mindmap', () => {
+        const result = (0, intent_1.inferDiagramIntent)('');
+        expect(result.intent).toBe('mindmap');
+        expect(result.confidence).toBeLessThan(0.5);
+    });
+    test('whitespace-only defaults to mindmap', () => {
+        const result = (0, intent_1.inferDiagramIntent)('   \n  ');
+        expect(result.intent).toBe('mindmap');
+    });
+    test('data table with numeric values infers dataChart', () => {
+        const md = [
+            '| Metric | Value |',
+            '| ------ | ----- |',
+            '| CPU    | 85%   |',
+            '| Memory | 72%   |',
+            'Monthly growth trend: 12% increase.',
+        ].join('\n');
+        const result = (0, intent_1.inferDiagramIntent)(md);
+        expect(result.intent).toBe('dataChart');
+        expect(result.confidence).toBeGreaterThan(0.8);
+    });
+    test('request-response vocabulary infers sequence', () => {
+        const md = 'Client sends request to server. Server processes and returns response. Gateway routes the request. Service handles the response.';
+        const result = (0, intent_1.inferDiagramIntent)(md);
+        expect(result.intent).toBe('sequence');
+    });
+    test('arrow markers infers sequence', () => {
+        const result = (0, intent_1.inferDiagramIntent)('User -> API -> Database -> Response');
+        expect(result.intent).toBe('sequence');
+    });
+    test('database schema vocabulary infers erDiagram', () => {
+        const md = 'The entity has a primary key. The table references a foreign key. The schema defines the column.';
+        const result = (0, intent_1.inferDiagramIntent)(md);
+        expect(result.intent).toBe('erDiagram');
+    });
+    test('state transition vocabulary infers stateDiagram', () => {
+        const md = 'The state machine transitions from pending to running. Completed state follows. Failed state triggers retry.';
+        const result = (0, intent_1.inferDiagramIntent)(md);
+        expect(result.intent).toBe('stateDiagram');
+    });
+    test('workflow/process vocabulary infers flowchart', () => {
+        const md = 'Step 1: Validate input. If valid then process, else stop. Continue to next step.';
+        const result = (0, intent_1.inferDiagramIntent)(md);
+        expect(result.intent).toBe('flowchart');
+    });
+    test('numbered steps infers flowchart', () => {
+        const md = '1. First step\n2. Second step\n3. Third step';
+        const result = (0, intent_1.inferDiagramIntent)(md);
+        expect(result.intent).toBe('flowchart');
+    });
+    test('concept map keywords infers canvasMap', () => {
+        const md = 'This is a concept map showing the knowledge graph of spatial clusters.';
+        const result = (0, intent_1.inferDiagramIntent)(md);
+        expect(result.intent).toBe('canvasMap');
+    });
+    test('general content defaults to mindmap', () => {
+        const result = (0, intent_1.inferDiagramIntent)('The quick brown fox jumps over the lazy dog.');
+        expect(result.intent).toBe('mindmap');
+        expect(result.confidence).toBeGreaterThan(0.4);
+    });
+});
+// ── Planner ──
+describe('Diagram Planner', () => {
+    test('best-fit mode routes dataChart to vega-lite', () => {
+        const md = '| A | B |\n| - | - |\n| 1 | 2 |\n| 3 | 4 |\nchart';
+        const plan = (0, planner_1.buildDiagramPlan)(md, { compatibilityMode: 'best-fit' });
+        expect(plan.renderTarget).toBe('vega-lite');
+    });
+    test('best-fit mode routes sequence to mermaid', () => {
+        const md = 'Client sends request. Server returns response. Gateway routes. Service processes.';
+        const plan = (0, planner_1.buildDiagramPlan)(md, { compatibilityMode: 'best-fit' });
+        expect(plan.intent).toBe('sequence');
+        expect(plan.renderTarget).toBe('mermaid');
+        expect(plan.mermaidDiagramType).toBe('sequenceDiagram');
+    });
+    test('legacy-mermaid mode forces mermaid render target', () => {
+        const md = '| A | B |\n| - | - |\n| 1 | 2 |\n| 3 | 4 |\nchart share distribution';
+        const plan = (0, planner_1.buildDiagramPlan)(md, { compatibilityMode: 'legacy-mermaid' });
+        expect(plan.renderTarget).toBe('mermaid');
+        expect(plan.legacyCompatibilityMode).toBe(true);
+    });
+    test('explicit intent overrides inference', () => {
+        const plan = (0, planner_1.buildDiagramPlan)('any content', {
+            requestedIntent: 'flowchart',
+            compatibilityMode: 'best-fit'
+        });
+        expect(plan.intent).toBe('flowchart');
+        expect(plan.confidence).toBeGreaterThan(0.9);
+    });
+    test('mindmap intent resolves to mindmap mermaid type', () => {
+        const plan = (0, planner_1.buildDiagramPlan)('# Just a regular note about topics', { compatibilityMode: 'best-fit' });
+        expect(plan.intent).toBe('mindmap');
+        expect(plan.mermaidDiagramType).toBe('mindmap');
+    });
+    test('fallback targets include html for dataChart (non-mermaid)', () => {
+        const md = '| A | B |\n| - | - |\n| 1 | 2 |\n| 3 | 4 |\nchart share breakdown';
+        const plan = (0, planner_1.buildDiagramPlan)(md, { compatibilityMode: 'best-fit' });
+        expect(plan.renderTarget).toBe('vega-lite');
+        // dataChart has no mermaidDiagramType, so only html is a valid fallback
+        expect(plan.fallbackTargets).toContain('html');
+    });
+});
+// ── Spec Validation ──
+describe('Diagram Spec Validation', () => {
+    const validMindmapSpec = {
+        intent: 'mindmap',
+        title: 'Test Diagram',
+        nodes: [{ id: 'n1', label: 'Node 1' }, { id: 'n2', label: 'Node 2' }],
+        edges: [{ from: 'n1', to: 'n2' }],
+    };
+    test('valid mindmap spec passes validation', () => {
+        const result = (0, diagramSpec_1.validateDiagramSpec)(validMindmapSpec);
+        expect(result.valid).toBe(true);
+        expect(result.errors).toHaveLength(0);
+    });
+    test('missing title fails validation', () => {
+        const result = (0, diagramSpec_1.validateDiagramSpec)({ ...validMindmapSpec, title: '' });
+        expect(result.valid).toBe(false);
+        expect(result.errors.some(e => e.includes('title'))).toBe(true);
+    });
+    test('duplicate node ids fail validation', () => {
+        const result = (0, diagramSpec_1.validateDiagramSpec)({
+            ...validMindmapSpec,
+            nodes: [{ id: 'n1', label: 'A' }, { id: 'n1', label: 'B' }],
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors.some(e => e.includes('duplicate'))).toBe(true);
+    });
+    test('edge to missing node fails validation', () => {
+        const result = (0, diagramSpec_1.validateDiagramSpec)({
+            ...validMindmapSpec,
+            edges: [{ from: 'n1', to: 'missing' }],
+        });
+        expect(result.valid).toBe(false);
+        expect(result.errors.some(e => e.includes('missing'))).toBe(true);
+    });
+    test('unsupported intent fails validation', () => {
+        const result = (0, diagramSpec_1.validateDiagramSpec)({ ...validMindmapSpec, intent: 'bogus' });
+        expect(result.valid).toBe(false);
+        expect(result.errors.some(e => e.includes('unsupported'))).toBe(true);
+    });
+    test('assertValidDiagramSpec throws on invalid spec', () => {
+        expect(() => (0, diagramSpec_1.assertValidDiagramSpec)({ ...validMindmapSpec, title: '' })).toThrow();
+    });
+    test('dataChart intent requires data series', () => {
+        const result = (0, diagramSpec_1.validateDiagramSpec)({ ...validMindmapSpec, intent: 'dataChart', nodes: [] });
+        expect(result.valid).toBe(false);
+        expect(result.errors.some(e => e.includes('data series'))).toBe(true);
+    });
+});
+// ── Response Parser ──
+describe('Diagram Spec Response Parser', () => {
+    test('parses valid JSON DiagramSpec', () => {
+        const json = JSON.stringify({
+            intent: 'mindmap',
+            title: 'Test',
+            nodes: [{ id: 'a', label: 'A' }],
+        });
+        const spec = (0, diagramSpecResponseParser_1.parseDiagramSpecResponse)(json);
+        expect(spec.intent).toBe('mindmap');
+        expect(spec.title).toBe('Test');
+        expect(spec.nodes).toHaveLength(1);
+        expect(spec.nodes[0].id).toBe('a');
+    });
+    test('strips code fences from response', () => {
+        const json = '```json\n' + JSON.stringify({
+            intent: 'flowchart',
+            title: 'Test',
+            nodes: [{ id: 'a', label: 'A' }],
+        }) + '\n```';
+        const spec = (0, diagramSpecResponseParser_1.parseDiagramSpecResponse)(json);
+        expect(spec.intent).toBe('flowchart');
+        expect(spec.title).toBe('Test');
+    });
+    test('handles diagramSpec wrapper key', () => {
+        const json = JSON.stringify({
+            diagramSpec: {
+                intent: 'sequence',
+                title: 'Test',
+                nodes: [{ id: 'a', label: 'A' }],
+            }
+        });
+        const spec = (0, diagramSpecResponseParser_1.parseDiagramSpecResponse)(json);
+        expect(spec.intent).toBe('sequence');
+    });
+    test('throws on non-JSON input', () => {
+        expect(() => (0, diagramSpecResponseParser_1.parseDiagramSpecResponse)('not json at all')).toThrow();
+    });
+    test('normalizes edge fields (source→from, target→to)', () => {
+        const json = JSON.stringify({
+            intent: 'mindmap', title: 'E',
+            nodes: [{ id: 'a', label: 'A' }, { id: 'b', label: 'B' }],
+            edges: [{ source: 'a', target: 'b', label: 'connects' }],
+        });
+        const spec = (0, diagramSpecResponseParser_1.parseDiagramSpecResponse)(json);
+        expect(spec.edges[0].from).toBe('a');
+        expect(spec.edges[0].to).toBe('b');
+    });
+});
+// ── Prompt Builder ──
+describe('Diagram Spec Prompt', () => {
+    test('includes required intent in output', () => {
+        const prompt = (0, diagramSpecPrompt_1.buildDiagramSpecPrompt)({ requiredIntent: 'flowchart' });
+        expect(prompt).toContain('REQUIRED');
+        expect(prompt).toContain('flowchart');
+    });
+    test('includes preferred intent', () => {
+        const prompt = (0, diagramSpecPrompt_1.buildDiagramSpecPrompt)({ preferredIntent: 'sequence' });
+        expect(prompt).toContain('Preferred');
+        expect(prompt).toContain('sequence');
+    });
+    test('includes target language', () => {
+        const prompt = (0, diagramSpecPrompt_1.buildDiagramSpecPrompt)({ targetLanguage: 'zh' });
+        expect(prompt).toContain('zh');
+    });
+    test('output rules forbid code fences', () => {
+        const prompt = (0, diagramSpecPrompt_1.buildDiagramSpecPrompt)();
+        expect(prompt).toContain('Do not wrap');
+    });
+});

package/dist/src/notemd.providerTemplates.test.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const providerTemplates_1 = require("./notemd/providerTemplates");
+const constants_1 = require("./notemd/constants");
+describe('notemd provider templates', () => {
+    test('exposes curated templates inspired by Cherry Studio and DeepTutor', () => {
+        expect(providerTemplates_1.NOTEMD_PROVIDER_TEMPLATES.length).toBeGreaterThanOrEqual(6);
+        expect((0, providerTemplates_1.getNotemdProviderTemplate)('openai-official')?.providerName).toBe('OpenAI');
+        expect((0, providerTemplates_1.getNotemdProviderTemplate)('lmstudio-local')?.inspiredBy).toContain('DeepTutor');
+    });
+    test('applies a template to the matching provider and switches activeProvider', () => {
+        const next = (0, providerTemplates_1.applyProviderTemplateToSettings)(constants_1.DEFAULT_SETTINGS, 'openrouter-gateway');
+        const provider = next.providers.find((item) => item.name === 'OpenRouter');
+        expect(next.activeProvider).toBe('OpenRouter');
+        expect(provider).toBeTruthy();
+        expect(provider?.baseUrl).toContain('openrouter.ai');
+        expect(provider?.model).toContain('openai/');
+    });
+    test('merges provider_templates into the notemd TOML section without dropping existing overrides', () => {
+        const next = (0, providerTemplates_1.mergeProviderTemplatesIntoNotemdSection)({
+            active_provider: 'DeepSeek',
+            provider_templates: {
+                custom_keep: {
+                    label: 'Keep Me',
+                },
+            },
+        });
+        const templates = next.provider_templates;
+        expect(templates).toBeTruthy();
+        expect(templates.custom_keep.label).toBe('Keep Me');
+        expect(templates['openai-official']).toBeTruthy();
+        expect(templates['openai-official'].provider_name).toBe('OpenAI');
+    });
+});

package/dist/src/notemd.server.integration.test.js

@@ -39,7 +39,7 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 class TempDir {
     constructor(prefix) {
-        this.path = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), `${prefix}-`));
+        this.path = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), `${prefix}-`)));
     }
     mkdir(relativePath) {
         const target = path.join(this.path, relativePath);
@@ -94,7 +94,7 @@ function getFreePort() {
         });
     });
 }
-function requestJson(port, method, requestPath, body) {
+function requestJson(port, method, requestPath, body, headers = {}) {
     return new Promise((resolve, reject) => {
         const payload = typeof body === 'undefined' ? null : Buffer.from(JSON.stringify(body), 'utf8');
         const req = http.request({
@@ -106,8 +106,9 @@ function requestJson(port, method, requestPath, body) {
                 ? {
                     'Content-Type': 'application/json',
                     'Content-Length': String(payload.length),
+                    ...headers,
                 }
-                : undefined,
+                : headers,
         }, (res) => {
             let text = '';
             res.setEncoding('utf8');
@@ -141,11 +142,35 @@ describe('NoteMD server integration', () => {
     let temp;
     let envRestorers;
     let server;
+    let serverModule;
     let port;
     let kbFilePath;
     let runtimeDataDir;
     let appConfigPath;
     let originalArgv;
+    function loadFreshServerModule() {
+        jest.resetModules();
+        process.argv = process.argv.slice(0, 2);
+        jest.doMock('./index', () => ({
+            buildGraph: jest.fn().mockResolvedValue(undefined),
+        }));
+        jest.doMock('./core/PathBridge', () => ({
+            PathBridge: jest.fn().mockImplementation(() => ({})),
+        }));
+        jest.doMock('./reader_renderer', () => ({
+            renderMathPng: jest.fn().mockResolvedValue({
+                pngBase64: 'math',
+                width: 100,
+                height: 50,
+            }),
+            renderMermaidPng: jest.fn().mockResolvedValue({
+                pngBase64: 'mermaid',
+                width: 100,
+                height: 50,
+            }),
+        }));
+        return require('./server');
+    }
     beforeAll(async () => {
         temp = new TempDir('noteconnection-notemd');
         const projectRoot = temp.mkdir('project');
@@ -186,45 +211,29 @@ describe('NoteMD server integration', () => {
         envRestorers.push(setEnv('npm_config_workers', undefined));
         envRestorers.push(setEnv('npm_config_static', undefined));
         port = await getFreePort();
-        jest.resetModules();
         originalArgv = [...process.argv];
-        process.argv = process.argv.slice(0, 2);
-        jest.doMock('./index', () => ({
-            buildGraph: jest.fn().mockResolvedValue(undefined),
-        }));
-        jest.doMock('./core/PathBridge', () => ({
-            PathBridge: jest.fn().mockImplementation(() => ({})),
-        }));
-        jest.doMock('./reader_renderer', () => ({
-            renderMathPng: jest.fn().mockResolvedValue({
-                pngBase64: 'math',
-                width: 100,
-                height: 50,
-            }),
-            renderMermaidPng: jest.fn().mockResolvedValue({
-                pngBase64: 'mermaid',
-                width: 100,
-                height: 50,
-            }),
-        }));
-        const serverModule = require('./server');
+        serverModule = loadFreshServerModule();
         server = await serverModule.startServer({ port });
-    });
-    afterAll(async () => {
-        if (server) {
-            if (typeof server.closeAllConnections === 'function') {
-                server.closeAllConnections();
-            }
-            await new Promise((resolve, reject) => {
-                server.close((err) => {
-                    if (err) {
-                        reject(err);
-                        return;
-                    }
-                    resolve();
-                });
-            });
+    }, 20000);
+    async function shutdownServerInstance(instance) {
+        if (!instance) {
+            return;
+        }
+        if (typeof instance.closeAllConnections === 'function') {
+            instance.closeAllConnections();
         }
+        await new Promise((resolve, reject) => {
+            instance.close((err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    afterAll(async () => {
+        await shutdownServerInstance(server);
         envRestorers.reverse().forEach((restore) => restore());
         process.argv = originalArgv;
         jest.dontMock('./index');
@@ -444,6 +453,93 @@ describe('NoteMD server integration', () => {
         expect(workspaceResponse.body.workspace.filePath).toBe(kbFilePath);
         expect(workspaceResponse.body.workspace.folderPath).toBe(path.dirname(kbFilePath));
     });
+    test('NoteMD protocol rejects wrong content type, oversized input and missing cancellation targets', async () => {
+        const wrongType = await requestJson(port, 'POST', '/api/notemd/settings', {}, { 'Content-Type': 'text/plain' });
+        expect(wrongType.status).toBe(415);
+        const oversized = await requestJson(port, 'POST', '/api/notemd/settings', { pad: 'x'.repeat(600 * 1024) });
+        expect(oversized.status).toBe(413);
+        const cancel = await requestJson(port, 'POST', '/api/notemd/cancel', { operationId: 'missing-operation' });
+        expect(cancel.status).toBe(404);
+    });
+    test('NoteMD protocol rejects files outside the configured workspace without mutation', async () => {
+        const outside = temp.file('outside/rejected.md', '# Outside\n$\nunsafe\n$');
+        const response = await requestJson(port, 'POST', '/api/notemd/fix-formulas', { filePath: outside, inPlace: true });
+        expect(response.status).toBe(403);
+        expect(fs.readFileSync(outside, 'utf8')).toBe('# Outside\n$\nunsafe\n$');
+    });
+    test('NoteMD protocol emits one operation and one completion while processing a real file', async () => {
+        const response = await requestJson(port, 'POST', '/api/notemd/process-file', {
+            filePath: kbFilePath, operationId: 'notemd-stream-contract',
+        }, { accept: 'text/event-stream' });
+        expect(response.status).toBe(200);
+        const frames = String(response.body).split('\n\n').filter(Boolean);
+        const operations = frames.filter(frame => frame.startsWith('event: operation\n'));
+        const completed = frames.filter(frame => frame.startsWith('event: done\n'));
+        expect(operations).toHaveLength(1);
+        expect(completed).toHaveLength(1);
+        expect(JSON.parse(completed[0].slice(completed[0].indexOf('data: ') + 6))).toEqual(expect.objectContaining({ success: true, operationId: 'notemd-stream-contract' }));
+    });
+    test('NoteMD registry owns aliases and unknown routes without an inline fallback', async () => {
+        const alias = await requestJson(port, 'PUT', '/api/notemd/fix-formulas', { filePath: kbFilePath, inPlace: true });
+        expect(alias.status).toBe(200);
+        expect((await requestJson(port, 'POST', '/api/notemd/unknown', {})).status).toBe(404);
+        const diagnostics = await requestJson(port, 'GET', '/api/runtime-diagnostics');
+        expect(diagnostics.body.routeMigration.registryHits).toBeGreaterThan(0);
+        expect(diagnostics.body.routeMigration.inlineFallbacksByFamily.notemd || 0).toBe(0);
+    });
+    test('NoteMD operation IDs cannot replace an active operation and cancellation reaches its owner', async () => {
+        const { NotemdService } = require('./notemd/NotemdService');
+        let entered;
+        let release;
+        const started = new Promise(resolve => { entered = resolve; });
+        const held = new Promise(resolve => { release = resolve; });
+        let signal;
+        const processFile = jest.spyOn(NotemdService.prototype, 'processFile')
+            .mockImplementationOnce(async (...args) => {
+            signal = args[3];
+            entered();
+            await held;
+            signal.throwIfAborted();
+            return { outputPath: kbFilePath };
+        }).mockResolvedValueOnce({ outputPath: kbFilePath });
+        const payload = { filePath: kbFilePath, operationId: 'notemd-admission-contract' };
+        const first = requestJson(port, 'POST', '/api/notemd/process-file', payload);
+        try {
+            await started;
+            const duplicate = await requestJson(port, 'POST', '/api/notemd/process-file', payload);
+            expect(duplicate.status).toBe(409);
+            expect(processFile).toHaveBeenCalledTimes(1);
+            expect((await requestJson(port, 'POST', '/api/notemd/cancel', { operationId: payload.operationId })).status).toBe(200);
+            expect(signal?.aborted).toBe(true);
+            release();
+            expect((await first).status).toBe(499);
+        }
+        finally {
+            release();
+            await first;
+            processFile.mockRestore();
+        }
+    });
+    test('NoteMD authentication is enforced before route dispatch', async () => {
+        const restoreToken = setEnv('NOTE_CONNECTION_AUTH_TOKEN', 'notemd-fixture-token');
+        let authenticated;
+        try {
+            const authPort = await getFreePort();
+            authenticated = await loadFreshServerModule().startServer({ port: authPort });
+            expect((await requestJson(authPort, 'GET', '/api/notemd/settings')).status).toBe(401);
+            expect((await requestJson(authPort, 'GET', '/api/notemd/settings', undefined, { 'X-NoteConnection-Token': 'notemd-fixture-token' })).status).toBe(200);
+        }
+        finally {
+            await shutdownServerInstance(authenticated);
+            restoreToken();
+        }
+    });
+    test.each(['/batch-fix-formulas', '/batch-generate-content', '/workflow', '/batch-workflow', '/extract-original-text'])('NoteMD registry validates the %s filesystem boundary', async (endpoint) => {
+        const outside = temp.file('outside/extended.md', '# Outside');
+        const response = await requestJson(port, 'POST', '/api/notemd' + endpoint, { filePath: outside, folderPath: path.dirname(outside), skipGenerate: true });
+        expect(response.status).toBe(403);
+        expect(fs.readFileSync(outside, 'utf8')).toBe('# Outside');
+    });
     test('extract-concepts and duplicate endpoints return structured results', async () => {
         const conceptsResponse = await requestJson(port, 'POST', '/api/notemd/extract-concepts', {
             filePath: kbFilePath,
@@ -462,4 +558,131 @@ describe('NoteMD server integration', () => {
         expect(fs.existsSync(appConfigPath)).toBe(true);
         expect(fs.existsSync(path.join(runtimeDataDir, 'notemd_config.json'))).toBe(false);
     });
+    test('foundation readiness and backend sufficiency reflect embedded sqlite graph runtime after ingest', async () => {
+        const ingestResponse = await requestJson(port, 'POST', '/api/knowledge/ingest', {
+            incremental: true,
+            documents: [
+                {
+                    documentId: 'doc_foundation_runtime',
+                    sourcePath: path.join(path.dirname(kbFilePath), 'foundation_runtime.md'),
+                    language: 'en',
+                    content: '# Foundation Runtime\n\nEmbedded graph backend readiness should be measurable after ingest.',
+                },
+            ],
+        });
+        expect(ingestResponse.status).toBe(200);
+        expect(ingestResponse.body.success).toBe(true);
+        const readinessResponse = await requestJson(port, 'GET', '/api/knowledge/foundation/readiness');
+        expect(readinessResponse.status).toBe(200);
+        expect(readinessResponse.body.success).toBe(true);
+        expect(readinessResponse.body.readiness).toEqual(expect.objectContaining({
+            status: 'integrated',
+            decision: 'go',
+            ready: true,
+        }));
+        expect(readinessResponse.body.readiness.baseline).toEqual(expect.objectContaining({
+            storeType: 'sqlite',
+            storageRequestedProvider: 'sqlite',
+            storageResolvedProvider: 'sqlite',
+            storageSupportsSqlite: true,
+            graphBackendStatus: 'independent',
+            graphBackendSignalKind: 'embedded_graphdb',
+            graphBackendIndependent: true,
+            queryBackendDefaultMode: 'local_hybrid',
+            vectorAdapterStatus: 'independent',
+            vectorAdapterSignalKind: 'embedding_ann',
+        }));
+        expect(readinessResponse.body.readiness.promotionCriteriaPassed).toBe(readinessResponse.body.readiness.promotionCriteriaTotal);
+        const sufficiencyResponse = await requestJson(port, 'GET', '/api/knowledge/backend/sufficiency');
+        expect(sufficiencyResponse.status).toBe(200);
+        expect(sufficiencyResponse.body.success).toBe(true);
+        expect(sufficiencyResponse.body.sufficiency).toEqual(expect.objectContaining({
+            sufficient: true,
+        }));
+        expect(sufficiencyResponse.body.sufficiency.checks.knowledgeGraph).toEqual(expect.objectContaining({
+            passed: true,
+            reason: 'embedded_graphdb',
+        }));
+        expect(sufficiencyResponse.body.sufficiency.checks.queryBackend).toEqual(expect.objectContaining({
+            passed: true,
+        }));
+        expect(sufficiencyResponse.body.sufficiency.checks.vectorIndex).toEqual(expect.objectContaining({
+            passed: true,
+            reason: 'embedding_ann',
+        }));
+    });
+    test('turn-cache alert trend restart durability', async () => {
+        await requestJson(port, 'POST', '/api/knowledge/conversation', { userId: 'durability-user', message: 'Graph theory', persistMemory: false });
+        const diagnostics = await requestJson(port, 'GET', '/api/knowledge/conversation/turn-cache/diagnostics');
+        expect(diagnostics.body.result.counters.executionSuccessCount).toBeGreaterThan(0);
+        const trend = await requestJson(port, 'GET', '/api/knowledge/conversation/turn-cache/diagnostics/trend');
+        expect(trend.body.result.records.length).toBeGreaterThan(0);
+        const storagePath = trend.body.result.storage.filePath;
+        const deadline = Date.now() + 3000;
+        while (!fs.existsSync(storagePath) && Date.now() < deadline)
+            await new Promise(resolve => setTimeout(resolve, 10));
+        expect(fs.existsSync(storagePath)).toBe(true);
+        const persisted = JSON.parse(fs.readFileSync(storagePath, 'utf8'));
+        expect(persisted.records.length).toBeGreaterThan(0);
+        await shutdownServerInstance(server);
+        port = await getFreePort();
+        serverModule = loadFreshServerModule();
+        server = await serverModule.startServer({ port });
+        const restored = await requestJson(port, 'GET', '/api/knowledge/conversation/turn-cache/diagnostics/trend/export');
+        expect(restored.status).toBe(200);
+        expect(restored.body.result.storage.lastLoadedRecordCount).toBeGreaterThan(0);
+        expect(restored.body.result.records).toEqual(expect.arrayContaining([expect.objectContaining(persisted.records[0])]));
+    });
+    test('embedded sqlite graph runtime survives server restart and preserves query/store diagnostics', async () => {
+        const sqliteStorePath = path.join(runtimeDataDir, 'knowledge_graph_store.graphdb.v1.sqlite');
+        const ingestResponse = await requestJson(port, 'POST', '/api/knowledge/ingest', {
+            incremental: true,
+            documents: [
+                {
+                    documentId: 'doc_restart_runtime',
+                    sourcePath: path.join(path.dirname(kbFilePath), 'restart_runtime.md'),
+                    language: 'en',
+                    content: '# Restart Runtime\n\nPersist this graph content across server restart for sqlite proof.',
+                },
+            ],
+        });
+        expect(ingestResponse.status).toBe(200);
+        expect(ingestResponse.body.success).toBe(true);
+        expect(fs.existsSync(sqliteStorePath)).toBe(true);
+        await shutdownServerInstance(server);
+        port = await getFreePort();
+        serverModule = loadFreshServerModule();
+        server = await serverModule.startServer({ port });
+        const diagnosticsResponse = await requestJson(port, 'GET', '/api/knowledge/store-diagnostics');
+        expect(diagnosticsResponse.status).toBe(200);
+        expect(diagnosticsResponse.body.success).toBe(true);
+        expect(diagnosticsResponse.body.store).toEqual(expect.objectContaining({
+            storeType: 'graphdb',
+            storageEngine: 'sqlite',
+            requestedProvider: 'sqlite',
+            resolvedProvider: 'sqlite',
+            backendReady: true,
+            usingFallback: false,
+        }));
+        const queryResponse = await requestJson(port, 'POST', '/api/knowledge/query', {
+            query: 'persist graph content restart sqlite proof',
+            topK: 3,
+        });
+        expect(queryResponse.status).toBe(200);
+        expect(queryResponse.body.success).toBe(true);
+        expect(Array.isArray(queryResponse.body.result.items)).toBe(true);
+        expect(queryResponse.body.result.items.length).toBeGreaterThan(0);
+        expect(String(queryResponse.body.result.items[0]?.atom?.documentId || '')).toBe('doc_restart_runtime');
+        const readinessResponse = await requestJson(port, 'GET', '/api/knowledge/foundation/readiness');
+        expect(readinessResponse.status).toBe(200);
+        expect(readinessResponse.body.readiness).toEqual(expect.objectContaining({
+            status: 'integrated',
+            decision: 'go',
+        }));
+        expect(readinessResponse.body.readiness.baseline).toEqual(expect.objectContaining({
+            storeType: 'sqlite',
+            graphBackendSignalKind: 'embedded_graphdb',
+            graphBackendIndependent: true,
+        }));
+    });
 });