opencode-lcm 0.12.0 → 0.13.1

package/dist/store.js

@@ -147,6 +147,46 @@ function extractTimestamp(event) {
         return properties.time;
     return Date.now();
 }
+function logMalformedMessage(message, context, extra) {
+    getLogger().warn(message, {
+        operation: context.operation,
+        sessionID: context.sessionID,
+        eventType: context.eventType,
+        ...extra,
+    });
+}
+function getValidMessageInfo(info) {
+    const record = asRecord(info);
+    if (!record)
+        return undefined;
+    const time = asRecord(record.time);
+    if (typeof record.id !== 'string' ||
+        typeof record.sessionID !== 'string' ||
+        typeof record.role !== 'string' ||
+        typeof time?.created !== 'number' ||
+        !Number.isFinite(time.created)) {
+        return undefined;
+    }
+    return info;
+}
+function filterValidConversationMessages(messages, context) {
+    const valid = messages.filter((message) => Boolean(getValidMessageInfo(message?.info)));
+    const dropped = messages.length - valid.length;
+    if (dropped > 0 && context) {
+        logMalformedMessage('Skipping malformed conversation messages', context, { dropped });
+    }
+    return valid;
+}
+function isValidMessagePartUpdate(event) {
+    if (event.type !== 'message.part.updated')
+        return false;
+    const part = asRecord(event.properties.part);
+    if (!part)
+        return false;
+    return (typeof part.id === 'string' &&
+        typeof part.messageID === 'string' &&
+        typeof part.sessionID === 'string');
+}
 function normalizeEvent(event) {
     const record = asRecord(event);
     if (!record || typeof record.type !== 'string')
@@ -165,7 +205,15 @@ function getDeferredPartUpdateKey(event) {
     return `${event.properties.part.sessionID}:${event.properties.part.messageID}:${event.properties.part.id}`;
 }
 function compareMessages(a, b) {
-    return a.info.time.created - b.info.time.created;
+    const aInfo = getValidMessageInfo(a.info);
+    const bInfo = getValidMessageInfo(b.info);
+    if (!aInfo && !bInfo)
+        return 0;
+    if (!aInfo)
+        return 1;
+    if (!bInfo)
+        return -1;
+    return aInfo.time.created - bInfo.time.created || aInfo.id.localeCompare(bInfo.id);
 }
 function emptySession(sessionID) {
     return {
@@ -323,7 +371,7 @@ function listFiles(message) {
 function makeSessionTitle(session) {
     if (session.title)
         return session.title;
-    const firstUser = session.messages.find((message) => message.info.role === 'user');
+    const firstUser = session.messages.find((message) => getValidMessageInfo(message.info)?.role === 'user');
     if (!firstUser)
         return undefined;
     return truncate(guessMessageText(firstUser, []), 80);
@@ -336,6 +384,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')
@@ -463,6 +516,10 @@ export class SqliteLcmStore {
     workspaceDirectory;
     db;
     dbReadyPromise;
+    deferredInitTimer;
+    deferredInitPromise;
+    deferredInitRequested = false;
+    activeOperationCount = 0;
     pendingPartUpdates = new Map();
     pendingPartUpdateTimer;
     pendingPartUpdateFlushPromise;
@@ -476,8 +533,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() {
@@ -487,12 +563,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)
@@ -536,57 +607,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 });
@@ -755,8 +833,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) {
@@ -770,6 +846,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;
     }
@@ -819,6 +943,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();
@@ -826,51 +954,58 @@ 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 = 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,
-                };
+        return this.withStoreActivity(async () => {
+            const normalized = normalizeEvent(event);
+            if (!normalized)
+                return;
+            if (this.shouldSkipMalformedCapturedEvent(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');
@@ -920,13 +1055,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;
@@ -1261,8 +1396,9 @@ export class SqliteLcmStore {
         }
     }
     syncDerivedSessionStateSync(session, preserveExistingResume = false) {
-        const roots = this.ensureSummaryGraphSync(session.sessionID, this.getArchivedMessages(session.messages));
-        this.writeResumeSync(session, roots, preserveExistingResume);
+        const sanitizedSession = this.sanitizeSessionMessages(session, 'syncDerivedSessionStateSync');
+        const roots = this.ensureSummaryGraphSync(sanitizedSession.sessionID, this.getArchivedMessages(sanitizedSession.messages));
+        this.writeResumeSync(sanitizedSession, roots, preserveExistingResume);
         return roots;
     }
     syncDerivedLineageSubtreeSync(sessionID, preserveExistingResume = false) {
@@ -1864,66 +2000,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();
@@ -2051,44 +2189,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();
@@ -2145,45 +2289,53 @@ 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 () => {
+            const validMessages = filterValidConversationMessages(messages, {
+                operation: 'transformMessages',
+            });
+            if (validMessages.length !== messages.length) {
+                messages.splice(0, messages.length, ...validMessages);
+            }
+            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)
@@ -2195,6 +2347,40 @@ export class SqliteLcmStore {
             'Keep ctx_* usage selective and treat those calls as infrastructure, not task intent.',
         ].join(' ');
     }
+    sanitizeSessionMessages(session, operation) {
+        const messages = filterValidConversationMessages(session.messages, {
+            operation,
+            sessionID: session.sessionID,
+        });
+        return messages.length === session.messages.length ? session : { ...session, messages };
+    }
+    shouldSkipMalformedCapturedEvent(event) {
+        const payload = event.payload;
+        switch (payload.type) {
+            case 'message.updated': {
+                if (getValidMessageInfo(payload.properties.info))
+                    return false;
+                logMalformedMessage('Skipping malformed message.updated event', {
+                    operation: 'capture',
+                    sessionID: event.sessionID,
+                    eventType: payload.type,
+                });
+                return true;
+            }
+            case 'message.part.updated': {
+                if (isValidMessagePartUpdate(payload))
+                    return false;
+                logMalformedMessage('Skipping malformed message.part.updated event', {
+                    operation: 'capture',
+                    sessionID: event.sessionID,
+                    eventType: payload.type,
+                });
+                return true;
+            }
+            default:
+                return false;
+        }
+    }
     async buildAutomaticRetrievalContext(sessionID, recent, anchor) {
         if (!this.options.automaticRetrieval.enabled)
             return undefined;
@@ -3001,9 +3187,17 @@ export class SqliteLcmStore {
         return searchByScanModule(this.searchDeps(), query, sessionIDs, limit);
     }
     replaceMessageSearchRowsSync(session) {
-        replaceMessageSearchRowsModule(this.searchDeps(), redactStructuredValue(session, this.privacy));
+        const sanitizedSession = this.sanitizeSessionMessages(session, 'replaceMessageSearchRowsSync');
+        replaceMessageSearchRowsModule(this.searchDeps(), redactStructuredValue(sanitizedSession, this.privacy));
     }
     replaceMessageSearchRowSync(sessionID, message) {
+        if (!getValidMessageInfo(message.info)) {
+            logMalformedMessage('Skipping malformed message search row', {
+                operation: 'replaceMessageSearchRowSync',
+                sessionID,
+            });
+            return;
+        }
         replaceMessageSearchRowModule(this.searchDeps(), sessionID, redactStructuredValue(message, this.privacy));
     }
     refreshSearchIndexesSync(sessionIDs) {
@@ -3132,15 +3326,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;
@@ -3200,26 +3408,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);
@@ -3355,25 +3570,14 @@ export class SqliteLcmStore {
         // Build NormalizedSession results
         return sessionIDs.map((sessionID) => {
             const row = sessionMap.get(sessionID);
-            const messages = messagesBySession.get(sessionID) ?? [];
+            const messages = filterValidConversationMessages(messagesBySession.get(sessionID) ?? [], {
+                operation: 'readSessionsBatchSync',
+                sessionID,
+            });
             if (!row) {
                 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) {
@@ -3400,28 +3604,14 @@ export class SqliteLcmStore {
             parts.push(part);
             partsByMessage.set(partRow.message_id, parts);
         }
-        const messages = messageRows.map((messageRow) => ({
+        const messages = filterValidConversationMessages(messageRows.map((messageRow) => ({
             info: parseJson(messageRow.info_json),
             parts: partsByMessage.get(messageRow.message_id) ?? [],
-        }));
+        })), { operation: 'readSessionSync', sessionID });
         if (!row) {
             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);
@@ -3492,8 +3682,16 @@ export class SqliteLcmStore {
         const parts = db
             .prepare('SELECT * FROM parts WHERE session_id = ? AND message_id = ? ORDER BY sort_key ASC, part_id ASC')
             .all(sessionID, messageID);
+        const info = parseJson(row.info_json);
+        if (!getValidMessageInfo(info)) {
+            logMalformedMessage('Skipping malformed stored message', {
+                operation: 'readMessageSync',
+                sessionID,
+            }, { messageID });
+            return undefined;
+        }
         return {
-            info: parseJson(row.info_json),
+            info,
             parts: parts.map((partRow) => {
                 const part = parseJson(partRow.part_json);
                 hydratePartFromArtifacts(part, artifactsByPart.get(part.id) ?? []);
@@ -3607,7 +3805,15 @@ export class SqliteLcmStore {
          event_count = excluded.event_count`).run(session.sessionID, title ?? null, directory ?? null, worktreeKey ?? null, session.parentSessionID ?? null, session.rootSessionID ?? session.sessionID, session.lineageDepth ?? 0, session.pinned ? 1 : 0, pinReason ?? null, session.updatedAt, session.compactedAt ?? null, session.deleted ? 1 : 0, session.eventCount);
     }
     upsertMessageInfoSync(sessionID, message) {
-        const info = redactStructuredValue(message.info, this.privacy);
+        const validated = getValidMessageInfo(message.info);
+        if (!validated) {
+            logMalformedMessage('Skipping malformed message metadata', {
+                operation: 'upsertMessageInfoSync',
+                sessionID,
+            });
+            return;
+        }
+        const info = redactStructuredValue(validated, this.privacy);
         this.getDb()
             .prepare(`INSERT INTO messages (message_id, session_id, created_at, info_json)
          VALUES (?, ?, ?, ?)
@@ -3638,7 +3844,7 @@ export class SqliteLcmStore {
         return buildArtifactSearchContentModule(artifact);
     }
     async externalizeSession(session) {
-        return externalizeSessionModule(this.artifactDeps(), session);
+        return externalizeSessionModule(this.artifactDeps(), this.sanitizeSessionMessages(session, 'externalizeSession'));
     }
     writeEvent(event) {
         const payloadStub = event.type.startsWith('message.') || event.type.startsWith('session.')