opencode-lcm 0.12.0 → 0.13.1

package/src/store.ts

@@ -338,6 +338,66 @@ function extractTimestamp(event: unknown): number {
   return Date.now();
 }
 
+type MessageValidationContext = {
+  operation: string;
+  sessionID?: string;
+  eventType?: string;
+};
+
+function logMalformedMessage(
+  message: string,
+  context: MessageValidationContext,
+  extra?: Record<string, unknown>,
+): void {
+  getLogger().warn(message, {
+    operation: context.operation,
+    sessionID: context.sessionID,
+    eventType: context.eventType,
+    ...extra,
+  });
+}
+
+function getValidMessageInfo(info: unknown): Message | undefined {
+  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 as Message;
+}
+
+function filterValidConversationMessages(
+  messages: ConversationMessage[],
+  context?: MessageValidationContext,
+): ConversationMessage[] {
+  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: Event): boolean {
+  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: unknown): CapturedEvent | null {
   const record = asRecord(event);
   if (!record || typeof record.type !== 'string') return null;
@@ -357,7 +417,13 @@ function getDeferredPartUpdateKey(event: Event): string | undefined {
 }
 
 function compareMessages(a: ConversationMessage, b: ConversationMessage): number {
-  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: string): NormalizedSession {
@@ -513,7 +579,9 @@ function listFiles(message: ConversationMessage): string[] {
 function makeSessionTitle(session: NormalizedSession): string | undefined {
   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);
@@ -528,6 +596,12 @@ function logStartupPhase(phase: string, context?: Record<string, unknown>): void
   getLogger().info(`startup phase: ${phase}`, context);
 }
 
+function unrefTimer(timer: ReturnType<typeof setTimeout> | undefined): void {
+  if (typeof timer === 'object' && timer && 'unref' in timer && typeof timer.unref === 'function') {
+    timer.unref();
+  }
+}
+
 type SqliteRuntime = 'bun' | 'node';
 type SqliteRuntimeOptions = {
   envOverride?: string | undefined;
@@ -707,6 +781,10 @@ export class SqliteLcmStore {
   private readonly workspaceDirectory: string;
   private db?: SqlDatabaseLike;
   private dbReadyPromise?: Promise<void>;
+  private deferredInitTimer?: ReturnType<typeof setTimeout>;
+  private deferredInitPromise?: Promise<void>;
+  private deferredInitRequested = false;
+  private activeOperationCount = 0;
   private readonly pendingPartUpdates = new Map<string, Event>();
   private pendingPartUpdateTimer?: ReturnType<typeof setTimeout>;
   private pendingPartUpdateFlushPromise?: Promise<void>;
@@ -725,8 +803,27 @@ export class SqliteLcmStore {
     await mkdir(this.baseDir, { recursive: true });
   }
 
+  // Keep deferred SQLite maintenance off the active connection while a store operation is running.
+  private async withStoreActivity<T>(operation: () => Promise<T>): Promise<T> {
+    this.activeOperationCount += 1;
+    try {
+      return await operation();
+    } finally {
+      this.activeOperationCount -= 1;
+      if (this.activeOperationCount === 0 && this.deferredInitRequested) {
+        this.scheduleDeferredInit();
+      }
+    }
+  }
+
+  private async waitForDeferredInitIfRunning(): Promise<void> {
+    if (!this.deferredInitPromise) return;
+    await this.deferredInitPromise;
+  }
+
   private async prepareForRead(): Promise<void> {
     await this.ensureDbReady();
+    await this.waitForDeferredInitIfRunning();
     await this.flushDeferredPartUpdates();
   }
 
@@ -737,15 +834,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);
   }
 
   private clearDeferredPartUpdateTimer(): void {
@@ -790,63 +879,73 @@ export class SqliteLcmStore {
   }
 
   async captureDeferred(event: Event): Promise<void> {
-    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(): Promise<void> {
-    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;
+    });
   }
 
   private async ensureDbReady(): Promise<void> {
-    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();
   }
 
   private async openAndInitializeDb(): Promise<void> {
@@ -1024,8 +1123,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) {
       logStartupPhase('open-db:error', {
@@ -1040,6 +1137,59 @@ export class SqliteLcmStore {
 
   private deferredInitCompleted = false;
 
+  private runDeferredInit(): Promise<void> {
+    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;
+  }
+
+  private scheduleDeferredInit(): void {
+    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);
+  }
+
+  private async ensureDeferredInitComplete(): Promise<void> {
+    await this.ensureDbReady();
+    if (this.deferredInitCompleted) return;
+
+    if (this.deferredInitTimer) {
+      clearTimeout(this.deferredInitTimer);
+      this.deferredInitTimer = undefined;
+    }
+
+    await this.runDeferredInit();
+  }
+
   private readSchemaVersionSync(): number {
     return firstFiniteNumber(this.getDb().prepare('PRAGMA user_version').get()) ?? 0;
   }
@@ -1101,6 +1251,10 @@ export class SqliteLcmStore {
   close(): void {
     this.clearDeferredPartUpdateTimer();
     this.pendingPartUpdates.clear();
+    if (this.deferredInitTimer) {
+      clearTimeout(this.deferredInitTimer);
+      this.deferredInitTimer = undefined;
+    }
     if (!this.db) return;
     this.db.close();
     this.db = undefined;
@@ -1108,65 +1262,77 @@ export class SqliteLcmStore {
   }
 
   async capture(event: Event): Promise<void> {
-    await this.ensureDbReady();
+    return this.withStoreActivity(async () => {
+      const normalized = normalizeEvent(event);
+      if (!normalized) return;
 
-    const normalized = normalizeEvent(event);
-    if (!normalized) return;
+      if (this.shouldSkipMalformedCapturedEvent(normalized)) return;
 
-    if (this.shouldRecordEvent(normalized.type)) {
-      this.writeEvent(normalized);
-    }
+      const shouldRecord = this.shouldRecordEvent(normalized.type);
+      const shouldPersistSession =
+        Boolean(normalized.sessionID) && this.shouldPersistSessionForEvent(normalized.type);
+      if (!shouldRecord && !shouldPersistSession) return;
 
-    if (!normalized.sessionID) return;
-    if (!this.shouldPersistSessionForEvent(normalized.type)) return;
+      await this.ensureDeferredInitComplete();
 
-    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);
+      if (shouldRecord) {
+        this.writeEvent(normalized);
+      }
 
-    await this.persistCapturedSession(next, normalized);
+      if (!normalized.sessionID || !shouldPersistSession) return;
 
-    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,
-        };
+      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 (shouldSyncDerivedState) {
+        this.syncDerivedSessionStateSync(this.readSessionSync(normalized.sessionID));
+      }
 
-    if (
-      this.shouldSyncDerivedLineageSubtree(
-        normalized.type,
-        previousParentSessionID,
-        next.parentSessionID,
-      )
-    ) {
-      this.syncDerivedLineageSubtreeSync(normalized.sessionID, true);
-    }
+      if (
+        this.shouldSyncDerivedLineageSubtree(
+          normalized.type,
+          previousParentSessionID,
+          next.parentSessionID,
+        )
+      ) {
+        this.syncDerivedLineageSubtreeSync(normalized.sessionID, true);
+      }
 
-    if (this.shouldCleanupOrphanBlobsForEvent(normalized.type)) {
-      this.deleteOrphanArtifactBlobsSync();
-    }
+      if (this.shouldCleanupOrphanBlobsForEvent(normalized.type)) {
+        this.deleteOrphanArtifactBlobsSync();
+      }
+    });
   }
 
   async stats(): Promise<StoreStats> {
     await this.prepareForRead();
+    await this.ensureDeferredInitComplete();
     const db = this.getDb();
     const totalRow = validateRow<{ count: number; latest: number | null }>(
       db.prepare('SELECT COUNT(*) AS count, MAX(ts) AS latest FROM events').get(),
@@ -1283,13 +1449,14 @@ export class SqliteLcmStore {
     scope?: string;
     limit?: number;
   }): Promise<SearchResult[]> {
-    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;
     return this.searchByScan(needle.toLowerCase(), sessionIDs, limit);
@@ -1735,11 +1902,12 @@ export class SqliteLcmStore {
     session: NormalizedSession,
     preserveExistingResume = false,
   ): SummaryNodeData[] {
+    const sanitizedSession = this.sanitizeSessionMessages(session, 'syncDerivedSessionStateSync');
     const roots = this.ensureSummaryGraphSync(
-      session.sessionID,
-      this.getArchivedMessages(session.messages),
+      sanitizedSession.sessionID,
+      this.getArchivedMessages(sanitizedSession.messages),
     );
-    this.writeResumeSync(session, roots, preserveExistingResume);
+    this.writeResumeSync(sanitizedSession, roots, preserveExistingResume);
     return roots;
   }
 
@@ -2516,71 +2684,73 @@ export class SqliteLcmStore {
     vacuum?: boolean;
     limit?: number;
   }): Promise<string> {
-    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();
+    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();
 
-    if (!apply || candidateEvents === 0) {
       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?: {
@@ -2750,24 +2920,26 @@ export class SqliteLcmStore {
     sessionID?: string;
     scope?: string;
   }): Promise<string> {
-    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: {
@@ -2775,31 +2947,35 @@ export class SqliteLcmStore {
     mode?: 'replace' | 'merge';
     worktreeMode?: SnapshotWorktreeMode;
   }): Promise<string> {
-    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?: string): Promise<string> {
-    await this.prepareForRead();
-    const resolvedSessionID = sessionID ?? this.latestSessionIDSync();
-    if (!resolvedSessionID) return 'No stored resume snapshots yet.';
+    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 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.';
+      const generated = await this.buildCompactionContext(resolvedSessionID);
+      return generated ?? existing ?? 'No stored resume snapshot for that session.';
+    });
   }
 
   async expand(input: {
@@ -2883,53 +3059,66 @@ export class SqliteLcmStore {
   }
 
   async transformMessages(messages: ConversationMessage[]): Promise<boolean> {
-    await this.prepareForRead();
-    if (messages.length < this.options.minMessagesForTransform) return false;
+    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;
+      const window = resolveArchiveTransformWindow(messages, this.options.freshTailMessages);
+      if (!window) return false;
 
-    const { anchor, archived, recent } = window;
+      await this.prepareForRead();
 
-    const roots = this.ensureSummaryGraphSync(anchor.info.sessionID, archived);
-    if (roots.length === 0) return false;
+      const { anchor, archived, recent } = window;
 
-    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);
-    }
+      const roots = this.ensureSummaryGraphSync(anchor.info.sessionID, archived);
+      if (roots.length === 0) return false;
 
-    anchor.parts = anchor.parts.filter(
-      (part) => !isSyntheticLcmTextPart(part, ['archive-summary', 'retrieved-context']),
-    );
-    const syntheticParts: Part[] = [];
-    if (retrieval) {
+      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: Part[] = [];
+      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(): string | undefined {
@@ -2943,6 +3132,44 @@ export class SqliteLcmStore {
     ].join(' ');
   }
 
+  private sanitizeSessionMessages(
+    session: NormalizedSession,
+    operation: string,
+  ): NormalizedSession {
+    const messages = filterValidConversationMessages(session.messages, {
+      operation,
+      sessionID: session.sessionID,
+    });
+    return messages.length === session.messages.length ? session : { ...session, messages };
+  }
+
+  private shouldSkipMalformedCapturedEvent(event: CapturedEvent): boolean {
+    const payload = event.payload as Event;
+
+    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;
+    }
+  }
+
   private async buildAutomaticRetrievalContext(
     sessionID: string,
     recent: ConversationMessage[],
@@ -4072,10 +4299,22 @@ export class SqliteLcmStore {
   }
 
   private replaceMessageSearchRowsSync(session: NormalizedSession): void {
-    replaceMessageSearchRowsModule(this.searchDeps(), redactStructuredValue(session, this.privacy));
+    const sanitizedSession = this.sanitizeSessionMessages(session, 'replaceMessageSearchRowsSync');
+    replaceMessageSearchRowsModule(
+      this.searchDeps(),
+      redactStructuredValue(sanitizedSession, this.privacy),
+    );
   }
 
   private replaceMessageSearchRowSync(sessionID: string, message: ConversationMessage): void {
+    if (!getValidMessageInfo(message.info)) {
+      logMalformedMessage('Skipping malformed message search row', {
+        operation: 'replaceMessageSearchRowSync',
+        sessionID,
+      });
+      return;
+    }
+
     replaceMessageSearchRowModule(
       this.searchDeps(),
       sessionID,
@@ -4240,17 +4479,40 @@ export class SqliteLcmStore {
   ): { rootSessionID: string; lineageDepth: number } {
     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) as
-      | { root_session_id: string | null; lineage_depth: number | null }
-      | undefined;
+    const seen = new Set<string>([sessionID]);
+    let currentSessionID: string | undefined = parentSessionID;
+    let lineageDepth = 1;
 
-    if (!parent) return { rootSessionID: parentSessionID, lineageDepth: 1 };
-    return {
-      rootSessionID: parent.root_session_id ?? parentSessionID,
-      lineageDepth: (parent.lineage_depth ?? 0) + 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) as
+        | {
+            parent_session_id: string | null;
+            root_session_id: string | null;
+            lineage_depth: number | null;
+          }
+        | undefined;
+
+      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 };
   }
 
   private applyEvent(session: NormalizedSession, event: CapturedEvent): NormalizedSession {
@@ -4322,31 +4584,44 @@ export class SqliteLcmStore {
     return row?.note;
   }
 
-  private readSessionHeaderSync(sessionID: string): NormalizedSession | undefined {
-    const row = safeQueryOne<SessionRow>(
-      this.getDb().prepare('SELECT * FROM sessions WHERE session_id = ?'),
-      [sessionID],
-      'readSessionHeaderSync',
-    );
-    if (!row) return undefined;
+  private materializeSessionRow(
+    row: SessionRow,
+    messages: ConversationMessage[] = [],
+  ): NormalizedSession {
+    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,
     };
   }
 
+  private readSessionHeaderSync(sessionID: string): NormalizedSession | undefined {
+    const row = safeQueryOne<SessionRow>(
+      this.getDb().prepare('SELECT * FROM sessions WHERE session_id = ?'),
+      [sessionID],
+      'readSessionHeaderSync',
+    );
+    if (!row) return undefined;
+
+    return this.materializeSessionRow(row);
+  }
+
   private clearSessionDataSync(sessionID: string): void {
     const db = this.getDb();
     db.prepare('DELETE FROM message_fts WHERE session_id = ?').run(sessionID);
@@ -4503,25 +4778,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);
     });
   }
 
@@ -4559,30 +4823,19 @@ export class SqliteLcmStore {
       partsByMessage.set(partRow.message_id, parts);
     }
 
-    const messages = messageRows.map((messageRow) => ({
-      info: parseJson<Message>(messageRow.info_json),
-      parts: partsByMessage.get(messageRow.message_id) ?? [],
-    }));
+    const messages = filterValidConversationMessages(
+      messageRows.map((messageRow) => ({
+        info: parseJson<Message>(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);
   }
 
   private prepareSessionForPersistence(session: NormalizedSession): NormalizedSession {
@@ -4669,8 +4922,21 @@ export class SqliteLcmStore {
       )
       .all(sessionID, messageID) as PartRow[];
 
+    const info = parseJson<Message>(row.info_json);
+    if (!getValidMessageInfo(info)) {
+      logMalformedMessage(
+        'Skipping malformed stored message',
+        {
+          operation: 'readMessageSync',
+          sessionID,
+        },
+        { messageID },
+      );
+      return undefined;
+    }
+
     return {
-      info: parseJson<Message>(row.info_json),
+      info,
       parts: parts.map((partRow) => {
         const part = parseJson<Part>(partRow.part_json);
         hydratePartFromArtifacts(part, artifactsByPart.get(part.id) ?? []);
@@ -4832,7 +5098,16 @@ export class SqliteLcmStore {
   }
 
   private upsertMessageInfoSync(sessionID: string, message: ConversationMessage): void {
-    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)
@@ -4884,7 +5159,10 @@ export class SqliteLcmStore {
   }
 
   private async externalizeSession(session: NormalizedSession): Promise<ExternalizedSession> {
-    return externalizeSessionModule(this.artifactDeps(), session);
+    return externalizeSessionModule(
+      this.artifactDeps(),
+      this.sanitizeSessionMessages(session, 'externalizeSession'),
+    );
   }
 
   private writeEvent(event: CapturedEvent): void {