opencode-lcm 0.11.0 → 0.13.0

package/src/store.ts

@@ -303,10 +303,6 @@ function readSessionStats(db: SqlDatabaseLike): {
   };
 }
 
-type ReadSessionOptions = {
-  artifactMessageIDs?: string[];
-};
-
 function extractSessionID(event: unknown): string | undefined {
   const record = asRecord(event);
   if (!record) return undefined;
@@ -364,6 +360,15 @@ function compareMessages(a: ConversationMessage, b: ConversationMessage): number
   return a.info.time.created - b.info.time.created;
 }
 
+function emptySession(sessionID: string): NormalizedSession {
+  return {
+    sessionID,
+    updatedAt: 0,
+    eventCount: 0,
+    messages: [],
+  };
+}
+
 function buildSummaryNodeID(sessionID: string, level: number, slot: number): string {
   return `sum_${hashContent(`summary:${sessionID}`).slice(0, 12)}_l${level}_p${slot}`;
 }
@@ -523,12 +528,23 @@ 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;
   isBunRuntime?: boolean;
   platform?: string | undefined;
 };
+type CaptureHydrationMode = 'full' | 'targeted';
+type CaptureHydrationOptions = {
+  isBunRuntime?: boolean;
+  platform?: string | undefined;
+};
 
 function normalizeSqliteRuntimeOverride(value: string | undefined): SqliteRuntime | 'auto' {
   const normalized = value?.trim().toLowerCase();
@@ -554,6 +570,20 @@ export function resolveSqliteRuntime(options?: SqliteRuntimeOptions): SqliteRunt
   return resolveSqliteRuntimeCandidates(options)[0];
 }
 
+export function resolveCaptureHydrationMode(
+  options?: CaptureHydrationOptions,
+): CaptureHydrationMode {
+  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: SqliteRuntime, error: unknown): boolean {
   const code =
     typeof error === 'object' && error && 'code' in error && typeof error.code === 'string'
@@ -683,6 +713,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>;
@@ -701,8 +735,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();
   }
 
@@ -713,15 +766,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 {
@@ -766,63 +811,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> {
@@ -1000,8 +1055,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', {
@@ -1016,6 +1069,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;
   }
@@ -1077,6 +1183,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;
@@ -1084,68 +1194,75 @@ export class SqliteLcmStore {
   }
 
   async capture(event: Event): Promise<void> {
-    await this.ensureDbReady();
-
-    const normalized = normalizeEvent(event);
-    if (!normalized) return;
+    return this.withStoreActivity(async () => {
+      const normalized = normalizeEvent(event);
+      if (!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 = 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,
-    );
+      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(),
@@ -1262,13 +1379,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);
@@ -1645,70 +1763,58 @@ export class SqliteLcmStore {
     );
   }
 
-  private captureArtifactHydrationMessageIDs(event: CapturedEvent): string[] {
-    const payload = event.payload as Event;
-
-    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 [];
-    }
-  }
-
-  private archivedMessageIDs(messages: ConversationMessage[]): string[] {
-    return this.getArchivedMessages(messages).map((message) => message.info.id);
-  }
-
-  private didArchivedMessagesChange(
-    before: ConversationMessage[],
-    after: ConversationMessage[],
-  ): boolean {
-    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]);
-  }
-
-  private isArchivedMessage(messages: ConversationMessage[], messageID?: string): boolean {
-    if (!messageID) return false;
-    return this.archivedMessageIDs(messages).includes(messageID);
-  }
-
   private shouldSyncDerivedSessionStateForEvent(
-    previous: NormalizedSession,
-    next: NormalizedSession,
+    session: NormalizedSession,
     event: CapturedEvent,
   ): boolean {
     const payload = event.payload as Event;
 
     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<{ created_at: number }>(
+          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:
@@ -2507,71 +2613,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?: {
@@ -2741,24 +2849,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: {
@@ -2766,31 +2876,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: {
@@ -2874,53 +2988,60 @@ export class SqliteLcmStore {
   }
 
   async transformMessages(messages: ConversationMessage[]): Promise<boolean> {
-    await this.prepareForRead();
-    if (messages.length < this.options.minMessagesForTransform) return false;
+    return this.withStoreActivity(async () => {
+      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 {
@@ -4231,17 +4352,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 {
@@ -4313,31 +4457,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);
@@ -4496,27 +4653,13 @@ 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);
     });
   }
 
-  private readSessionSync(sessionID: string, options?: ReadSessionOptions): NormalizedSession {
+  private readSessionSync(sessionID: string): NormalizedSession {
     const db = this.getDb();
     const row = safeQueryOne<SessionRow>(
       db.prepare('SELECT * FROM sessions WHERE session_id = ?'),
@@ -4534,14 +4677,7 @@ export class SqliteLcmStore {
       )
       .all(sessionID) as PartRow[];
     const artifactsByPart = new Map<string, ArtifactData[]>();
-    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);
@@ -4563,29 +4699,10 @@ export class SqliteLcmStore {
     }));
 
     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);
   }
 
   private prepareSessionForPersistence(session: NormalizedSession): NormalizedSession {
@@ -4622,6 +4739,85 @@ export class SqliteLcmStore {
     return parentSessionID;
   }
 
+  private readSessionForCaptureSync(event: CapturedEvent): NormalizedSession {
+    const sessionID = event.sessionID;
+    if (!sessionID) return emptySession('');
+
+    const session = this.readSessionHeaderSync(sessionID) ?? emptySession(sessionID);
+    const payload = event.payload as Event;
+
+    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;
+    }
+  }
+
+  private readMessageSync(sessionID: string, messageID: string): ConversationMessage | undefined {
+    const db = this.getDb();
+    const row = safeQueryOne<MessageRow>(
+      db.prepare('SELECT * FROM messages WHERE session_id = ? AND message_id = ?'),
+      [sessionID, messageID],
+      'readMessageSync',
+    );
+    if (!row) return undefined;
+
+    const artifactsByPart = new Map<string, ArtifactData[]>();
+    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) as PartRow[];
+
+    return {
+      info: parseJson<Message>(row.info_json),
+      parts: parts.map((partRow) => {
+        const part = parseJson<Part>(partRow.part_json);
+        hydratePartFromArtifacts(part, artifactsByPart.get(part.id) ?? []);
+        return part;
+      }),
+    };
+  }
+
+  private readMessageCountSync(sessionID: string): number {
+    const row = this.getDb()
+      .prepare('SELECT COUNT(*) AS count FROM messages WHERE session_id = ?')
+      .get(sessionID) as { count: number };
+    return row.count;
+  }
+
+  private isMessageArchivedSync(sessionID: string, messageID: string, createdAt: number): boolean {
+    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) as { count: number };
+    return row.count >= this.options.freshTailMessages;
+  }
+
   private async persistCapturedSession(
     session: NormalizedSession,
     event: CapturedEvent,