fix(memory): complete reindex retry recovery

vincentkoc · vincentkoc · commit 6fa4ca0b1543 · 2026-06-14T14:48:18.000+08:00
diff --git a/extensions/memory-core/src/memory/manager-embedding-ops.ts b/extensions/memory-core/src/memory/manager-embedding-ops.ts
@@ -241,14 +241,20 @@ export abstract class MemoryManagerEmbeddingOps extends MemoryManagerSyncOps {
       tableName: EMBEDDING_CACHE_TABLE,
     });
     if (this.embeddingCacheMirrorDb && this.embeddingCacheMirrorDb !== this.db) {
-      upsertMemoryEmbeddingCache({
-        db: this.embeddingCacheMirrorDb,
-        enabled: this.cache.enabled,
-        provider,
-        providerKey: this.providerKey,
-        entries,
-        tableName: EMBEDDING_CACHE_TABLE,
-      });
+      try {
+        upsertMemoryEmbeddingCache({
+          db: this.embeddingCacheMirrorDb,
+          enabled: this.cache.enabled,
+          provider,
+          providerKey: this.providerKey,
+          entries,
+          tableName: EMBEDDING_CACHE_TABLE,
+        });
+      } catch (err) {
+        log.warn("memory embeddings: failed to mirror safe-reindex cache batch", {
+          error: formatErrorMessage(err),
+        });
+      }
     }
   }
 
diff --git a/extensions/memory-core/src/memory/manager-sync-ops.ts b/extensions/memory-core/src/memory/manager-sync-ops.ts
@@ -122,6 +122,7 @@ type MemorySessionDeltaState = { lastSize: number; pendingBytes: number; pending
 
 type MemoryReindexRetryState = {
   dirty: boolean;
+  memoryFullRetryDirty: boolean;
   sessionsDirty: boolean;
   sessionsFullRetryDirty: boolean;
   sessionsDirtyFiles: Set<string>;
@@ -275,6 +276,9 @@ export abstract class MemoryManagerSyncOps {
   protected memoryWatchPressureStartupTimer: NodeJS.Timeout | null = null;
   protected closed = false;
   protected dirty = false;
+  // Failed full memory reindexes must retry as full rebuilds, not incremental
+  // dirty syncs that can skip unchanged files against the still-live index.
+  protected memoryFullRetryDirty = false;
   protected pendingWatchPaths: MemoryWatchSettleQueue = new Map();
   protected sessionsDirty = false;
   // Failed full reindexes can start with no per-file dirty set. Keep a
@@ -324,6 +328,7 @@ export abstract class MemoryManagerSyncOps {
   private snapshotReindexRetryState(): MemoryReindexRetryState {
     return {
       dirty: this.dirty,
+      memoryFullRetryDirty: this.memoryFullRetryDirty,
       sessionsDirty: this.sessionsDirty,
       sessionsFullRetryDirty: this.sessionsFullRetryDirty,
       sessionsDirtyFiles: new Set(this.sessionsDirtyFiles),
@@ -335,6 +340,7 @@ export abstract class MemoryManagerSyncOps {
 
   private restoreReindexRetryState(snapshot: MemoryReindexRetryState): void {
     this.dirty = snapshot.dirty || this.dirty;
+    this.memoryFullRetryDirty = snapshot.memoryFullRetryDirty || this.memoryFullRetryDirty;
     this.sessionsFullRetryDirty = snapshot.sessionsFullRetryDirty || this.sessionsFullRetryDirty;
     this.sessionsDirtyFiles = new Set([...snapshot.sessionsDirtyFiles, ...this.sessionsDirtyFiles]);
     const currentDeltas = this.sessionDeltas;
@@ -354,6 +360,7 @@ export abstract class MemoryManagerSyncOps {
   private markFailedFullReindexRetry(params: { memory: boolean; sessions: boolean }): void {
     if (params.memory) {
       this.dirty = true;
+      this.memoryFullRetryDirty = true;
     }
     if (params.sessions) {
       this.sessionsDirty = true;
@@ -367,6 +374,11 @@ export abstract class MemoryManagerSyncOps {
     this.sessionsDirtyFiles.clear();
   }
 
+  private clearMemoryRetryState(): void {
+    this.dirty = false;
+    this.memoryFullRetryDirty = false;
+  }
+
   private refreshSessionDirtyFlag(): void {
     this.sessionsDirty = this.sessionsFullRetryDirty || this.sessionsDirtyFiles.size > 0;
   }
@@ -428,6 +440,7 @@ export abstract class MemoryManagerSyncOps {
     shouldSyncMemory: boolean;
     shouldSyncSessions: boolean;
     needsFullReindex: boolean;
+    needsFullSessionReindex?: boolean;
     targetSessionFiles?: string[];
     progress?: MemorySyncProgressState;
   }): Promise<void> {
@@ -440,7 +453,7 @@ export abstract class MemoryManagerSyncOps {
       : this.emptySourceSyncPlan();
     if (params.shouldSyncSessions) {
       await this.syncSessionFiles({
-        needsFullReindex: params.needsFullReindex,
+        needsFullReindex: params.needsFullSessionReindex ?? params.needsFullReindex,
         targetSessionFiles: params.targetSessionFiles,
         progress: params.progress,
         deferIndex: true,
@@ -2169,7 +2182,9 @@ export abstract class MemoryManagerSyncOps {
       (params?.force && !hasTargetSessionFiles) ||
       needsInitialIndex ||
       needsMissingIdentityReindex ||
-      needsExplicitIdentityReindex;
+      needsExplicitIdentityReindex ||
+      this.memoryFullRetryDirty;
+    const needsFullSessionReindex = needsFullReindex || this.sessionsFullRetryDirty;
     if (indexIdentity.status !== "valid" && !needsFullReindex) {
       this.dirty = true;
       const sessionsDirty = markMemoryTargetSessionFilesDirty({
@@ -2181,12 +2196,13 @@ export abstract class MemoryManagerSyncOps {
       }
       return;
     }
-    if (!needsFullReindex) {
+    if (!needsFullSessionReindex) {
       const targetedSessionSync = await runMemoryTargetedSessionSync({
         hasSessionSource: this.sources.has("sessions"),
         targetSessionFiles,
         reason: params?.reason,
         progress: progress ?? undefined,
+        sessionsFullRetryDirty: this.sessionsFullRetryDirty,
         sessionsDirtyFiles: this.sessionsDirtyFiles,
         syncSessionFiles: async (targetedParams) => {
           await this.syncSessionFiles(targetedParams);
@@ -2230,11 +2246,12 @@ export abstract class MemoryManagerSyncOps {
           shouldSyncMemory,
           shouldSyncSessions,
           needsFullReindex,
+          needsFullSessionReindex,
           targetSessionFiles: targetSessionFiles ? Array.from(targetSessionFiles) : undefined,
           progress: progress ?? undefined,
         });
         if (shouldSyncMemory) {
-          this.dirty = false;
+          this.clearMemoryRetryState();
         }
         if (shouldSyncSessions) {
           this.clearSessionRetryState();
@@ -2244,12 +2261,12 @@ export abstract class MemoryManagerSyncOps {
       } else {
         if (shouldSyncMemory) {
           await this.syncMemoryFiles({ needsFullReindex, progress: progress ?? undefined });
-          this.dirty = false;
+          this.clearMemoryRetryState();
         }
 
         if (shouldSyncSessions) {
           await this.syncSessionFiles({
-            needsFullReindex,
+            needsFullReindex: needsFullSessionReindex,
             targetSessionFiles: targetSessionFiles ? Array.from(targetSessionFiles) : undefined,
             progress: progress ?? undefined,
           });
@@ -2430,7 +2447,7 @@ export abstract class MemoryManagerSyncOps {
               progress: params.progress,
             });
             if (shouldSyncMemory) {
-              this.dirty = false;
+              this.clearMemoryRetryState();
             }
             if (shouldSyncSessions) {
               this.clearSessionRetryState();
@@ -2440,7 +2457,7 @@ export abstract class MemoryManagerSyncOps {
           } else {
             if (shouldSyncMemory) {
               await this.syncMemoryFiles({ needsFullReindex: true, progress: params.progress });
-              this.dirty = false;
+              this.clearMemoryRetryState();
             }
 
             if (shouldSyncSessions) {
@@ -2538,7 +2555,7 @@ export abstract class MemoryManagerSyncOps {
           progress: params.progress,
         });
         if (shouldSyncMemory) {
-          this.dirty = false;
+          this.clearMemoryRetryState();
         }
         if (shouldSyncSessions) {
           this.clearSessionRetryState();
@@ -2548,7 +2565,7 @@ export abstract class MemoryManagerSyncOps {
       } else {
         if (shouldSyncMemory) {
           await this.syncMemoryFiles({ needsFullReindex: true, progress: params.progress });
-          this.dirty = false;
+          this.clearMemoryRetryState();
         }
 
         if (shouldSyncSessions) {
diff --git a/extensions/memory-core/src/memory/manager-targeted-sync.test.ts b/extensions/memory-core/src/memory/manager-targeted-sync.test.ts
@@ -64,4 +64,24 @@ describe("memory targeted session sync", () => {
     expect(sessionsDirtyFiles.has("/tmp/targeted-fallback.jsonl")).toBe(true);
     expect(sessionsDirtyFiles.has("/tmp/other-dirty.jsonl")).toBe(true);
   });
+
+  it("preserves the full-retry dirty marker after targeted cleanup", async () => {
+    const syncSessionFiles = vi.fn(async () => undefined);
+    const sessionsDirtyFiles = new Set(["/tmp/targeted-full-retry.jsonl"]);
+
+    const result = await runMemoryTargetedSessionSync({
+      hasSessionSource: true,
+      targetSessionFiles: new Set(["/tmp/targeted-full-retry.jsonl"]),
+      reason: "post-compaction",
+      progress: undefined,
+      sessionsFullRetryDirty: true,
+      sessionsDirtyFiles,
+      syncSessionFiles,
+      shouldFallbackOnError: () => false,
+      activateFallbackProvider: async () => false,
+    });
+
+    expect(result).toEqual({ handled: true, sessionsDirty: true });
+    expect(sessionsDirtyFiles.size).toBe(0);
+  });
 });
diff --git a/extensions/memory-core/src/memory/manager-targeted-sync.ts b/extensions/memory-core/src/memory/manager-targeted-sync.ts
@@ -40,6 +40,7 @@ export async function runMemoryTargetedSessionSync(params: {
   targetSessionFiles: Set<string> | null;
   reason?: string;
   progress?: TargetedSyncProgress;
+  sessionsFullRetryDirty?: boolean;
   sessionsDirtyFiles: Set<string>;
   syncSessionFiles: (params: {
     needsFullReindex: boolean;
@@ -52,7 +53,7 @@ export async function runMemoryTargetedSessionSync(params: {
   if (!params.hasSessionSource || !params.targetSessionFiles) {
     return {
       handled: false,
-      sessionsDirty: params.sessionsDirtyFiles.size > 0,
+      sessionsDirty: Boolean(params.sessionsFullRetryDirty) || params.sessionsDirtyFiles.size > 0,
     };
   }
 
@@ -62,12 +63,13 @@ export async function runMemoryTargetedSessionSync(params: {
       targetSessionFiles: Array.from(params.targetSessionFiles),
       progress: params.progress,
     });
+    const remainingSessionsDirty = clearMemorySyncedSessionFiles({
+      sessionsDirtyFiles: params.sessionsDirtyFiles,
+      targetSessionFiles: params.targetSessionFiles,
+    });
     return {
       handled: true,
-      sessionsDirty: clearMemorySyncedSessionFiles({
-        sessionsDirtyFiles: params.sessionsDirtyFiles,
-        targetSessionFiles: params.targetSessionFiles,
-      }),
+      sessionsDirty: Boolean(params.sessionsFullRetryDirty) || remainingSessionsDirty,
     };
   } catch (err) {
     const reason = formatErrorMessage(err);
@@ -76,12 +78,13 @@ export async function runMemoryTargetedSessionSync(params: {
     if (!activated) {
       throw err;
     }
+    const remainingSessionsDirty = markMemoryTargetSessionFilesDirty({
+      sessionsDirtyFiles: params.sessionsDirtyFiles,
+      targetSessionFiles: params.targetSessionFiles,
+    });
     return {
       handled: true,
-      sessionsDirty: markMemoryTargetSessionFilesDirty({
-        sessionsDirtyFiles: params.sessionsDirtyFiles,
-        targetSessionFiles: params.targetSessionFiles,
-      }),
+      sessionsDirty: Boolean(params.sessionsFullRetryDirty) || remainingSessionsDirty,
     };
   }
 }
diff --git a/extensions/memory-core/src/memory/manager.reindex-recovery.test.ts b/extensions/memory-core/src/memory/manager.reindex-recovery.test.ts
