noteconnection 1.8.0 → 1.9.0

package/dist/src/learning/store.js

@@ -38,12 +38,14 @@ exports.isOpsAdapter = isOpsAdapter;
 exports.createFileBackedKnowledgeGraphStore = createFileBackedKnowledgeGraphStore;
 exports.normalizeKnowledgeGraphStoreBackend = normalizeKnowledgeGraphStoreBackend;
 exports.normalizeGraphDbSnapshotAdapterProvider = normalizeGraphDbSnapshotAdapterProvider;
+exports.normalizeStorageProviderKind = normalizeStorageProviderKind;
 exports.normalizeGraphDbStoreOperationMode = normalizeGraphDbStoreOperationMode;
 exports.createFileGraphDbSnapshotAdapter = createFileGraphDbSnapshotAdapter;
 exports.createGraphDbSnapshotAdapter = createGraphDbSnapshotAdapter;
 exports.createKnowledgeGraphStore = createKnowledgeGraphStore;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
 function filterNodesFromSnapshot(snapshot, filter) {
     let results = snapshot.atoms;
     if (filter.nodeIds && filter.nodeIds.length > 0) {
@@ -122,6 +124,8 @@ class FileBackedKnowledgeGraphStore {
         this.loaded = false;
         /** Cached snapshot for operation-level queries without re-reading from disk. */
         this.cachedSnapshot = null;
+        /** Serializes complete replace transactions; concurrent rename is not portable on Windows. */
+        this.pendingSave = Promise.resolve();
     }
     // ── M10.5: Operational Semantics ──
     getCapabilities() {
@@ -172,14 +176,17 @@ class FileBackedKnowledgeGraphStore {
             if ((parsed.schemaVersion !== 1 && parsed.schemaVersion !== 2) || !Array.isArray(parsed.atoms) || !Array.isArray(parsed.documents)) {
                 throw new Error('Invalid knowledge graph snapshot schema.');
             }
+            const snapshot = parsed;
+            this.cachedSnapshot = snapshot;
             this.loaded = true;
             this.lastLoadAt = new Date().toISOString();
-            return parsed;
+            return snapshot;
         }
         catch (error) {
             const code = error?.code;
             if (code === 'ENOENT' || code === 'ENOTDIR') {
                 this.loaded = false;
+                this.cachedSnapshot = null;
                 this.lastError = undefined;
                 return null;
             }
@@ -188,15 +195,21 @@ class FileBackedKnowledgeGraphStore {
             throw error;
         }
     }
-    async saveSnapshot(snapshot) {
+    saveSnapshot(snapshot) {
+        const saveOperation = this.pendingSave.then(() => this.persistSnapshot(snapshot));
+        this.pendingSave = saveOperation.catch(() => undefined);
+        return saveOperation;
+    }
+    async persistSnapshot(snapshot) {
         const filePath = path.resolve(this.options.filePath);
         const directory = path.dirname(filePath);
-        const tempPath = `${filePath}.tmp`;
+        const tempPath = `${filePath}.${process.pid}.${Date.now().toString(36)}.${(0, crypto_1.randomUUID)()}.tmp`;
         await fs.promises.mkdir(directory, { recursive: true });
         const serialized = JSON.stringify(snapshot, null, 2);
         try {
             await fs.promises.writeFile(tempPath, serialized, 'utf8');
             await fs.promises.rename(tempPath, filePath);
+            this.cachedSnapshot = snapshot;
             this.lastSaveAt = new Date().toISOString();
             this.lastError = undefined;
         }
@@ -231,6 +244,9 @@ class FileBackedKnowledgeGraphStore {
             location: filePath,
             exists: fs.existsSync(filePath),
             loaded: this.loaded,
+            requestedProvider: 'file',
+            resolvedProvider: 'file',
+            storageEngine: 'file',
             lastLoadAt: this.lastLoadAt,
             lastSaveAt: this.lastSaveAt,
             lastError: this.lastError,
@@ -297,6 +313,26 @@ function normalizeGraphDbSnapshotAdapterProvider(v) {
         return 'file';
     return 'file';
 }
+/**
+ * Normalize the product-level storage vocabulary without leaking adapter
+ * implementation names into cross-platform diagnostics.
+ */
+function normalizeStorageProviderKind(v) {
+    const normalized = String(v ?? '').trim().toLowerCase();
+    if (normalized === 'sqlite' || normalized === 'embedded_sqlite' || normalized === 'embedded-sqlite' || normalized === 'embedded') {
+        return 'sqlite';
+    }
+    if (normalized === 'file' || normalized === 'local-file' || normalized === 'snapshot') {
+        return 'file';
+    }
+    if (normalized === 'http' || normalized === 'external_http' || normalized === 'remote-http' || normalized === 'service' || normalized === 'remote') {
+        return 'remote';
+    }
+    if (normalized === 'projection' || normalized === 'mobile_projection' || normalized === 'mobile-slim') {
+        return 'projection';
+    }
+    return undefined;
+}
 function normalizeGraphDbStoreOperationMode(v) {
     const s = String(v ?? 'snapshot').trim().toLowerCase();
     if (s === 'snapshot' || s === 'snapshot_only')
@@ -330,6 +366,9 @@ function createFileGraphDbSnapshotAdapter(options) {
         },
         getDiagnostics: () => ({
             ...store.getDiagnostics(),
+            requestedProvider: 'file',
+            resolvedProvider: 'file',
+            storageEngine: 'file',
             capabilityMode: 'ops_capable',
             supportedReadOperations: ['load_snapshot', 'load_snapshot_by_ops', 'probe_snapshot_metadata'],
             supportedWriteOperations: ['save_snapshot', 'save_snapshot_by_ops'],
@@ -680,6 +719,8 @@ function createSqliteGraphDbSnapshotAdapter(options) {
             location: sqlitePath,
             exists: fs.existsSync(sqlitePath),
             loaded,
+            requestedProvider: 'sqlite',
+            resolvedProvider: 'sqlite',
             lastLoadAt: lastLoadAt || undefined,
             lastSaveAt: lastSaveAt || undefined,
             lastError: lastError || undefined,
@@ -719,15 +760,22 @@ function createGraphDbSnapshotAdapter(options) {
         return fileAdapter;
     }
     if (provider === 'sqlite') {
-        const sqliteAdapter = createSqliteGraphDbSnapshotAdapter({
-            provider: 'sqlite',
-            filePath: options?.filePath,
-            sqlitePath: options?.sqlitePath,
-            id: (options?.id ?? options?.sqliteAdapterId ?? options?.adapterId),
-        });
-        if (!sqliteAdapter)
+        try {
+            const sqliteAdapter = createSqliteGraphDbSnapshotAdapter({
+                provider: 'sqlite',
+                filePath: options?.filePath,
+                sqlitePath: options?.sqlitePath,
+                id: (options?.id ?? options?.sqliteAdapterId ?? options?.adapterId),
+            });
+            if (!sqliteAdapter)
+                return null;
+            return sqliteAdapter;
+        }
+        catch {
+            // A sandboxed or read-only host must be allowed to use the
+            // configured file fallback instead of failing during startup.
             return null;
-        return sqliteAdapter;
+        }
     }
     // HTTP adapter — real HTTP communication with graphdb endpoint
     const httpEndpoint = (options?.httpEndpoint ?? options?.baseUrl);
@@ -914,6 +962,9 @@ function createGraphDbSnapshotAdapter(options) {
                 exists: okCount > 0,
                 loaded: okCount > 0,
                 location: snapUrl,
+                requestedProvider: 'remote',
+                resolvedProvider: 'remote',
+                storageEngine: 'remote',
                 capabilityMode: 'ops_capable',
                 supportedReadOperations: ['load_snapshot', 'get_node', 'query_nodes', 'query_edges', 'find_path'],
                 supportedWriteOperations: ['save_snapshot'],
@@ -942,6 +993,20 @@ function createKnowledgeGraphStore(o) {
     const graphdbAdapter = o.graphdb?.adapter ?? o.graphDbAdapter ?? null;
     const graphdbOperationMode = (o.graphdb?.operationMode ?? o.graphDbOperationMode ?? 'snapshot');
     const graphdbFallbackEnabled = (o.graphdb?.fallbackEnabled ?? o.graphDbFallbackEnabled ?? true);
+    const requestedProviderOverride = o.graphdb?.requestedProvider
+        ?? o.graphDbRequestedProvider
+        ?? o.graphDbAdapterProvider;
+    const requestedProviderValue = requestedProviderOverride
+        ?? graphdbAdapter?.provider
+        ?? 'unknown';
+    const requestedProviderKind = normalizeStorageProviderKind(requestedProviderValue);
+    const requestedProvider = requestedProviderKind
+        ?? (String(requestedProviderValue || '').trim().toLowerCase() || 'unknown');
+    const adapterUnavailableReason = requestedProviderKind === 'sqlite'
+        ? 'sqlite_runtime_unavailable'
+        : requestedProviderKind === 'remote'
+            ? 'remote_endpoint_unavailable'
+            : 'graphdb_adapter_unavailable';
     if (backend === 'memory') {
         // In-memory store for testing
         let memorySnapshot = null;
@@ -974,6 +1039,19 @@ function createKnowledgeGraphStore(o) {
                 pathOpsReadCount: 0,
                 pathFallbackCount: 0,
             };
+            const snapshotMetadataFromSnapshot = (snapshot) => {
+                if (!snapshot) {
+                    return null;
+                }
+                return {
+                    schemaVersion: snapshot.schemaVersion,
+                    savedAt: snapshot.savedAt,
+                    atomCount: Array.isArray(snapshot.atoms) ? snapshot.atoms.length : 0,
+                    relationEdgeCount: Array.isArray(snapshot.relationEdges) ? snapshot.relationEdges.length : 0,
+                    temporalEdgeCount: Array.isArray(snapshot.temporalEdges) ? snapshot.temporalEdges.length : 0,
+                    documentCount: Array.isArray(snapshot.documents) ? snapshot.documents.length : 0,
+                };
+            };
             const resolveOpsPath = async () => {
                 if (!opsCapable || requestMode !== 'ops_preferred')
                     return false;
@@ -1004,6 +1082,9 @@ function createKnowledgeGraphStore(o) {
                             const result = await a.loadSnapshotByOps();
                             opsState.probed = true;
                             opsState.opsReadUsed = true;
+                            if (result) {
+                                opsState.lastProbeResult = snapshotMetadataFromSnapshot(result);
+                            }
                             return result;
                         }
                         catch {
@@ -1011,7 +1092,12 @@ function createKnowledgeGraphStore(o) {
                         }
                     }
                 }
-                return a.loadSnapshot();
+                const snapshot = await a.loadSnapshot();
+                if (snapshot) {
+                    opsState.lastProbeResult = snapshotMetadataFromSnapshot(snapshot);
+                    opsState.probed = true;
+                }
+                return snapshot;
             };
             const saveSnapshotThroughAdapter = async (snapshot) => {
                 if (await resolveOpsPath() && typeof a.saveSnapshotByOps === 'function') {
@@ -1107,6 +1193,15 @@ function createKnowledgeGraphStore(o) {
                 getDiagnostics: () => {
                     const diag = a.getDiagnostics?.() ?? {};
                     const caps = resolveOpsCapabilities();
+                    const resolvedProvider = normalizeStorageProviderKind(diag.resolvedProvider
+                        ?? diag.storageEngine
+                        ?? a.provider);
+                    const fallbackReason = diag.fallbackReason
+                        ?? (requestedProviderKind && resolvedProvider && requestedProviderKind !== resolvedProvider
+                            ? requestedProviderKind === 'sqlite' && resolvedProvider === 'file'
+                                ? 'sqlite_runtime_unavailable'
+                                : 'provider_request_mismatch'
+                            : undefined);
                     const totalQueryOpsReadCount = queryOpsState.nodeOpsReadCount
                         + queryOpsState.nodesOpsReadCount
                         + queryOpsState.edgesOpsReadCount
@@ -1123,6 +1218,9 @@ function createKnowledgeGraphStore(o) {
                         adapterId: a.id,
                         ...diag,
                         storeType: 'graphdb',
+                        requestedProvider,
+                        resolvedProvider,
+                        fallbackReason,
                         graphDbOperationMode: normalizeGraphDbStoreOperationMode(graphdbOperationMode),
                         fallbackEnabled: graphdbFallbackEnabled,
                         graphDbAdapterCapabilityMode: diag.capabilityMode ?? caps.mode ?? (opsCapable ? 'ops_capable' : 'snapshot_only'),
@@ -1203,6 +1301,8 @@ function createKnowledgeGraphStore(o) {
                     usingFallback: false,
                     fallbackEnabled: false,
                     lastError: 'graphdb_adapter_unavailable_no_fallback',
+                    requestedProvider,
+                    fallbackReason: `${adapterUnavailableReason}_no_fallback`,
                     graphDbOperationMode: normalizeGraphDbStoreOperationMode(graphdbOperationMode),
                     graphDbAdapterCapabilityMode: 'unknown',
                     graphDbReadPath: 'fallback',
@@ -1229,6 +1329,10 @@ function createKnowledgeGraphStore(o) {
                 usingFallback: true,
                 fallbackEnabled: true,
                 fallbackStoreType: 'file',
+                requestedProvider,
+                resolvedProvider: 'file',
+                fallbackReason: adapterUnavailableReason,
+                storageEngine: 'file',
                 graphDbOperationMode: 'snapshot_only',
                 graphDbAdapterCapabilityMode: 'unknown',
                 graphDbReadPath: 'fallback',

package/dist/src/learning/store.test.js

@@ -413,6 +413,65 @@ describe('Knowledge graph store backend factory', () => {
             fs.rmSync(tempRoot, { recursive: true, force: true });
         }
     });
+    test('refreshes the in-process snapshot cache after a save', async () => {
+        const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'knowledge-store-cache-coherence-'));
+        const filePath = path.join(tempRoot, 'runtime_data', 'knowledge_graph_store.v1.json');
+        try {
+            const store = (0, store_1.createFileBackedKnowledgeGraphStore)({ filePath });
+            const first = createSnapshot('cache_first');
+            first.atoms = [createAtom('atom_first', 'First')];
+            const second = createSnapshot('cache_second');
+            second.atoms = [createAtom('atom_second', 'Second')];
+            await store.saveSnapshot(first);
+            expect(await store.getNode('atom_first')).toEqual(first.atoms[0]);
+            await store.saveSnapshot(second);
+            expect(await store.getNode('atom_first')).toBeNull();
+            expect(await store.getNode('atom_second')).toEqual(second.atoms[0]);
+        }
+        finally {
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
+    test('uses a unique sibling temporary path for each save', async () => {
+        const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'knowledge-store-atomic-save-'));
+        const filePath = path.join(tempRoot, 'runtime_data', 'knowledge_graph_store.v1.json');
+        const renameSpy = jest.spyOn(fs.promises, 'rename');
+        try {
+            const store = (0, store_1.createKnowledgeGraphStore)({ backend: 'file', filePath });
+            await store.saveSnapshot(createSnapshot('atomic_first'));
+            await store.saveSnapshot(createSnapshot('atomic_second'));
+            const temporaryPaths = renameSpy.mock.calls
+                .map(([sourcePath]) => String(sourcePath));
+            expect(new Set(temporaryPaths).size).toBe(2);
+            expect(fs.existsSync(filePath)).toBe(true);
+            expect(fs.readdirSync(path.dirname(filePath)).filter((name) => name.includes('.tmp'))).toHaveLength(0);
+        }
+        finally {
+            renameSpy.mockRestore();
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
+    test('keeps the target parseable when saves overlap', async () => {
+        const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'knowledge-store-concurrent-save-'));
+        const filePath = path.join(tempRoot, 'runtime_data', 'knowledge_graph_store.v1.json');
+        try {
+            const store = (0, store_1.createFileBackedKnowledgeGraphStore)({ filePath });
+            const first = createSnapshot('concurrent_first');
+            first.atoms = [createAtom('atom_concurrent_first', 'Concurrent First')];
+            const second = createSnapshot('concurrent_second');
+            second.atoms = [createAtom('atom_concurrent_second', 'Concurrent Second')];
+            await Promise.all([
+                store.saveSnapshot(first),
+                store.saveSnapshot(second),
+            ]);
+            const persisted = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+            expect(['atom_concurrent_first', 'atom_concurrent_second']).toContain(persisted.atoms[0]?.id);
+            expect(fs.readdirSync(path.dirname(filePath)).filter((name) => name.endsWith('.tmp'))).toHaveLength(0);
+        }
+        finally {
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
     test('normalizes graphdb adapter provider aliases', () => {
         expect((0, store_1.normalizeGraphDbSnapshotAdapterProvider)('file')).toBe('file');
         expect((0, store_1.normalizeGraphDbSnapshotAdapterProvider)('local-file')).toBe('file');
@@ -426,6 +485,37 @@ describe('Knowledge graph store backend factory', () => {
         expect((0, store_1.normalizeGraphDbSnapshotAdapterProvider)('fallback_only')).toBe('none');
         expect((0, store_1.normalizeGraphDbSnapshotAdapterProvider)('unknown')).toBe('file');
     });
+    test('normalizes cross-platform storage provider kinds without conflating http and projection', () => {
+        expect((0, store_1.normalizeStorageProviderKind)('sqlite')).toBe('sqlite');
+        expect((0, store_1.normalizeStorageProviderKind)('embedded-sqlite')).toBe('sqlite');
+        expect((0, store_1.normalizeStorageProviderKind)('file')).toBe('file');
+        expect((0, store_1.normalizeStorageProviderKind)('external_http')).toBe('remote');
+        expect((0, store_1.normalizeStorageProviderKind)('remote')).toBe('remote');
+        expect((0, store_1.normalizeStorageProviderKind)('mobile_projection')).toBe('projection');
+        expect((0, store_1.normalizeStorageProviderKind)('unknown')).toBeUndefined();
+    });
+    test('reports file resolution when a requested sqlite graph adapter is unavailable', async () => {
+        const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'knowledge-store-provider-resolution-'));
+        const filePath = path.join(tempRoot, 'runtime_data', 'knowledge_graph_store.v1.json');
+        try {
+            const store = (0, store_1.createKnowledgeGraphStore)({
+                backend: 'graphdb',
+                filePath,
+                graphdb: { adapter: null },
+                graphDbRequestedProvider: 'sqlite',
+                graphDbFallbackEnabled: true,
+            });
+            expect(store.getDiagnostics()).toEqual(expect.objectContaining({
+                requestedProvider: 'sqlite',
+                resolvedProvider: 'file',
+                fallbackReason: 'sqlite_runtime_unavailable',
+                storageEngine: 'file',
+            }));
+        }
+        finally {
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
     test('normalizes graphdb operation mode aliases', () => {
         expect((0, store_1.normalizeGraphDbStoreOperationMode)('snapshot')).toBe('snapshot_only');
         expect((0, store_1.normalizeGraphDbStoreOperationMode)('snapshot_only')).toBe('snapshot_only');
@@ -873,6 +963,8 @@ describe('Knowledge graph store backend factory', () => {
             expect(diagnostics.capabilityMode).toBe('ops_capable');
             expect(diagnostics.supportedReadOperations).toEqual(expect.arrayContaining(['load_snapshot', 'get_node', 'query_nodes', 'query_edges', 'find_path']));
             expect(diagnostics.supportedWriteOperations).toEqual(['save_snapshot']);
+            expect(diagnostics.requestedProvider).toBe('remote');
+            expect(diagnostics.resolvedProvider).toBe('remote');
             expect(String(diagnostics.connector?.healthStatus || '')).toBe('ready');
             expect(String(diagnostics.connector?.circuitState || '')).toBe('closed');
             expect(Number(diagnostics.connector?.requestCount || 0)).toBeGreaterThanOrEqual(2);
@@ -886,6 +978,55 @@ describe('Knowledge graph store backend factory', () => {
             await mockServer.close();
         }
     });
+    test('reports a SQLite runtime fallback when a file adapter is supplied for a SQLite request', () => {
+        const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'knowledge-store-provider-mismatch-'));
+        const filePath = path.join(tempRoot, 'runtime_data', 'knowledge_graph_store.graphdb.v1.json');
+        try {
+            const adapter = (0, store_1.createFileGraphDbSnapshotAdapter)({ filePath, id: 'file-fallback-adapter' });
+            const store = (0, store_1.createKnowledgeGraphStore)({
+                backend: 'graphdb',
+                filePath,
+                graphdb: { adapter },
+                graphDbRequestedProvider: 'sqlite',
+                graphDbFallbackEnabled: true,
+            });
+            expect(store.getDiagnostics()).toEqual(expect.objectContaining({
+                requestedProvider: 'sqlite',
+                resolvedProvider: 'file',
+                fallbackReason: 'sqlite_runtime_unavailable',
+                storageEngine: 'file',
+            }));
+        }
+        finally {
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
+    test('returns an unavailable SQLite adapter instead of throwing when its parent path cannot be created', () => {
+        const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'knowledge-store-sqlite-init-failure-'));
+        const parentFile = path.join(tempRoot, 'not-a-directory');
+        fs.writeFileSync(parentFile, 'occupied', 'utf8');
+        try {
+            const adapter = (0, store_1.createGraphDbSnapshotAdapter)({
+                provider: 'sqlite',
+                sqlitePath: path.join(parentFile, 'knowledge.sqlite'),
+            });
+            expect(adapter).toBeNull();
+            const fallbackPath = path.join(tempRoot, 'fallback', 'knowledge.json');
+            const store = (0, store_1.createKnowledgeGraphStore)({
+                backend: 'graphdb',
+                filePath: fallbackPath,
+                graphdb: { adapter: null },
+                graphDbRequestedProvider: 'sqlite',
+            });
+            expect(store.getDiagnostics()).toEqual(expect.objectContaining({
+                resolvedProvider: 'file',
+                fallbackReason: 'sqlite_runtime_unavailable',
+            }));
+        }
+        finally {
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
     test('graphdb store proxies node/edge/path operations through http ops adapter when ops mode is preferred', async () => {
         const mockServer = await startMockGraphDbSnapshotServer();
         try {
@@ -980,6 +1121,9 @@ describe('Knowledge graph store backend factory', () => {
             expect(String(diagnostics.location || '')).toContain('knowledge_graph_store.graphdb.v1.sqlite');
             expect(diagnostics.storeType).toBe('graphdb');
             expect(String(diagnostics.storageEngine || '')).toBe('sqlite');
+            expect(diagnostics.requestedProvider).toBe('sqlite');
+            expect(diagnostics.resolvedProvider).toBe('sqlite');
+            expect(diagnostics.fallbackReason).toBeUndefined();
             expect(diagnostics.capabilityMode).toBe('ops_capable');
             expect(diagnostics.supportedReadOperations).toEqual(expect.arrayContaining(['load_snapshot', 'get_node', 'query_nodes', 'query_edges', 'find_path']));
             expect(diagnostics.supportedWriteOperations).toEqual(['save_snapshot']);
@@ -1059,6 +1203,161 @@ describe('Knowledge graph store backend factory', () => {
             fs.rmSync(tempRoot, { recursive: true, force: true });
         }
     });
+    test('sqlite graphdb adapter reopens after close and replays the last committed snapshot', async () => {
+        const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'knowledge-store-sqlite-replay-'));
+        const sqlitePath = path.join(tempRoot, 'runtime_data', 'knowledge_graph_store.graphdb.v1.sqlite');
+        let firstAdapter = null;
+        let secondAdapter = null;
+        try {
+            firstAdapter = (0, store_1.createGraphDbSnapshotAdapter)({
+                provider: 'sqlite',
+                sqlitePath,
+                adapterId: 'embedded-sqlite-replay-before-close',
+            });
+            expect(firstAdapter).not.toBeNull();
+            const snapshot = createSnapshot('sqlite_restart_user');
+            snapshot.atoms = [createAtom('restart_atom', 'Restart Alpha')];
+            snapshot.documents = [{
+                    documentId: 'restart_doc',
+                    sourcePath: 'restart.md',
+                    sourceHash: 'restart_hash',
+                    version: 1,
+                    updatedAt: '2026-01-01T00:00:00.000Z',
+                    atomStableKeyToId: [['restart_stable', 'restart_atom']],
+                    atomIds: ['restart_atom'],
+                    evidenceSpanIds: [],
+                    relationEdgeIds: [],
+                    temporalEdgeIds: [],
+                }];
+            await firstAdapter.saveSnapshot(snapshot);
+            firstAdapter.close?.();
+            secondAdapter = (0, store_1.createGraphDbSnapshotAdapter)({
+                provider: 'sqlite',
+                sqlitePath,
+                adapterId: 'embedded-sqlite-replay-after-close',
+            });
+            expect(secondAdapter).not.toBeNull();
+            await expect(secondAdapter.loadSnapshot()).resolves.toEqual(snapshot);
+            await expect(secondAdapter.getNodeByOps?.('restart_atom')).resolves.toEqual(snapshot.atoms[0]);
+            await expect(secondAdapter.probeSnapshotMetadata?.()).resolves.toEqual(expect.objectContaining({
+                atomCount: 1,
+                documentCount: 1,
+            }));
+        }
+        finally {
+            try {
+                firstAdapter?.close?.();
+                secondAdapter?.close?.();
+            }
+            catch {
+            }
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
+    test('graphdb store diagnostics restores snapshot metadata after reopening the sqlite adapter', async () => {
+        const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'knowledge-store-sqlite-diagnostics-reopen-'));
+        const sqlitePath = path.join(tempRoot, 'runtime_data', 'knowledge_graph_store.graphdb.v1.sqlite');
+        let firstAdapter = null;
+        let secondAdapter = null;
+        let firstStore = null;
+        let secondStore = null;
+        try {
+            const snapshot = createSnapshot('sqlite_store_diagnostics_reopen_user');
+            snapshot.atoms = [createAtom('reopen_atom', 'Reopen Alpha')];
+            snapshot.documents = [{
+                    documentId: 'reopen_doc',
+                    sourcePath: '/reopen/doc.md',
+                    sourceHash: 'reopen_hash',
+                    version: 1,
+                    updatedAt: '2026-01-01T00:00:00.000Z',
+                    atomStableKeyToId: [['reopen_atom_stable', 'reopen_atom']],
+                    atomIds: ['reopen_atom'],
+                    evidenceSpanIds: [],
+                    relationEdgeIds: [],
+                    temporalEdgeIds: [],
+                }];
+            firstAdapter = (0, store_1.createGraphDbSnapshotAdapter)({ provider: 'sqlite', sqlitePath, adapterId: 'sqlite-diagnostics-reopen-first' });
+            expect(firstAdapter).not.toBeNull();
+            firstStore = (0, store_1.createKnowledgeGraphStore)({
+                backend: 'graphdb',
+                graphdb: { adapter: firstAdapter },
+                graphDbFallbackEnabled: false,
+                graphDbOperationMode: 'ops_preferred',
+            });
+            await firstStore.saveSnapshot(snapshot);
+            firstStore.close?.();
+            firstStore = null;
+            firstAdapter = null;
+            secondAdapter = (0, store_1.createGraphDbSnapshotAdapter)({ provider: 'sqlite', sqlitePath, adapterId: 'sqlite-diagnostics-reopen-second' });
+            expect(secondAdapter).not.toBeNull();
+            secondStore = (0, store_1.createKnowledgeGraphStore)({
+                backend: 'graphdb',
+                graphdb: { adapter: secondAdapter },
+                graphDbFallbackEnabled: false,
+                graphDbOperationMode: 'ops_preferred',
+            });
+            await expect(secondStore.loadSnapshot()).resolves.toEqual(snapshot);
+            expect(secondStore.getDiagnostics().graphDbLastSnapshotMetadata).toEqual(expect.objectContaining({
+                atomCount: 1,
+                documentCount: 1,
+            }));
+        }
+        finally {
+            try {
+                firstStore?.close?.();
+            }
+            catch { }
+            try {
+                secondStore?.close?.();
+            }
+            catch { }
+            try {
+                firstAdapter?.close?.();
+            }
+            catch { }
+            try {
+                secondAdapter?.close?.();
+            }
+            catch { }
+            fs.rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
+    test('graphdb store diagnostics derives metadata from ops reads when the adapter has no probe method', async () => {
+        const snapshot = createSnapshot('ops_read_metadata_user');
+        snapshot.atoms = [createAtom('ops_read_atom', 'Ops Read Alpha')];
+        snapshot.documents = [{
+                documentId: 'ops_read_doc',
+                sourcePath: '/ops-read/doc.md',
+                sourceHash: 'ops_read_hash',
+                version: 1,
+                updatedAt: '2026-01-01T00:00:00.000Z',
+                atomStableKeyToId: [['ops_read_atom_stable', 'ops_read_atom']],
+                atomIds: ['ops_read_atom'],
+                evidenceSpanIds: [],
+                relationEdgeIds: [],
+                temporalEdgeIds: [],
+            }];
+        const adapter = {
+            id: 'ops-only-without-probe',
+            opsCapable: true,
+            loadSnapshot: async () => snapshot,
+            saveSnapshot: async () => undefined,
+            loadSnapshotByOps: async () => snapshot,
+            saveSnapshotByOps: async () => undefined,
+            getCapabilities: () => ({ mode: 'ops_capable', snapshotSupported: true, writeSupported: true }),
+        };
+        const store = (0, store_1.createKnowledgeGraphStore)({
+            backend: 'graphdb',
+            graphdb: { adapter },
+            graphDbFallbackEnabled: false,
+            graphDbOperationMode: 'ops_preferred',
+        });
+        await expect(store.loadSnapshot()).resolves.toEqual(snapshot);
+        expect(store.getDiagnostics().graphDbLastSnapshotMetadata).toEqual(expect.objectContaining({
+            atomCount: 1,
+            documentCount: 1,
+        }));
+    });
     test('built-in http graphdb adapter surfaces circuit-open telemetry after repeated transient failures', async () => {
         const server = http.createServer((req, res) => {
             const method = String(req.method || 'GET').toUpperCase();