noteconnection 1.8.0 → 1.9.0

package/dist/src/notemd/progressReporter.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNoopProgressReporter = createNoopProgressReporter;
+function createNoopProgressReporter() {
+    return {
+        report: () => undefined,
+        isCancelled: () => false,
+    };
+}

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');
@@ -213,7 +214,7 @@ describe('NoteMD server integration', () => {
         originalArgv = [...process.argv];
         serverModule = loadFreshServerModule();
         server = await serverModule.startServer({ port });
-    });
+    }, 20000);
     async function shutdownServerInstance(instance) {
         if (!instance) {
             return;
@@ -452,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,
@@ -494,6 +582,9 @@ describe('NoteMD server integration', () => {
         }));
         expect(readinessResponse.body.readiness.baseline).toEqual(expect.objectContaining({
             storeType: 'sqlite',
+            storageRequestedProvider: 'sqlite',
+            storageResolvedProvider: 'sqlite',
+            storageSupportsSqlite: true,
             graphBackendStatus: 'independent',
             graphBackendSignalKind: 'embedded_graphdb',
             graphBackendIndependent: true,
@@ -520,6 +611,28 @@ describe('NoteMD server integration', () => {
             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', {
@@ -546,6 +659,8 @@ describe('NoteMD server integration', () => {
         expect(diagnosticsResponse.body.store).toEqual(expect.objectContaining({
             storeType: 'graphdb',
             storageEngine: 'sqlite',
+            requestedProvider: 'sqlite',
+            resolvedProvider: 'sqlite',
             backendReady: true,
             usingFallback: false,
         }));

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

@@ -104,7 +104,7 @@ describe('Notemd Workflow Pipeline', () => {
         // Summary should have valid numbers
         expect(typeof result.summary.conceptsExtracted).toBe('number');
         expect(typeof result.summary.totalElapsedMs).toBe('number');
-        expect(result.summary.totalElapsedMs).toBeGreaterThan(0);
+        expect(result.summary.totalElapsedMs).toBeGreaterThanOrEqual(0);
     });
     test('runWorkflow with addWikiLinks injects wiki-links and writes _wikified file', async () => {
         const src = temp.file('notes/test.md', '# Machine Learning\n\nMachine learning uses neural networks and deep learning.');

package/dist/src/pathbridge.handshake.contract.test.js

@@ -91,6 +91,35 @@ describe('path bridge handshake and transport verification contracts', () => {
         });
         expect(validIdentify.ok).toBe(true);
         expect(validIdentify.envelope?.type).toBe('identify');
+        const validQuery = (0, PathBridge_1.parseBridgeInboundEnvelope)({
+            type: 'query',
+            version: PathBridge_1.PATH_BRIDGE_PROTOCOL_VERSION,
+            payload: {
+                requestId: 'query-1',
+                workspaceId: 'mobile-workspace',
+                sourceUri: 'note://workspace/v1/algebra/index.md',
+            },
+        });
+        expect(validQuery.ok).toBe(true);
+        const invalidQuery = (0, PathBridge_1.parseBridgeInboundEnvelope)({
+            type: 'query',
+            payload: { requestId: '' },
+        });
+        expect(invalidQuery.ok).toBe(false);
+        expect(invalidQuery.reason).toContain('requestId');
+        const invalidCapabilities = (0, PathBridge_1.parseBridgeInboundEnvelope)({
+            type: 'capabilities',
+            payload: { protocolVersion: PathBridge_1.PATH_BRIDGE_PROTOCOL_VERSION, capabilities: [''] },
+        });
+        expect(invalidCapabilities.ok).toBe(false);
+        expect(invalidCapabilities.reason).toContain('non-empty strings');
+        expect(PathBridge_1.PATH_BRIDGE_CAPABILITIES).toEqual(expect.arrayContaining([
+            'knowledge.analyze',
+            'knowledge.query',
+            'knowledge.readEvidence',
+            'knowledge.exportBundle',
+            'request.cancel',
+        ]));
         const invalidSwitchCenter = (0, PathBridge_1.parseBridgeInboundEnvelope)({
             type: 'switchCenter',
             payload: {

package/dist/src/pathbridge.host-adapter.contract.test.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ws_1 = require("ws");
+const PathBridge_1 = require("./core/PathBridge");
+function waitForMessage(socket, predicate) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            socket.off('message', onMessage);
+            reject(new Error('Timed out waiting for PathBridge message.'));
+        }, 3000);
+        const onMessage = (raw) => {
+            let payload;
+            try {
+                payload = JSON.parse(raw.toString('utf8'));
+            }
+            catch {
+                return;
+            }
+            if (!predicate(payload)) {
+                return;
+            }
+            clearTimeout(timer);
+            socket.off('message', onMessage);
+            resolve(payload);
+        };
+        socket.on('message', onMessage);
+    });
+}
+function connectClient(port) {
+    return new Promise((resolve, reject) => {
+        const socket = new ws_1.WebSocket(`ws://127.0.0.1:${port}`);
+        socket.once('open', () => resolve(socket));
+        socket.once('error', reject);
+    });
+}
+async function closeClient(socket) {
+    if (!socket || socket.readyState === ws_1.WebSocket.CLOSED) {
+        return;
+    }
+    await new Promise((resolve) => {
+        socket.once('close', () => resolve());
+        socket.close();
+    });
+}
+describe('PathBridge host adapter contract', () => {
+    test('executes knowledge requests in the host and returns correlated results', async () => {
+        const operations = [];
+        const bridge = new PathBridge_1.PathBridge({
+            port: 0,
+            hostAdapter: {
+                execute: async (operation) => {
+                    operations.push(operation);
+                    return { nodeCount: 2, execution: 'host' };
+                },
+            },
+        });
+        let client = null;
+        try {
+            await bridge.waitUntilReady();
+            client = await connectClient(bridge.getPort());
+            const capabilitiesPromise = waitForMessage(client, (message) => message.type === 'capabilities');
+            client.send(JSON.stringify({ type: 'identify', payload: { client: 'test-client' } }));
+            await capabilitiesPromise;
+            client.send(JSON.stringify({
+                type: 'query',
+                correlationId: 'corr-1',
+                payload: { requestId: 'query-1', workspaceId: 'mobile-workspace' },
+            }));
+            const result = await waitForMessage(client, (message) => message.type === 'operationResult');
+            expect(result.payload).toEqual(expect.objectContaining({
+                type: 'query',
+                requestId: 'query-1',
+                correlationId: 'corr-1',
+                ok: true,
+                result: { nodeCount: 2, execution: 'host' },
+            }));
+            expect(operations[0]).toEqual(expect.objectContaining({
+                type: 'query',
+                requestId: 'query-1',
+                correlationId: 'corr-1',
+                clientTag: 'test-client',
+            }));
+            expect(operations[0].signal).toBeInstanceOf(AbortSignal);
+        }
+        finally {
+            await closeClient(client);
+            bridge.close();
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+    });
+    test('propagates cancellation to the host adapter and does not leak pending work', async () => {
+        let cancelledRequestId = '';
+        let operationSignal = null;
+        const bridge = new PathBridge_1.PathBridge({
+            port: 0,
+            hostAdapter: {
+                execute: (operation) => {
+                    operationSignal = operation.signal;
+                    return new Promise((_resolve, reject) => {
+                        operation.signal.addEventListener('abort', () => reject(new Error('aborted')));
+                    });
+                },
+                cancel: (requestId) => {
+                    cancelledRequestId = requestId;
+                },
+            },
+        });
+        let client = null;
+        try {
+            await bridge.waitUntilReady();
+            client = await connectClient(bridge.getPort());
+            const capabilitiesPromise = waitForMessage(client, (message) => message.type === 'capabilities');
+            client.send(JSON.stringify({ type: 'identify', payload: { client: 'cancel-client' } }));
+            await capabilitiesPromise;
+            client.send(JSON.stringify({ type: 'query', payload: { requestId: 'query-cancel' } }));
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            client.send(JSON.stringify({ type: 'cancel', payload: { requestId: 'query-cancel' } }));
+            const result = await waitForMessage(client, (message) => message.type === 'operationResult' && message.payload.type === 'cancel');
+            expect(result.payload).toEqual(expect.objectContaining({
+                requestId: 'query-cancel',
+                cancelled: true,
+                ok: false,
+            }));
+            expect(cancelledRequestId).toBe('query-cancel');
+            expect(operationSignal?.aborted).toBe(true);
+        }
+        finally {
+            await closeClient(client);
+            bridge.close();
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+    });
+});

package/dist/src/pathcore.bundle.contract.test.js

@@ -80,6 +80,14 @@ describe('path core bundle contract', () => {
         ['A', 'B', 'C', 'D'].forEach((id) => {
             graph.addNode({ id, label: id, inDegree: 0, outDegree: 0 });
         });
+        graph.addNode({
+            id: 'Alias',
+            label: 'Alias',
+            inDegree: 0,
+            outDegree: 0,
+            identityAliases: ['folder/alias.md'],
+        });
+        expect(graph.hasNode('folder\\alias.md')).toBe(true);
         graph.addEdge('A', 'B');
         graph.addEdge('A', 'C');
         graph.addEdge('B', 'D');

package/dist/src/platform/ExportProfile.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOBILE_SLIM_MAX_RESIDENT_BYTES = exports.MOBILE_SLIM_ASSET_BUDGET_BYTES = void 0;
 exports.getExportProfile = getExportProfile;
 exports.listExportProfiles = listExportProfiles;
+const MobileBudget_1 = require("./MobileBudget");
+exports.MOBILE_SLIM_ASSET_BUDGET_BYTES = MobileBudget_1.MOBILE_LOW_ARTIFACT_BUDGET_BYTES;
+exports.MOBILE_SLIM_MAX_RESIDENT_BYTES = MobileBudget_1.MOBILE_LOW_MAX_RESIDENT_BYTES;
 const EXPORT_PROFILES = {
     'desktop-full': {
         id: 'desktop-full',
@@ -12,6 +16,12 @@ const EXPORT_PROFILES = {
         supportsConversationStreaming: true,
         supportsSvgRenderArtifacts: true,
         supportsPngRenderArtifacts: true,
+        supportsLocalIngest: true,
+        supportsLocalExactQuery: true,
+        supportsRemoteInference: true,
+        requiresRemoteInference: false,
+        assetBudgetBytes: null,
+        maxResidentBytes: null,
         preferredMermaidRenderer: 'auto',
     },
     'desktop-reader': {
@@ -23,6 +33,12 @@ const EXPORT_PROFILES = {
         supportsConversationStreaming: true,
         supportsSvgRenderArtifacts: true,
         supportsPngRenderArtifacts: true,
+        supportsLocalIngest: false,
+        supportsLocalExactQuery: true,
+        supportsRemoteInference: true,
+        requiresRemoteInference: false,
+        assetBudgetBytes: null,
+        maxResidentBytes: null,
         preferredMermaidRenderer: 'auto',
     },
     'godot-path-mode': {
@@ -34,6 +50,12 @@ const EXPORT_PROFILES = {
         supportsConversationStreaming: false,
         supportsSvgRenderArtifacts: false,
         supportsPngRenderArtifacts: true,
+        supportsLocalIngest: false,
+        supportsLocalExactQuery: false,
+        supportsRemoteInference: false,
+        requiresRemoteInference: false,
+        assetBudgetBytes: null,
+        maxResidentBytes: null,
         preferredMermaidRenderer: 'auto',
     },
     'mobile-slim': {
@@ -45,6 +67,12 @@ const EXPORT_PROFILES = {
         supportsConversationStreaming: false,
         supportsSvgRenderArtifacts: false,
         supportsPngRenderArtifacts: true,
+        supportsLocalIngest: true,
+        supportsLocalExactQuery: true,
+        supportsRemoteInference: true,
+        requiresRemoteInference: false,
+        assetBudgetBytes: exports.MOBILE_SLIM_ASSET_BUDGET_BYTES,
+        maxResidentBytes: exports.MOBILE_SLIM_MAX_RESIDENT_BYTES,
         preferredMermaidRenderer: 'local',
     },
 };

package/dist/src/platform/MobileBudget.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOBILE_LOW_MAX_DEVICE_RAM_BYTES = exports.MOBILE_LOW_MAX_RESIDENT_BYTES = exports.MOBILE_LOW_ARTIFACT_BUDGET_BYTES = exports.MOBILE_BUDGET_SCHEMA_VERSION = void 0;
+/**
+ * TypeScript projection of config/mobile-budget.v1.json for server-side export metadata.
+ * Keep this small and compare it with the checked-in contract in mobile budget tests.
+ */
+exports.MOBILE_BUDGET_SCHEMA_VERSION = 1;
+exports.MOBILE_LOW_ARTIFACT_BUDGET_BYTES = 25 * 1024 * 1024;
+exports.MOBILE_LOW_MAX_RESIDENT_BYTES = 256 * 1024 * 1024;
+exports.MOBILE_LOW_MAX_DEVICE_RAM_BYTES = 4 * 1024 * 1024 * 1024;

package/dist/src/platform/PlatformCapabilities.js

@@ -27,6 +27,8 @@ function resolvePlatformCapabilities(input = {}) {
             deterministicBundles: true,
             bundlePackagingMode: profile.supportsSidecar ? 'full' : 'slim',
             requiresIndexedReadiness: true,
+            assetBudgetBytes: profile.assetBudgetBytes,
+            maxResidentBytes: profile.maxResidentBytes,
         },
         render: {
             supportsSvgArtifacts: profile.supportsSvgRenderArtifacts,
@@ -37,6 +39,18 @@ function resolvePlatformCapabilities(input = {}) {
         retrieval: {
             supportsSidecar: profile.supportsSidecar,
             supportsBackgroundIndexing: profile.supportsBackgroundIndexing,
+            supportsLocalIngest: profile.supportsLocalIngest,
+            supportsLocalExactQuery: profile.supportsLocalExactQuery,
+            supportsRemoteInference: profile.supportsRemoteInference,
+            requiresRemoteInference: profile.requiresRemoteInference,
+        },
+        storage: {
+            preferredProvider: profile.platformTarget === 'mobile' ? 'projection' : 'sqlite',
+            supportedProviders: profile.platformTarget === 'mobile'
+                ? ['projection']
+                : ['sqlite', 'file', 'remote'],
+            supportsSqlite: profile.platformTarget !== 'mobile',
+            supportsProjection: profile.platformTarget === 'mobile',
         },
         conversation: {
             supportsStreaming: profile.supportsConversationStreaming,

package/dist/src/platform/PlatformCapabilities.test.js

@@ -10,6 +10,9 @@ describe('PlatformCapabilities', () => {
         expect(capabilities.render.supportsSvgArtifacts).toBe(false);
         expect(capabilities.render.preferredArtifact).toBe('png');
         expect(capabilities.conversation.supportsStreaming).toBe(false);
+        expect(capabilities.storage.preferredProvider).toBe('sqlite');
+        expect(capabilities.storage.supportsSqlite).toBe(true);
+        expect(capabilities.storage.supportsProjection).toBe(false);
     });
     test('resolves mobile slim profile as sidecar-free and PNG-only', () => {
         const capabilities = (0, PlatformCapabilities_1.resolvePlatformCapabilities)({ exportProfileId: 'mobile-slim' });
@@ -18,6 +21,9 @@ describe('PlatformCapabilities', () => {
         expect(capabilities.export.requiresIndexedReadiness).toBe(true);
         expect(capabilities.retrieval.supportsSidecar).toBe(false);
         expect(capabilities.render.supportsSvgArtifacts).toBe(false);
+        expect(capabilities.storage.preferredProvider).toBe('projection');
+        expect(capabilities.storage.supportsSqlite).toBe(false);
+        expect(capabilities.storage.supportsProjection).toBe(true);
     });
     test('platform target override selects the compatible profile family', () => {
         const capabilities = (0, PlatformCapabilities_1.resolvePlatformCapabilities)({

package/dist/src/query_backend.external_http.integration.test.js

@@ -346,7 +346,7 @@ describe('external_http vector acceleration server integration', () => {
         originalArgv = [...process.argv];
         const serverModule = loadFreshServerModule();
         server = await serverModule.startServer({ port });
-    });
+    }, 30000);
     afterAll(async () => {
         await shutdownServerInstance(server);
         await shutdownServerInstance(annService);
@@ -356,7 +356,7 @@ describe('external_http vector acceleration server integration', () => {
         jest.dontMock('./core/PathBridge');
         jest.dontMock('./reader_renderer');
         temp.cleanup();
-    });
+    }, 30000);
     test('local_vector runtime can sync a remote external_http ANN index and use it for live queries', async () => {
         const documents = Array.from({ length: 140 }, (_value, index) => ({
             documentId: `doc_external_ann_${index}`,

package/dist/src/release.godot.mirror.contract.test.js

@@ -44,10 +44,8 @@ describe('release workflow godot mirror contract', () => {
         expect(workflow).toContain('description: "Allow desktop release jobs to fall back to the upstream Godot release when the project mirror is unavailable."');
         expect(workflow).toContain('default: true');
         expect(workflow).toContain('type: boolean');
-        expect(workflow).toContain('GODOT_MIRROR_TAG: "godot-mirror-v4.3-stable"');
-        expect(workflow).toContain('GODOT_WINDOWS_ARCHIVE_SHA256: "8f2c75b734bd956027ae3ca92c41f78b5d5a255dacc0f20e4e3c523c545ad410"');
-        expect(workflow).toContain('GODOT_LINUX_ARCHIVE_SHA256: "7de56444b130b10af84d19c7e0cf63cf9e9937ee4ba94364c3b7dd114253ca21"');
-        expect(workflow).toContain('GODOT_MACOS_ARCHIVE_SHA256: "d17940b913b3f3bf54c941eeb09042099d93865c6e2638e09e20f7c649aa474a"');
+        expect(workflow.match(/node scripts\/write-godot-desktop-ci-env\.js/g)).toHaveLength(2);
+        expect(workflow).toContain('${GODOT_LINUX_ARCHIVE_NAME%.zip}');
         expect(workflow).toContain("GODOT_ALLOW_UPSTREAM_FALLBACK: ${{ github.event_name != 'workflow_dispatch' || github.event.inputs.allow_godot_upstream_fallback != 'false' }}");
         expect(workflow).toContain('ensure-godot-mirror-assets:');
         expect(workflow).toContain('gh release view "$GODOT_MIRROR_TAG" --repo "$GITHUB_REPOSITORY"');
@@ -70,4 +68,30 @@ describe('release workflow godot mirror contract', () => {
         expect(workflow).toContain('ACTUAL_SHA256="$(sha256sum build/godot/godot-macos.zip | awk \'{print $1}\')"');
         expect(workflow).toContain('needs: [ensure-release, ensure-godot-mirror-assets]');
     });
+    test('exports checksummed engine archives matching the declared Godot project version', () => {
+        const runtime = require('../config/godot-desktop-runtime.json');
+        const { writeGodotDesktopCiEnvironment } = require('../scripts/write-godot-desktop-ci-env');
+        const project = fs.readFileSync(path.join(repoRoot, 'path_mode/project.godot'), 'utf8');
+        expect(project).toContain(`PackedStringArray("${runtime.version}"`);
+        const directory = fs.mkdtempSync(path.join(fs.realpathSync(require('os').tmpdir()), 'godot-ci-env-'));
+        const destination = path.join(directory, 'env');
+        try {
+            writeGodotDesktopCiEnvironment(destination);
+            const environment = Object.fromEntries(fs.readFileSync(destination, 'utf8').trim().split('\n').map(line => {
+                const separator = line.indexOf('=');
+                return [line.slice(0, separator), line.slice(separator + 1)];
+            }));
+            expect(environment.GODOT_MIRROR_TAG).toBe(runtime.mirrorTag);
+            for (const platform of ['windows', 'linux', 'macos']) {
+                const archive = runtime.archives[platform];
+                expect(archive.name).toContain(`Godot_v${runtime.version}-stable`);
+                expect(archive.sha256).toMatch(/^[a-f0-9]{64}$/);
+                expect(environment[`GODOT_${platform.toUpperCase()}_ARCHIVE_NAME`]).toBe(archive.name);
+                expect(environment[`GODOT_${platform.toUpperCase()}_ARCHIVE_SHA256`]).toBe(archive.sha256);
+            }
+        }
+        finally {
+            fs.rmSync(directory, { recursive: true, force: true });
+        }
+    });
 });

package/dist/src/resources/ResourceRegistry.js

@@ -121,6 +121,46 @@ class ResourceRegistry {
         this.projectionIdsByStableKey.set(input.stableKey, projectionId);
         return { resource, projection };
     }
+    /**
+     * Keeps the resource/projection owners aligned with a document move without
+     * allocating a new resource or changing the stable document projection key.
+     * The document store owns the transition journal; this adapter only mirrors
+     * the committed identity metadata for export and diagnostics consumers.
+     */
+    updateKnowledgeDocumentIdentity(input) {
+        const projection = this.getProjectionByDocumentId(input.documentId);
+        if (!projection) {
+            return false;
+        }
+        const resource = this.resources.get(projection.resourceId);
+        const identityMetadata = {
+            ...(input.sourceUri !== undefined ? { sourceUri: input.sourceUri } : {}),
+            ...(input.revision !== undefined ? { revision: input.revision } : {}),
+            ...(input.identityAliases !== undefined ? { identityAliases: [...input.identityAliases] } : {}),
+        };
+        this.projections.set(projection.projectionId, {
+            ...projection,
+            sourcePath: input.sourcePath,
+            metadata: {
+                ...projection.metadata,
+                ...identityMetadata,
+            },
+            updatedAt: input.updatedAt,
+        });
+        if (resource) {
+            this.resources.set(resource.resourceId, {
+                ...resource,
+                sourcePath: input.sourcePath,
+                title: input.title || resource.title,
+                metadata: {
+                    ...resource.metadata,
+                    ...identityMetadata,
+                },
+                updatedAt: input.updatedAt,
+            });
+        }
+        return true;
+    }
     markDocumentProjectionDeleted(documentId, deletedAt) {
         const stableKey = `knowledge_document:${String(documentId || '').trim()}`;
         const projectionId = this.projectionIdsByStableKey.get(stableKey);