fix(memory-core): trigger verified reindex on missing-meta recovery

chengzhichao-xydt · claude · chengzhichao-xydt · commit be3db39f63bf · 2026-06-06T18:06:11.000+08:00
When identity is missing but indexed chunks exist, force a verified full reindex via runSafeReindex/runUnsafeReindex instead of returning with a dirty/paused index. The reindex path prunes stale chunks from deleted paths, old providers, or old scopes before writing meta, so the index does not become searchable with unverified memory rows. Guard: when a specific embedding provider is configured but currently unavailable, the recovery path leaves the index dirty/paused instead of forcing an FTS-only reindex that would wipe existing vector embeddings. For auto/none/unset providers or when the provider is available, the verified full reindex proceeds safely. Adds three regression tests: - triggers verified reindex when identity missing + chunks exist - prunes stale chunks from deleted paths during recovery - preserves index when specific provider is unavailable Closes #90338 Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
diff --git a/extensions/memory-core/src/memory/manager-sync-ops.ts b/extensions/memory-core/src/memory/manager-sync-ops.ts
@@ -1846,7 +1846,7 @@ export abstract class MemoryManagerSyncOps {
     const needsInitialIndex = indexIdentity.status !== "valid" && !hasIndexedChunks;
     const needsExplicitIdentityReindex =
       params?.reason === "cli" && indexIdentity.status !== "valid" && !hasTargetSessionFiles;
-    const needsFullReindex =
+    let needsFullReindex =
       (params?.force && !hasTargetSessionFiles) ||
       needsInitialIndex ||
       needsExplicitIdentityReindex;
@@ -1859,7 +1859,28 @@ export abstract class MemoryManagerSyncOps {
       if (sessionsDirty) {
         this.sessionsDirty = true;
       }
-      return;
+      // If meta is missing but indexed chunks exist, force a verified full
+      // reindex instead of returning with a dirty/paused index. The reindex
+      // prunes stale chunks from deleted paths, old providers, or old scopes
+      // before writing meta (PR #90395, issue #90338).
+      // Guard: when a specific embedding provider is configured but currently
+      // unavailable, the existing chunks may be semantic (vector-backed).
+      // Forcing a reindex without the provider would silently downgrade the
+      // index to FTS-only and wipe vector embeddings. In that case keep the
+      // index dirty/paused so the provider can recover on a later sync.
+      if (!meta && hasIndexedChunks) {
+        const isSpecificProviderConfigured =
+          this.settings.provider &&
+          this.settings.provider !== "none" &&
+          this.settings.provider !== "auto";
+        if (isSpecificProviderConfigured && !this.provider) {
+          return;
+        }
+        needsFullReindex = true;
+        // Fall through to runSafeReindex / runUnsafeReindex below.
+      } else {
+        return;
+      }
     }
     if (!needsFullReindex) {
       const targetedSessionSync = await runMemoryTargetedSessionSync({
diff --git a/extensions/memory-core/src/memory/manager.fts-only-reindex.test.ts b/extensions/memory-core/src/memory/manager.fts-only-reindex.test.ts
@@ -205,4 +205,99 @@ describe("memory manager FTS-only reindex", () => {
     );
     expect(memoryManager.status().provider).toBe("openai");
   });
+
+  it("triggers verified reindex when identity is missing but indexed chunks exist", async () => {
+    // Explicit "none" provider: FTS-only, no semantic downgrade risk.
+    const memoryManager = await createManager({ provider: "none", vectorEnabled: false });
+    await memoryManager.sync({ force: true });
+
+    // Sanity: after initial sync, meta is present and chunks exist.
+    expect(memoryManager.status().chunks).toBeGreaterThan(0);
+    expect(memoryManager.status().custom?.indexIdentity).toEqual({ status: "valid" });
+
+    // Delete meta via the manager's own DB to simulate the dead-loop condition.
+    const internals = memoryManager as unknown as {
+      db: DatabaseSync;
+      readMeta(): MemoryIndexMeta | null;
+    };
+    internals.db.exec("DELETE FROM meta WHERE key = 'memory_index_meta_v1'");
+
+    // Verify meta was actually deleted.
+    expect(internals.readMeta()).toBeNull();
+
+    // Without force, the recovery path triggers a verified full reindex
+    // (runSafeReindex) instead of writing unverified meta. The reindex
+    // prunes stale rows and writes meta only after verification.
+    await memoryManager.sync();
+
+    // After the fix: meta is recreated via verified reindex, dead loop broken.
+    const metaAfter = internals.readMeta();
+    expect(metaAfter).not.toBeNull();
+    expect(memoryManager.status().custom?.indexIdentity).toEqual({ status: "valid" });
+  });
+
+  it("prunes stale chunks during missing-meta recovery when memory files are deleted", async () => {
+    // Explicit "none" provider: FTS-only, no semantic downgrade risk.
+    const memoryManager = await createManager({ provider: "none", vectorEnabled: false });
+    await memoryManager.sync({ force: true });
+
+    // Sanity: chunks exist from current MEMORY.md.
+    const initialChunks = memoryManager.status().chunks;
+    expect(initialChunks).toBeGreaterThan(0);
+
+    // Delete the memory file from disk — its chunks are now stale.
+    await fs.rm(path.join(workspaceDir, "MEMORY.md"));
+
+    // Delete meta to trigger the recovery path.
+    const internals = memoryManager as unknown as {
+      db: DatabaseSync;
+      readMeta(): MemoryIndexMeta | null;
+    };
+    internals.db.exec("DELETE FROM meta WHERE key = 'memory_index_meta_v1'");
+    expect(internals.readMeta()).toBeNull();
+
+    // Sync without force — recovery path triggers verified reindex.
+    // The reindex scans current sources, finds no memory files,
+    // and prunes stale chunks from the deleted path.
+    await memoryManager.sync();
+
+    // Stale chunks from deleted paths are pruned.
+    const chunksAfter = (
+      internals.db.prepare("SELECT count(*) as c FROM chunks").get() as { c: number }
+    ).c;
+    expect(chunksAfter).toBe(0);
+
+    // Meta is recreated, identity valid — dead loop broken.
+    expect(internals.readMeta()).not.toBeNull();
+    expect(memoryManager.status().custom?.indexIdentity).toEqual({ status: "valid" });
+  });
+
+  it("preserves index when specific provider is configured but unavailable during missing-meta recovery", async () => {
+    // Configure a specific embedding provider that is unavailable.
+    const memoryManager = await createManager({ provider: "openai" });
+    await memoryManager.sync({ force: true });
+
+    expect(memoryManager.status().chunks).toBeGreaterThan(0);
+
+    // Delete meta to simulate the dead-loop condition.
+    const internals = memoryManager as unknown as {
+      db: DatabaseSync;
+      readMeta(): MemoryIndexMeta | null;
+    };
+    internals.db.exec("DELETE FROM meta WHERE key = 'memory_index_meta_v1'");
+    expect(internals.readMeta()).toBeNull();
+
+    // Sync without force — recovery path detects that a specific provider
+    // ("openai") is configured but unavailable. Existing chunks may be
+    // semantic, so the index stays dirty/paused instead of forcing an
+    // FTS-only reindex that would wipe vector embeddings.
+    await memoryManager.sync();
+
+    // Meta stays missing, index stays dirty — provider outage preserved.
+    expect(internals.readMeta()).toBeNull();
+    expect(memoryManager.status().dirty).toBe(true);
+    expect(memoryManager.status().custom?.indexIdentity).toMatchObject({
+      status: "missing",
+    });
+  });
 });
