opencode-lcm 0.11.0 → 0.13.0

package/dist/store.js

@@ -167,6 +167,14 @@ function getDeferredPartUpdateKey(event) {
 function compareMessages(a, b) {
     return a.info.time.created - b.info.time.created;
 }
+function emptySession(sessionID) {
+    return {
+        sessionID,
+        updatedAt: 0,
+        eventCount: 0,
+        messages: [],
+    };
+}
 function buildSummaryNodeID(sessionID, level, slot) {
     return `sum_${hashContent(`summary:${sessionID}`).slice(0, 12)}_l${level}_p${slot}`;
 }
@@ -328,6 +336,11 @@ function logStartupPhase(phase, context) {
         return;
     getLogger().info(`startup phase: ${phase}`, context);
 }
+function unrefTimer(timer) {
+    if (typeof timer === 'object' && timer && 'unref' in timer && typeof timer.unref === 'function') {
+        timer.unref();
+    }
+}
 function normalizeSqliteRuntimeOverride(value) {
     const normalized = value?.trim().toLowerCase();
     if (normalized === 'bun' || normalized === 'node')
@@ -347,6 +360,15 @@ export function resolveSqliteRuntimeCandidates(options) {
 export function resolveSqliteRuntime(options) {
     return resolveSqliteRuntimeCandidates(options)[0];
 }
+export function resolveCaptureHydrationMode(options) {
+    const isBunRuntime = options?.isBunRuntime ?? (typeof globalThis === 'object' && 'Bun' in globalThis);
+    const platform = options?.platform ?? process.platform;
+    // The targeted fresh-tail capture path is safe under Node, but the bundled
+    // Bun runtime on Windows has been the only environment where users have
+    // reported native crashes in this hot path. Keep the older full-session
+    // hydration there until Bun/Windows is proven stable again.
+    return isBunRuntime && platform === 'win32' ? 'full' : 'targeted';
+}
 function isSqliteRuntimeImportError(runtime, error) {
     const code = typeof error === 'object' && error && 'code' in error && typeof error.code === 'string'
         ? error.code
@@ -446,6 +468,10 @@ export class SqliteLcmStore {
     workspaceDirectory;
     db;
     dbReadyPromise;
+    deferredInitTimer;
+    deferredInitPromise;
+    deferredInitRequested = false;
+    activeOperationCount = 0;
     pendingPartUpdates = new Map();
     pendingPartUpdateTimer;
     pendingPartUpdateFlushPromise;
@@ -459,8 +485,27 @@ export class SqliteLcmStore {
     async init() {
         await mkdir(this.baseDir, { recursive: true });
     }
+    // Keep deferred SQLite maintenance off the active connection while a store operation is running.
+    async withStoreActivity(operation) {
+        this.activeOperationCount += 1;
+        try {
+            return await operation();
+        }
+        finally {
+            this.activeOperationCount -= 1;
+            if (this.activeOperationCount === 0 && this.deferredInitRequested) {
+                this.scheduleDeferredInit();
+            }
+        }
+    }
+    async waitForDeferredInitIfRunning() {
+        if (!this.deferredInitPromise)
+            return;
+        await this.deferredInitPromise;
+    }
     async prepareForRead() {
         await this.ensureDbReady();
+        await this.waitForDeferredInitIfRunning();
         await this.flushDeferredPartUpdates();
     }
     scheduleDeferredPartUpdateFlush() {
@@ -470,12 +515,7 @@ export class SqliteLcmStore {
             this.pendingPartUpdateTimer = undefined;
             void this.flushDeferredPartUpdates();
         }, SqliteLcmStore.deferredPartUpdateDelayMs);
-        if (typeof this.pendingPartUpdateTimer === 'object' &&
-            this.pendingPartUpdateTimer &&
-            'unref' in this.pendingPartUpdateTimer &&
-            typeof this.pendingPartUpdateTimer.unref === 'function') {
-            this.pendingPartUpdateTimer.unref();
-        }
+        unrefTimer(this.pendingPartUpdateTimer);
     }
     clearDeferredPartUpdateTimer() {
         if (!this.pendingPartUpdateTimer)
@@ -519,57 +559,64 @@ export class SqliteLcmStore {
             this.clearDeferredPartUpdateTimer();
     }
     async captureDeferred(event) {
-        switch (event.type) {
-            case 'message.part.updated': {
-                const key = getDeferredPartUpdateKey(event);
-                if (!key)
-                    return await this.capture(event);
-                this.pendingPartUpdates.set(key, event);
-                this.scheduleDeferredPartUpdateFlush();
-                return;
+        return this.withStoreActivity(async () => {
+            switch (event.type) {
+                case 'message.part.updated': {
+                    const key = getDeferredPartUpdateKey(event);
+                    if (!key)
+                        return await this.capture(event);
+                    this.pendingPartUpdates.set(key, event);
+                    this.scheduleDeferredPartUpdateFlush();
+                    return;
+                }
+                case 'message.part.removed':
+                    this.clearDeferredPartUpdateForPart(event.properties.sessionID, event.properties.messageID, event.properties.partID);
+                    break;
+                case 'message.removed':
+                    this.clearDeferredPartUpdatesForMessage(event.properties.sessionID, event.properties.messageID);
+                    break;
+                case 'session.deleted':
+                    this.clearDeferredPartUpdatesForSession(extractSessionID(event));
+                    break;
+                default:
+                    break;
             }
-            case 'message.part.removed':
-                this.clearDeferredPartUpdateForPart(event.properties.sessionID, event.properties.messageID, event.properties.partID);
-                break;
-            case 'message.removed':
-                this.clearDeferredPartUpdatesForMessage(event.properties.sessionID, event.properties.messageID);
-                break;
-            case 'session.deleted':
-                this.clearDeferredPartUpdatesForSession(extractSessionID(event));
-                break;
-            default:
-                break;
-        }
-        await this.capture(event);
+            await this.capture(event);
+        });
     }
     async flushDeferredPartUpdates() {
-        if (this.pendingPartUpdateFlushPromise)
-            return this.pendingPartUpdateFlushPromise;
-        if (this.pendingPartUpdates.size === 0)
-            return;
-        this.clearDeferredPartUpdateTimer();
-        this.pendingPartUpdateFlushPromise = (async () => {
-            while (this.pendingPartUpdates.size > 0) {
-                const batch = [...this.pendingPartUpdates.values()];
-                this.pendingPartUpdates.clear();
-                for (const event of batch) {
-                    await this.capture(event);
+        return this.withStoreActivity(async () => {
+            if (this.pendingPartUpdateFlushPromise)
+                return this.pendingPartUpdateFlushPromise;
+            if (this.pendingPartUpdates.size === 0)
+                return;
+            this.clearDeferredPartUpdateTimer();
+            this.pendingPartUpdateFlushPromise = (async () => {
+                while (this.pendingPartUpdates.size > 0) {
+                    const batch = [...this.pendingPartUpdates.values()];
+                    this.pendingPartUpdates.clear();
+                    for (const event of batch) {
+                        await this.capture(event);
+                    }
                 }
-            }
-        })().finally(() => {
-            this.pendingPartUpdateFlushPromise = undefined;
-            if (this.pendingPartUpdates.size > 0)
-                this.scheduleDeferredPartUpdateFlush();
+            })().finally(() => {
+                this.pendingPartUpdateFlushPromise = undefined;
+                if (this.pendingPartUpdates.size > 0)
+                    this.scheduleDeferredPartUpdateFlush();
+            });
+            return this.pendingPartUpdateFlushPromise;
         });
-        return this.pendingPartUpdateFlushPromise;
     }
     async ensureDbReady() {
-        if (this.db)
-            return;
-        if (this.dbReadyPromise)
-            return this.dbReadyPromise;
-        this.dbReadyPromise = this.openAndInitializeDb();
-        return this.dbReadyPromise;
+        if (!this.dbReadyPromise) {
+            if (this.db) {
+                this.scheduleDeferredInit();
+                return;
+            }
+            this.dbReadyPromise = this.openAndInitializeDb();
+        }
+        await this.dbReadyPromise;
+        this.scheduleDeferredInit();
     }
     async openAndInitializeDb() {
         logStartupPhase('open-db:start', { dbPath: this.dbPath });
@@ -738,8 +785,6 @@ export class SqliteLcmStore {
             await this.migrateLegacyArtifacts();
             logStartupPhase('open-db:write-schema-version', { schemaVersion: STORE_SCHEMA_VERSION });
             this.writeSchemaVersionSync(STORE_SCHEMA_VERSION);
-            logStartupPhase('open-db:deferred-init:start');
-            this.completeDeferredInit();
             logStartupPhase('open-db:ready');
         }
         catch (error) {
@@ -753,6 +798,54 @@ export class SqliteLcmStore {
         }
     }
     deferredInitCompleted = false;
+    runDeferredInit() {
+        if (this.deferredInitCompleted)
+            return Promise.resolve();
+        if (this.deferredInitPromise)
+            return this.deferredInitPromise;
+        this.deferredInitPromise = this.withStoreActivity(async () => {
+            this.deferredInitRequested = false;
+            logStartupPhase('deferred-init:start');
+            this.completeDeferredInit();
+        })
+            .catch((error) => {
+            getLogger().warn('Deferred LCM maintenance failed', {
+                message: error instanceof Error ? error.message : String(error),
+            });
+        })
+            .finally(() => {
+            this.deferredInitPromise = undefined;
+        });
+        return this.deferredInitPromise;
+    }
+    scheduleDeferredInit() {
+        if (!this.db || this.deferredInitCompleted || this.deferredInitPromise) {
+            return;
+        }
+        this.deferredInitRequested = true;
+        if (this.activeOperationCount > 0 || this.deferredInitTimer)
+            return;
+        logStartupPhase('deferred-init:scheduled');
+        this.deferredInitTimer = setTimeout(() => {
+            this.deferredInitTimer = undefined;
+            if (this.activeOperationCount > 0) {
+                this.scheduleDeferredInit();
+                return;
+            }
+            void this.runDeferredInit();
+        }, 0);
+        unrefTimer(this.deferredInitTimer);
+    }
+    async ensureDeferredInitComplete() {
+        await this.ensureDbReady();
+        if (this.deferredInitCompleted)
+            return;
+        if (this.deferredInitTimer) {
+            clearTimeout(this.deferredInitTimer);
+            this.deferredInitTimer = undefined;
+        }
+        await this.runDeferredInit();
+    }
     readSchemaVersionSync() {
         return firstFiniteNumber(this.getDb().prepare('PRAGMA user_version').get()) ?? 0;
     }
@@ -802,6 +895,10 @@ export class SqliteLcmStore {
     close() {
         this.clearDeferredPartUpdateTimer();
         this.pendingPartUpdates.clear();
+        if (this.deferredInitTimer) {
+            clearTimeout(this.deferredInitTimer);
+            this.deferredInitTimer = undefined;
+        }
         if (!this.db)
             return;
         this.db.close();
@@ -809,51 +906,56 @@ export class SqliteLcmStore {
         this.dbReadyPromise = undefined;
     }
     async capture(event) {
-        await this.ensureDbReady();
-        const normalized = normalizeEvent(event);
-        if (!normalized)
-            return;
-        if (this.shouldRecordEvent(normalized.type)) {
-            this.writeEvent(normalized);
-        }
-        if (!normalized.sessionID)
-            return;
-        if (!this.shouldPersistSessionForEvent(normalized.type))
-            return;
-        const session = this.readSessionSync(normalized.sessionID, {
-            artifactMessageIDs: this.captureArtifactHydrationMessageIDs(normalized),
-        });
-        const previousParentSessionID = session.parentSessionID;
-        let next = this.applyEvent(session, normalized);
-        next.updatedAt = Math.max(next.updatedAt, normalized.timestamp);
-        next.eventCount += 1;
-        next = this.prepareSessionForPersistence(next);
-        const shouldSyncDerivedState = this.shouldSyncDerivedSessionStateForEvent(session, next, normalized);
-        await this.persistCapturedSession(next, normalized);
-        if (this.shouldRefreshLineageForEvent(normalized.type)) {
-            this.refreshAllLineageSync();
-            const refreshed = this.readSessionHeaderSync(normalized.sessionID);
-            if (refreshed) {
-                next = {
-                    ...next,
-                    parentSessionID: refreshed.parentSessionID,
-                    rootSessionID: refreshed.rootSessionID,
-                    lineageDepth: refreshed.lineageDepth,
-                };
+        return this.withStoreActivity(async () => {
+            const normalized = normalizeEvent(event);
+            if (!normalized)
+                return;
+            const shouldRecord = this.shouldRecordEvent(normalized.type);
+            const shouldPersistSession = Boolean(normalized.sessionID) && this.shouldPersistSessionForEvent(normalized.type);
+            if (!shouldRecord && !shouldPersistSession)
+                return;
+            await this.ensureDeferredInitComplete();
+            if (shouldRecord) {
+                this.writeEvent(normalized);
             }
-        }
-        if (shouldSyncDerivedState) {
-            this.syncDerivedSessionStateSync(this.readSessionSync(normalized.sessionID));
-        }
-        if (this.shouldSyncDerivedLineageSubtree(normalized.type, previousParentSessionID, next.parentSessionID)) {
-            this.syncDerivedLineageSubtreeSync(normalized.sessionID, true);
-        }
-        if (this.shouldCleanupOrphanBlobsForEvent(normalized.type)) {
-            this.deleteOrphanArtifactBlobsSync();
-        }
+            if (!normalized.sessionID || !shouldPersistSession)
+                return;
+            const session = resolveCaptureHydrationMode() === 'targeted'
+                ? this.readSessionForCaptureSync(normalized)
+                : this.readSessionSync(normalized.sessionID);
+            const previousParentSessionID = session.parentSessionID;
+            const shouldSyncDerivedState = this.shouldSyncDerivedSessionStateForEvent(session, normalized);
+            let next = this.applyEvent(session, normalized);
+            next.updatedAt = Math.max(next.updatedAt, normalized.timestamp);
+            next.eventCount += 1;
+            next = this.prepareSessionForPersistence(next);
+            await this.persistCapturedSession(next, normalized);
+            if (this.shouldRefreshLineageForEvent(normalized.type)) {
+                this.refreshAllLineageSync();
+                const refreshed = this.readSessionHeaderSync(normalized.sessionID);
+                if (refreshed) {
+                    next = {
+                        ...next,
+                        parentSessionID: refreshed.parentSessionID,
+                        rootSessionID: refreshed.rootSessionID,
+                        lineageDepth: refreshed.lineageDepth,
+                    };
+                }
+            }
+            if (shouldSyncDerivedState) {
+                this.syncDerivedSessionStateSync(this.readSessionSync(normalized.sessionID));
+            }
+            if (this.shouldSyncDerivedLineageSubtree(normalized.type, previousParentSessionID, next.parentSessionID)) {
+                this.syncDerivedLineageSubtreeSync(normalized.sessionID, true);
+            }
+            if (this.shouldCleanupOrphanBlobsForEvent(normalized.type)) {
+                this.deleteOrphanArtifactBlobsSync();
+            }
+        });
     }
     async stats() {
         await this.prepareForRead();
+        await this.ensureDeferredInitComplete();
         const db = this.getDb();
         const totalRow = validateRow(db.prepare('SELECT COUNT(*) AS count, MAX(ts) AS latest FROM events').get(), { count: 'number', latest: 'nullable' }, 'stats.totalEvents');
         const sessionRow = validateRow(db.prepare('SELECT COUNT(*) AS count FROM sessions').get(), { count: 'number' }, 'stats.sessionCount');
@@ -903,13 +1005,13 @@ export class SqliteLcmStore {
         };
     }
     async grep(input) {
-        await this.prepareForRead();
         const resolvedScope = this.resolveConfiguredScope('grep', input.scope, input.sessionID);
-        const sessionIDs = this.resolveScopeSessionIDs(resolvedScope, input.sessionID);
         const limit = input.limit ?? 5;
         const needle = input.query.trim();
         if (!needle)
             return [];
+        await this.prepareForRead();
+        const sessionIDs = this.resolveScopeSessionIDs(resolvedScope, input.sessionID);
         const ftsResults = this.searchWithFts(needle, sessionIDs, limit);
         if (ftsResults.length > 0)
             return ftsResults;
@@ -1206,54 +1308,33 @@ export class SqliteLcmStore {
             eventType === 'message.part.updated' ||
             eventType === 'message.part.removed');
     }
-    captureArtifactHydrationMessageIDs(event) {
-        const payload = event.payload;
-        switch (payload.type) {
-            case 'message.updated':
-                return [payload.properties.info.id];
-            case 'message.part.updated':
-                return [payload.properties.part.messageID];
-            case 'message.part.removed':
-                return [payload.properties.messageID];
-            default:
-                return [];
-        }
-    }
-    archivedMessageIDs(messages) {
-        return this.getArchivedMessages(messages).map((message) => message.info.id);
-    }
-    didArchivedMessagesChange(before, after) {
-        const beforeIDs = this.archivedMessageIDs(before);
-        const afterIDs = this.archivedMessageIDs(after);
-        if (beforeIDs.length !== afterIDs.length)
-            return true;
-        return beforeIDs.some((messageID, index) => messageID !== afterIDs[index]);
-    }
-    isArchivedMessage(messages, messageID) {
-        if (!messageID)
-            return false;
-        return this.archivedMessageIDs(messages).includes(messageID);
-    }
-    shouldSyncDerivedSessionStateForEvent(previous, next, event) {
+    shouldSyncDerivedSessionStateForEvent(session, event) {
         const payload = event.payload;
         switch (payload.type) {
             case 'message.updated': {
-                const messageID = payload.properties.info.id;
-                return (this.didArchivedMessagesChange(previous.messages, next.messages) ||
-                    this.isArchivedMessage(previous.messages, messageID) ||
-                    this.isArchivedMessage(next.messages, messageID));
+                const existing = session.messages.find((message) => message.info.id === payload.properties.info.id);
+                if (existing) {
+                    return this.isMessageArchivedSync(session.sessionID, existing.info.id, existing.info.time.created);
+                }
+                return this.readMessageCountSync(session.sessionID) >= this.options.freshTailMessages;
+            }
+            case 'message.removed': {
+                const existing = safeQueryOne(this.getDb().prepare('SELECT created_at FROM messages WHERE session_id = ? AND message_id = ?'), [session.sessionID, payload.properties.messageID], 'shouldSyncDerivedSessionStateForEvent.messageRemoved');
+                if (!existing)
+                    return false;
+                return this.readMessageCountSync(session.sessionID) > this.options.freshTailMessages;
             }
-            case 'message.removed':
-                return this.didArchivedMessagesChange(previous.messages, next.messages);
             case 'message.part.updated': {
-                const messageID = payload.properties.part.messageID;
-                return (this.isArchivedMessage(previous.messages, messageID) ||
-                    this.isArchivedMessage(next.messages, messageID));
+                const message = session.messages.find((entry) => entry.info.id === payload.properties.part.messageID);
+                if (!message)
+                    return false;
+                return this.isMessageArchivedSync(session.sessionID, message.info.id, message.info.time.created);
             }
             case 'message.part.removed': {
-                const messageID = payload.properties.messageID;
-                return (this.isArchivedMessage(previous.messages, messageID) ||
-                    this.isArchivedMessage(next.messages, messageID));
+                const message = session.messages.find((entry) => entry.info.id === payload.properties.messageID);
+                if (!message)
+                    return false;
+                return this.isMessageArchivedSync(session.sessionID, message.info.id, message.info.time.created);
             }
             default:
                 return false;
@@ -1868,66 +1949,68 @@ export class SqliteLcmStore {
         };
     }
     async compactEventLog(input) {
-        await this.prepareForRead();
-        const apply = input?.apply ?? false;
-        const vacuum = input?.vacuum ?? true;
-        const limit = clamp(input?.limit ?? 10, 1, 50);
-        const candidates = this.readPrunableEventTypeCountsSync();
-        const candidateEvents = candidates.reduce((sum, row) => sum + row.count, 0);
-        const beforeSizes = await this.readStoreFileSizes();
-        if (!apply || candidateEvents === 0) {
+        return this.withStoreActivity(async () => {
+            await this.prepareForRead();
+            const apply = input?.apply ?? false;
+            const vacuum = input?.vacuum ?? true;
+            const limit = clamp(input?.limit ?? 10, 1, 50);
+            const candidates = this.readPrunableEventTypeCountsSync();
+            const candidateEvents = candidates.reduce((sum, row) => sum + row.count, 0);
+            const beforeSizes = await this.readStoreFileSizes();
+            if (!apply || candidateEvents === 0) {
+                return [
+                    `candidate_events=${candidateEvents}`,
+                    `apply=false`,
+                    `vacuum_requested=${vacuum}`,
+                    `db_bytes=${beforeSizes.dbBytes}`,
+                    `wal_bytes=${beforeSizes.walBytes}`,
+                    `shm_bytes=${beforeSizes.shmBytes}`,
+                    `total_bytes=${beforeSizes.totalBytes}`,
+                    ...(candidates.length > 0
+                        ? [
+                            'candidate_event_types:',
+                            ...candidates.slice(0, limit).map((row) => `- ${row.eventType} count=${row.count}`),
+                        ]
+                        : ['candidate_event_types:', '- none']),
+                ].join('\n');
+            }
+            const eventTypes = candidates.map((row) => row.eventType);
+            if (eventTypes.length > 0) {
+                const placeholders = eventTypes.map(() => '?').join(', ');
+                this.getDb()
+                    .prepare(`DELETE FROM events WHERE event_type IN (${placeholders})`)
+                    .run(...eventTypes);
+            }
+            let vacuumApplied = false;
+            this.getDb().exec('PRAGMA wal_checkpoint(TRUNCATE)');
+            if (vacuum) {
+                this.getDb().exec('VACUUM');
+                this.getDb().exec('PRAGMA wal_checkpoint(TRUNCATE)');
+                vacuumApplied = true;
+            }
+            const afterSizes = await this.readStoreFileSizes();
             return [
                 `candidate_events=${candidateEvents}`,
-                `apply=false`,
+                `deleted_events=${candidateEvents}`,
+                `apply=true`,
                 `vacuum_requested=${vacuum}`,
-                `db_bytes=${beforeSizes.dbBytes}`,
-                `wal_bytes=${beforeSizes.walBytes}`,
-                `shm_bytes=${beforeSizes.shmBytes}`,
-                `total_bytes=${beforeSizes.totalBytes}`,
+                `vacuum_applied=${vacuumApplied}`,
+                `db_bytes_before=${beforeSizes.dbBytes}`,
+                `wal_bytes_before=${beforeSizes.walBytes}`,
+                `shm_bytes_before=${beforeSizes.shmBytes}`,
+                `total_bytes_before=${beforeSizes.totalBytes}`,
+                `db_bytes_after=${afterSizes.dbBytes}`,
+                `wal_bytes_after=${afterSizes.walBytes}`,
+                `shm_bytes_after=${afterSizes.shmBytes}`,
+                `total_bytes_after=${afterSizes.totalBytes}`,
                 ...(candidates.length > 0
                     ? [
-                        'candidate_event_types:',
+                        'deleted_event_types:',
                         ...candidates.slice(0, limit).map((row) => `- ${row.eventType} count=${row.count}`),
                     ]
-                    : ['candidate_event_types:', '- none']),
+                    : ['deleted_event_types:', '- none']),
             ].join('\n');
-        }
-        const eventTypes = candidates.map((row) => row.eventType);
-        if (eventTypes.length > 0) {
-            const placeholders = eventTypes.map(() => '?').join(', ');
-            this.getDb()
-                .prepare(`DELETE FROM events WHERE event_type IN (${placeholders})`)
-                .run(...eventTypes);
-        }
-        let vacuumApplied = false;
-        this.getDb().exec('PRAGMA wal_checkpoint(TRUNCATE)');
-        if (vacuum) {
-            this.getDb().exec('VACUUM');
-            this.getDb().exec('PRAGMA wal_checkpoint(TRUNCATE)');
-            vacuumApplied = true;
-        }
-        const afterSizes = await this.readStoreFileSizes();
-        return [
-            `candidate_events=${candidateEvents}`,
-            `deleted_events=${candidateEvents}`,
-            `apply=true`,
-            `vacuum_requested=${vacuum}`,
-            `vacuum_applied=${vacuumApplied}`,
-            `db_bytes_before=${beforeSizes.dbBytes}`,
-            `wal_bytes_before=${beforeSizes.walBytes}`,
-            `shm_bytes_before=${beforeSizes.shmBytes}`,
-            `total_bytes_before=${beforeSizes.totalBytes}`,
-            `db_bytes_after=${afterSizes.dbBytes}`,
-            `wal_bytes_after=${afterSizes.walBytes}`,
-            `shm_bytes_after=${afterSizes.shmBytes}`,
-            `total_bytes_after=${afterSizes.totalBytes}`,
-            ...(candidates.length > 0
-                ? [
-                    'deleted_event_types:',
-                    ...candidates.slice(0, limit).map((row) => `- ${row.eventType} count=${row.count}`),
-                ]
-                : ['deleted_event_types:', '- none']),
-        ].join('\n');
+        });
     }
     async retentionReport(input) {
         await this.prepareForRead();
@@ -2055,44 +2138,50 @@ export class SqliteLcmStore {
         ].join('\n');
     }
     async exportSnapshot(input) {
-        await this.prepareForRead();
-        return exportStoreSnapshot({
-            workspaceDirectory: this.workspaceDirectory,
-            normalizeScope: this.normalizeScope.bind(this),
-            resolveScopeSessionIDs: this.resolveScopeSessionIDs.bind(this),
-            readScopedSessionRowsSync: this.readScopedSessionRowsSync.bind(this),
-            readScopedMessageRowsSync: this.readScopedMessageRowsSync.bind(this),
-            readScopedPartRowsSync: this.readScopedPartRowsSync.bind(this),
-            readScopedResumeRowsSync: this.readScopedResumeRowsSync.bind(this),
-            readScopedArtifactRowsSync: this.readScopedArtifactRowsSync.bind(this),
-            readScopedArtifactBlobRowsSync: this.readScopedArtifactBlobRowsSync.bind(this),
-            readScopedSummaryRowsSync: this.readScopedSummaryRowsSync.bind(this),
-            readScopedSummaryEdgeRowsSync: this.readScopedSummaryEdgeRowsSync.bind(this),
-            readScopedSummaryStateRowsSync: this.readScopedSummaryStateRowsSync.bind(this),
-        }, input);
+        return this.withStoreActivity(async () => {
+            await this.prepareForRead();
+            return exportStoreSnapshot({
+                workspaceDirectory: this.workspaceDirectory,
+                normalizeScope: this.normalizeScope.bind(this),
+                resolveScopeSessionIDs: this.resolveScopeSessionIDs.bind(this),
+                readScopedSessionRowsSync: this.readScopedSessionRowsSync.bind(this),
+                readScopedMessageRowsSync: this.readScopedMessageRowsSync.bind(this),
+                readScopedPartRowsSync: this.readScopedPartRowsSync.bind(this),
+                readScopedResumeRowsSync: this.readScopedResumeRowsSync.bind(this),
+                readScopedArtifactRowsSync: this.readScopedArtifactRowsSync.bind(this),
+                readScopedArtifactBlobRowsSync: this.readScopedArtifactBlobRowsSync.bind(this),
+                readScopedSummaryRowsSync: this.readScopedSummaryRowsSync.bind(this),
+                readScopedSummaryEdgeRowsSync: this.readScopedSummaryEdgeRowsSync.bind(this),
+                readScopedSummaryStateRowsSync: this.readScopedSummaryStateRowsSync.bind(this),
+            }, input);
+        });
     }
     async importSnapshot(input) {
-        await this.prepareForRead();
-        return importStoreSnapshot({
-            workspaceDirectory: this.workspaceDirectory,
-            getDb: () => this.getDb(),
-            clearSessionDataSync: this.clearSessionDataSync.bind(this),
-            backfillArtifactBlobsSync: this.backfillArtifactBlobsSync.bind(this),
-            refreshAllLineageSync: this.refreshAllLineageSync.bind(this),
-            syncAllDerivedSessionStateSync: this.syncAllDerivedSessionStateSync.bind(this),
-            refreshSearchIndexesSync: this.refreshSearchIndexesSync.bind(this),
-        }, input);
+        return this.withStoreActivity(async () => {
+            await this.prepareForRead();
+            return importStoreSnapshot({
+                workspaceDirectory: this.workspaceDirectory,
+                getDb: () => this.getDb(),
+                clearSessionDataSync: this.clearSessionDataSync.bind(this),
+                backfillArtifactBlobsSync: this.backfillArtifactBlobsSync.bind(this),
+                refreshAllLineageSync: this.refreshAllLineageSync.bind(this),
+                syncAllDerivedSessionStateSync: this.syncAllDerivedSessionStateSync.bind(this),
+                refreshSearchIndexesSync: this.refreshSearchIndexesSync.bind(this),
+            }, input);
+        });
     }
     async resume(sessionID) {
-        await this.prepareForRead();
-        const resolvedSessionID = sessionID ?? this.latestSessionIDSync();
-        if (!resolvedSessionID)
-            return 'No stored resume snapshots yet.';
-        const existing = this.getResumeSync(resolvedSessionID);
-        if (existing && !this.isManagedResumeNote(existing))
-            return existing;
-        const generated = await this.buildCompactionContext(resolvedSessionID);
-        return generated ?? existing ?? 'No stored resume snapshot for that session.';
+        return this.withStoreActivity(async () => {
+            await this.prepareForRead();
+            const resolvedSessionID = sessionID ?? this.latestSessionIDSync();
+            if (!resolvedSessionID)
+                return 'No stored resume snapshots yet.';
+            const existing = this.getResumeSync(resolvedSessionID);
+            if (existing && !this.isManagedResumeNote(existing))
+                return existing;
+            const generated = await this.buildCompactionContext(resolvedSessionID);
+            return generated ?? existing ?? 'No stored resume snapshot for that session.';
+        });
     }
     async expand(input) {
         await this.prepareForRead();
@@ -2149,45 +2238,47 @@ export class SqliteLcmStore {
         return note;
     }
     async transformMessages(messages) {
-        await this.prepareForRead();
-        if (messages.length < this.options.minMessagesForTransform)
-            return false;
-        const window = resolveArchiveTransformWindow(messages, this.options.freshTailMessages);
-        if (!window)
-            return false;
-        const { anchor, archived, recent } = window;
-        const roots = this.ensureSummaryGraphSync(anchor.info.sessionID, archived);
-        if (roots.length === 0)
-            return false;
-        const summary = buildActiveSummaryText(roots, archived.length, this.options.summaryCharBudget);
-        const retrieval = await this.buildAutomaticRetrievalContext(anchor.info.sessionID, recent, anchor);
-        for (const message of archived) {
-            this.compactMessageInPlace(message);
-        }
-        anchor.parts = anchor.parts.filter((part) => !isSyntheticLcmTextPart(part, ['archive-summary', 'retrieved-context']));
-        const syntheticParts = [];
-        if (retrieval) {
+        return this.withStoreActivity(async () => {
+            if (messages.length < this.options.minMessagesForTransform)
+                return false;
+            const window = resolveArchiveTransformWindow(messages, this.options.freshTailMessages);
+            if (!window)
+                return false;
+            await this.prepareForRead();
+            const { anchor, archived, recent } = window;
+            const roots = this.ensureSummaryGraphSync(anchor.info.sessionID, archived);
+            if (roots.length === 0)
+                return false;
+            const summary = buildActiveSummaryText(roots, archived.length, this.options.summaryCharBudget);
+            const retrieval = await this.buildAutomaticRetrievalContext(anchor.info.sessionID, recent, anchor);
+            for (const message of archived) {
+                this.compactMessageInPlace(message);
+            }
+            anchor.parts = anchor.parts.filter((part) => !isSyntheticLcmTextPart(part, ['archive-summary', 'retrieved-context']));
+            const syntheticParts = [];
+            if (retrieval) {
+                syntheticParts.push({
+                    id: `lcm-memory-${randomUUID().replace(/-/g, '').slice(0, 12)}`,
+                    sessionID: anchor.info.sessionID,
+                    messageID: anchor.info.id,
+                    type: 'text',
+                    text: retrieval,
+                    synthetic: true,
+                    metadata: { opencodeLcm: 'retrieved-context' },
+                });
+            }
             syntheticParts.push({
-                id: `lcm-memory-${randomUUID().replace(/-/g, '').slice(0, 12)}`,
+                id: `lcm-summary-${randomUUID().replace(/-/g, '').slice(0, 12)}`,
                 sessionID: anchor.info.sessionID,
                 messageID: anchor.info.id,
                 type: 'text',
-                text: retrieval,
+                text: summary,
                 synthetic: true,
-                metadata: { opencodeLcm: 'retrieved-context' },
+                metadata: { opencodeLcm: 'archive-summary' },
             });
-        }
-        syntheticParts.push({
-            id: `lcm-summary-${randomUUID().replace(/-/g, '').slice(0, 12)}`,
-            sessionID: anchor.info.sessionID,
-            messageID: anchor.info.id,
-            type: 'text',
-            text: summary,
-            synthetic: true,
-            metadata: { opencodeLcm: 'archive-summary' },
+            anchor.parts.push(...syntheticParts);
+            return true;
         });
-        anchor.parts.push(...syntheticParts);
-        return true;
     }
     systemHint() {
         if (!this.options.systemHint)
@@ -3136,15 +3227,29 @@ export class SqliteLcmStore {
     resolveLineageSync(sessionID, parentSessionID) {
         if (!parentSessionID)
             return { rootSessionID: sessionID, lineageDepth: 0 };
-        const parent = this.getDb()
-            .prepare('SELECT root_session_id, lineage_depth FROM sessions WHERE session_id = ?')
-            .get(parentSessionID);
-        if (!parent)
-            return { rootSessionID: parentSessionID, lineageDepth: 1 };
-        return {
-            rootSessionID: parent.root_session_id ?? parentSessionID,
-            lineageDepth: (parent.lineage_depth ?? 0) + 1,
-        };
+        const seen = new Set([sessionID]);
+        let currentSessionID = parentSessionID;
+        let lineageDepth = 1;
+        while (currentSessionID && !seen.has(currentSessionID)) {
+            seen.add(currentSessionID);
+            const parent = this.getDb()
+                .prepare('SELECT parent_session_id, root_session_id, lineage_depth FROM sessions WHERE session_id = ?')
+                .get(currentSessionID);
+            if (!parent)
+                return { rootSessionID: currentSessionID, lineageDepth };
+            if (parent.root_session_id && parent.lineage_depth !== null) {
+                return {
+                    rootSessionID: parent.root_session_id,
+                    lineageDepth: parent.lineage_depth + lineageDepth,
+                };
+            }
+            if (!parent.parent_session_id) {
+                return { rootSessionID: currentSessionID, lineageDepth };
+            }
+            currentSessionID = parent.parent_session_id;
+            lineageDepth += 1;
+        }
+        return { rootSessionID: parentSessionID, lineageDepth };
     }
     applyEvent(session, event) {
         const payload = event.payload;
@@ -3204,26 +3309,33 @@ export class SqliteLcmStore {
         const row = safeQueryOne(this.getDb().prepare('SELECT note FROM resumes WHERE session_id = ?'), [sessionID], 'getResumeSync');
         return row?.note;
     }
-    readSessionHeaderSync(sessionID) {
-        const row = safeQueryOne(this.getDb().prepare('SELECT * FROM sessions WHERE session_id = ?'), [sessionID], 'readSessionHeaderSync');
-        if (!row)
-            return undefined;
+    materializeSessionRow(row, messages = []) {
+        const parentSessionID = row.parent_session_id ?? undefined;
+        const derivedLineage = row.root_session_id === null || row.lineage_depth === null
+            ? this.resolveLineageSync(row.session_id, parentSessionID)
+            : undefined;
         return {
             sessionID: row.session_id,
             title: row.title ?? undefined,
             directory: row.session_directory ?? undefined,
-            parentSessionID: row.parent_session_id ?? undefined,
-            rootSessionID: row.root_session_id ?? undefined,
-            lineageDepth: row.lineage_depth ?? undefined,
+            parentSessionID,
+            rootSessionID: row.root_session_id ?? derivedLineage?.rootSessionID,
+            lineageDepth: row.lineage_depth ?? derivedLineage?.lineageDepth,
             pinned: Boolean(row.pinned),
             pinReason: row.pin_reason ?? undefined,
             updatedAt: row.updated_at,
             compactedAt: row.compacted_at ?? undefined,
             deleted: Boolean(row.deleted),
             eventCount: row.event_count,
-            messages: [],
+            messages,
         };
     }
+    readSessionHeaderSync(sessionID) {
+        const row = safeQueryOne(this.getDb().prepare('SELECT * FROM sessions WHERE session_id = ?'), [sessionID], 'readSessionHeaderSync');
+        if (!row)
+            return undefined;
+        return this.materializeSessionRow(row);
+    }
     clearSessionDataSync(sessionID) {
         const db = this.getDb();
         db.prepare('DELETE FROM message_fts WHERE session_id = ?').run(sessionID);
@@ -3361,26 +3473,12 @@ export class SqliteLcmStore {
             const row = sessionMap.get(sessionID);
             const messages = messagesBySession.get(sessionID) ?? [];
             if (!row) {
-                return { sessionID, updatedAt: 0, eventCount: 0, messages };
+                return { ...emptySession(sessionID), messages };
             }
-            return {
-                sessionID: row.session_id,
-                title: row.title ?? undefined,
-                directory: row.session_directory ?? undefined,
-                parentSessionID: row.parent_session_id ?? undefined,
-                rootSessionID: row.root_session_id ?? undefined,
-                lineageDepth: row.lineage_depth ?? undefined,
-                pinned: Boolean(row.pinned),
-                pinReason: row.pin_reason ?? undefined,
-                updatedAt: row.updated_at,
-                compactedAt: row.compacted_at ?? undefined,
-                deleted: Boolean(row.deleted),
-                eventCount: row.event_count,
-                messages,
-            };
+            return this.materializeSessionRow(row, messages);
         });
     }
-    readSessionSync(sessionID, options) {
+    readSessionSync(sessionID) {
         const db = this.getDb();
         const row = safeQueryOne(db.prepare('SELECT * FROM sessions WHERE session_id = ?'), [sessionID], 'readSessionSync');
         const messageRows = db
@@ -3390,11 +3488,7 @@ export class SqliteLcmStore {
             .prepare('SELECT * FROM parts WHERE session_id = ? ORDER BY message_id ASC, sort_key ASC, part_id ASC')
             .all(sessionID);
         const artifactsByPart = new Map();
-        const artifactMessageIDs = options?.artifactMessageIDs;
-        const artifacts = artifactMessageIDs === undefined
-            ? this.readArtifactsForSessionSync(sessionID)
-            : [...new Set(artifactMessageIDs)].flatMap((messageID) => this.readArtifactsForMessageSync(messageID));
-        for (const artifact of artifacts) {
+        for (const artifact of this.readArtifactsForSessionSync(sessionID)) {
             const list = artifactsByPart.get(artifact.partID) ?? [];
             list.push(artifact);
             artifactsByPart.set(artifact.partID, list);
@@ -3413,28 +3507,9 @@ export class SqliteLcmStore {
             parts: partsByMessage.get(messageRow.message_id) ?? [],
         }));
         if (!row) {
-            return {
-                sessionID,
-                updatedAt: 0,
-                eventCount: 0,
-                messages,
-            };
+            return { ...emptySession(sessionID), messages };
         }
-        return {
-            sessionID: row.session_id,
-            title: row.title ?? undefined,
-            directory: row.session_directory ?? undefined,
-            parentSessionID: row.parent_session_id ?? undefined,
-            rootSessionID: row.root_session_id ?? undefined,
-            lineageDepth: row.lineage_depth ?? undefined,
-            pinned: Boolean(row.pinned),
-            pinReason: row.pin_reason ?? undefined,
-            updatedAt: row.updated_at,
-            compactedAt: row.compacted_at ?? undefined,
-            deleted: Boolean(row.deleted),
-            eventCount: row.event_count,
-            messages,
-        };
+        return this.materializeSessionRow(row, messages);
     }
     prepareSessionForPersistence(session) {
         const parentSessionID = this.sanitizeParentSessionIDSync(session.sessionID, session.parentSessionID);
@@ -3462,6 +3537,73 @@ export class SqliteLcmStore {
         }
         return parentSessionID;
     }
+    readSessionForCaptureSync(event) {
+        const sessionID = event.sessionID;
+        if (!sessionID)
+            return emptySession('');
+        const session = this.readSessionHeaderSync(sessionID) ?? emptySession(sessionID);
+        const payload = event.payload;
+        switch (payload.type) {
+            case 'message.updated': {
+                const message = this.readMessageSync(sessionID, payload.properties.info.id);
+                if (message)
+                    session.messages = [message];
+                return session;
+            }
+            case 'message.part.updated': {
+                const message = this.readMessageSync(sessionID, payload.properties.part.messageID);
+                if (message)
+                    session.messages = [message];
+                return session;
+            }
+            case 'message.part.removed': {
+                const message = this.readMessageSync(sessionID, payload.properties.messageID);
+                if (message)
+                    session.messages = [message];
+                return session;
+            }
+            default:
+                return session;
+        }
+    }
+    readMessageSync(sessionID, messageID) {
+        const db = this.getDb();
+        const row = safeQueryOne(db.prepare('SELECT * FROM messages WHERE session_id = ? AND message_id = ?'), [sessionID, messageID], 'readMessageSync');
+        if (!row)
+            return undefined;
+        const artifactsByPart = new Map();
+        for (const artifact of this.readArtifactsForMessageSync(messageID)) {
+            const list = artifactsByPart.get(artifact.partID) ?? [];
+            list.push(artifact);
+            artifactsByPart.set(artifact.partID, list);
+        }
+        const parts = db
+            .prepare('SELECT * FROM parts WHERE session_id = ? AND message_id = ? ORDER BY sort_key ASC, part_id ASC')
+            .all(sessionID, messageID);
+        return {
+            info: parseJson(row.info_json),
+            parts: parts.map((partRow) => {
+                const part = parseJson(partRow.part_json);
+                hydratePartFromArtifacts(part, artifactsByPart.get(part.id) ?? []);
+                return part;
+            }),
+        };
+    }
+    readMessageCountSync(sessionID) {
+        const row = this.getDb()
+            .prepare('SELECT COUNT(*) AS count FROM messages WHERE session_id = ?')
+            .get(sessionID);
+        return row.count;
+    }
+    isMessageArchivedSync(sessionID, messageID, createdAt) {
+        const row = this.getDb()
+            .prepare(`SELECT COUNT(*) AS count
+         FROM messages
+         WHERE session_id = ?
+           AND (created_at > ? OR (created_at = ? AND message_id > ?))`)
+            .get(sessionID, createdAt, createdAt, messageID);
+        return row.count >= this.options.freshTailMessages;
+    }
     async persistCapturedSession(session, event) {
         const payload = event.payload;
         switch (payload.type) {