opencode-memory-pro 1.3.9 → 1.4.1

package/README.md

@@ -40,13 +40,7 @@ Published on npm — install directly (requires OpenCode ≥ 1.x and Node.js ≥
 opencode plugin opencode-memory-pro
 ```
 
-The latest release is **v1.3.9** on [npm](https://www.npmjs.com/package/opencode-memory-pro); source and releases are on [GitHub](https://github.com/tman204-50/opencode-memory-pro).
-
-Remove the old plugin pin at the same time:
-
-```bash
-opencode plugin lancedb-opencode-pro -g   # removes pin (if installed)
-```
+The latest release is **v1.4.0** on [npm](https://www.npmjs.com/package/opencode-memory-pro); source and releases are on [GitHub](https://github.com/tman204-50/opencode-memory-pro).
 
 ### Getting started
 
@@ -432,6 +426,7 @@ All tools are auto-registered when the plugin loads. Hybrid recall surfaces
 | `memory_event_cleanup` | Clean up expired effectiveness events (optional archive). |
 | `memory_consolidate` | Merge near-duplicate memories in a scope. |
 | `memory_consolidate_all` | Global duplicate cleanup (daily cron friendly). |
+| `memory_reembed` | Detect/repair an embedding-dimension mismatch (backs up, rebuilds the table, re-embeds every memory). |
 
 **Scoping**
 
@@ -480,15 +475,85 @@ npm run verify      # tests + pack dry-run
 
 CI runs on GitHub Actions (Node 22 + 24) on every push/PR to `main`.
 
-## Migrating from `lancedb-opencode-pro`
-
-Clean-break rename: sidecar is `opencode-memory-pro.json`, env prefix is
-`OPENCODE_MEMORY_PRO_*`. Data is **not** affected — the default storage paths
-are unchanged (`~/.opencode/memory/lancedb` + `~/.opencode/memory/graph.db`),
-so your memories and graph carry over untouched.
-
 ## Changelog
 
+### v1.4.1 (2026-09-06)
+
+New `memory_reembed` tool — detects and repairs embedding-dimension
+mismatches, which previously corrupted the store silently:
+
+- **Root cause**: the `memories` table's `vector` column is an Arrow
+  `FixedSizeList` whose width is fixed forever by the first row ever
+  written. `init()` re-probes the embedder's dimension on every startup but
+  silently discarded that value once a table already existed — nothing ever
+  compared "what the embedder produces now" against "what the table is
+  physically built for." Switching `embedding.provider`/`embedding.model` to
+  a different-dimension model did not error: LanceDB silently coerced
+  mismatched writes into the old fixed-width column (corrupting the vector,
+  not rejecting the write), and every `vectorSearch()` call at the new
+  dimension threw inside `findSimilarVectors`'s catch block, which silently
+  swallowed it — so write-time dedup and `memory_consolidate` silently
+  stopped finding neighbors for anything written after the switch, with zero
+  visible symptom beyond a passive `memory_stats.incompatibleVectors` count.
+- **Detection**: `init()` now reads back the table's actual physical vector
+  width (`getPhysicalVectorDim()`) and compares it to the freshly-probed
+  embedder dimension on every startup, logging a `warn` on mismatch.
+  `getIndexHealth()` (and therefore `memory_stats.index`) now reports
+  `dimensionMismatch`/`expectedDim`/`actualDim`, and `computeDegradedFlags`
+  surfaces an `embedding-dimension-mismatch` flag pointing at the fix.
+- **Repair**: `memory_reembed` (`dryRun` default `true`, `confirm` gate for
+  the actual repair — same pattern as `memory_clear`/`memory_forget`)
+  discovers every scope in the store (a dimension mismatch is table-wide,
+  not scope-scoped), backs up every memory to
+  `<dbPath's parent>/backups/reembed-repair-<ts>.json` (same shape as
+  `memory_export`, written *before* any mutation, always), then drops and
+  recreates the `memories` table at the current embedder's dimension and
+  re-embeds every memory from its stored text under its original id (so
+  entity-graph edges and citation chains keyed by id stay valid).
+- **Tests**: new integration test covers detection on a freshly-created
+  table (no false positive), detection after reopening with a different
+  dimension, and a full repair pass — asserting the physical column width
+  actually changes, every original id/text survives, and post-repair health
+  reports no mismatch.
+
+### v1.4.0 (2026-09-06)
+
+Dedup correctness overhaul — the write-time duplicate check compared against
+the wrong score type, and the resulting flags were a one-way ratchet:
+
+- **Write-time dedup now compares a raw cosine similarity**: the capture path
+  went through the hybrid `search()` API, whose RRF score is algebraically
+  `>= 1.0` for `limit: 1` (and up to `1.4` with importance) — so every capture
+  in a non-empty scope compared `>= 1.0` against `dedup.writeThreshold`
+  (clamped to `[0,1]`) and got falsely flagged as a potential duplicate.
+  `storeCapturedMemory` now calls `findSimilarVectors` (the same raw cosine
+  primitive consolidation measures) and compares that to the threshold.
+  Consequence: recall scores can no longer exceed 100%, and
+  `dedup.enabled`'s write-time detection actually detects.
+- **False duplicate flags now self-correct**: `isPotentialDuplicate` was a
+  one-way ratchet — consolidation never cleared it, so `memory_stats`
+  `flaggedCount` only grew (153 flagged / 0 merged observed on a live store).
+  `consolidateDuplicates` now revalidates flags against the real cosine
+  threshold and clears (`isPotentialDuplicate`/`duplicateOf` removed) any
+  flagged row whose closest found neighbor never reaches the merge bar.
+  Returns `clearedFlags` so tools can report the correction.
+- **Auto-consolidation cooldown is per-scope**: the shared
+  `lastConsolidateAt` timestamp meant the first scope to consolidate blocked
+  all other scopes for 30 minutes. Cooldowns are now tracked per scope
+  (same for the retention sweep, which had the identical flaw).
+- **Scope cache staleness bound**: the per-process version counter can't see
+  writes from another opencode process sharing the same `dbPath`, so process A
+  could serve stale records indefinitely. Cache entries now reload after a
+  60s age bound even when the local version is unchanged (configurable via
+  `cache.staleAfterMs`; 0 restores pure version gating).
+- **Consistent truncation warnings**: `deleteByIdForce`'s 100k-row fallback
+  scan and `pruneScope`'s 100k-row read now log a warning when the cap is hit,
+  matching `getCachedScopes`.
+- **Tests**: three new integration tests — the dedup write-check primitive
+  returns cosine in `[0,1]` (plus a guard that the old RRF path still scores
+  `>= 1.0`), consolidation clears false flags, and the scope cache reloads
+  after the age bound when a second process writes behind its back.
+
 ### v1.3.8 (2026-09-06)
 
 Fixes `memory_forget(force=true)` being unable to permanently delete a memory

package/dist/index.js

@@ -11,7 +11,7 @@ import { requestLLMCapture, isOwnSession } from "./llm.js";
 import { createMemoryTools, createFeedbackTools, createEpisodicTools } from "./tools/index.js";
 import { sweepExpiredMemories } from "./tools/memory.js";
 import { createGraphStore } from "./graph.js";
-const PLUGIN_VERSION = "1.3.9";
+const PLUGIN_VERSION = "1.4.1";
 const SCHEMA_VERSION = 1;
 // Event-driven dedup: run consolidateDuplicates on session.idle (throttled to
 // this interval so chatty sessions aren't re-scanning the store every turn)
@@ -597,12 +597,16 @@ async function createRuntimeState(input) {
         activeEpisodes: new Map(),
         sessionErrors: new Map(),
         lastRecall: null,
+        // PER_SCOPE_COOLDOWN (1.4.0): cooldowns are per-scope (Map keyed by scope)
+        // instead of a single shared timestamp — one shared value meant the
+        // first scope to consolidate/sweep blocked every other scope for the
+        // whole 30-minute cooldown, even scopes that had never run.
         consolidationInProgress: new Map(),
-        lastConsolidateAt: 0,
+        lastConsolidateAt: new Map(),
         // MEMORY_RETENTION (1.0): digest-then-hide expiry sweep state — same
         // throttle pattern as consolidation (cooldown-gated, one per scope).
         sweepInProgress: new Map(),
-        lastSweepAt: 0,
+        lastSweepAt: new Map(),
         ensureInitialized: async () => {
             if (state.initialized)
                 return;
@@ -800,22 +804,19 @@ async function storeCapturedMemory(state, opts) {
     }
     let isPotentialDuplicate = false;
     let duplicateOf = null;
+    // DEDUP_COSINE_CHECK (1.4.0): the write-time dedup check used to go
+    // through the hybrid search() API, whose RRF score is algebraically >= 1.0
+    // for limit:1 (rrfScore = 1/(rrfK+1) * (rrfK+1) == 1.0, then multiplied by
+    // an importance factor in [1, 1.4]) — so every capture with any same-dim
+    // record in the scope compared >= 1.0 against writeThreshold (clamped
+    // [0,1]) and got falsely flagged as a duplicate. Now it uses
+    // findSimilarVectors, which returns a raw cosine similarity in [0,1], the
+    // same primitive consolidateDuplicates measures against.
     if (state.config.dedup.enabled) {
-        const similar = await state.store.search({
-            query: opts.text,
-            queryVector: vector,
-            scopes: [opts.scope],
-            limit: 1,
-            vectorWeight: 1.0,
-            bm25Weight: 0.0,
-            minScore: 0.0,
-            rrfK: 60,
-            recencyBoost: false,
-            globalDiscountFactor: 1.0,
-        });
+        const similar = await state.store.findSimilarVectors(vector, opts.scope, 1);
         if (similar.length > 0 && similar[0].score >= state.config.dedup.writeThreshold) {
             isPotentialDuplicate = true;
-            duplicateOf = similar[0].record.id;
+            duplicateOf = similar[0].id;
         }
     }
     const memoryId = generateId();
@@ -866,11 +867,12 @@ async function maybeConsolidateDuplicates(state, scope, force = false) {
     if (state.consolidationInProgress.get(scope))
         return;
     if (!force) {
-        const elapsed = Date.now() - state.lastConsolidateAt;
+        const last = state.lastConsolidateAt.get(scope) ?? 0;
+        const elapsed = Date.now() - last;
         if (elapsed < CONSOLIDATE_COOLDOWN_MS)
             return;
     }
-    state.lastConsolidateAt = Date.now();
+    state.lastConsolidateAt.set(scope, Date.now());
     state.consolidationInProgress.set(scope, true);
     state.store
         .consolidateDuplicates(scope, state.config.dedup.consolidateThreshold, state.config.dedup.candidateLimit)
@@ -888,11 +890,12 @@ async function maybeSweepExpiredMemories(state, scope, force = false) {
     if (state.sweepInProgress.get(scope))
         return;
     if (!force) {
-        const elapsed = Date.now() - state.lastSweepAt;
+        const last = state.lastSweepAt.get(scope) ?? 0;
+        const elapsed = Date.now() - last;
         if (elapsed < CONSOLIDATE_COOLDOWN_MS)
             return;
     }
-    state.lastSweepAt = Date.now();
+    state.lastSweepAt.set(scope, Date.now());
     state.sweepInProgress.set(scope, true);
     sweepExpiredMemories(state, { scope })
         .then((result) => {

package/dist/store.d.ts

@@ -98,7 +98,12 @@ export declare class MemoryStore {
         ftsError?: string;
         vectorRetries?: number;
         ftsRetries?: number;
+        dimensionMismatch: boolean;
+        expectedDim: number | null;
+        actualDim: number | null;
     };
+    getPhysicalVectorDim(): Promise<number | null>;
+    listDistinctScopes(): Promise<string[]>;
     private invalidateScope;
     private getCachedScopes;
     private enforceMaxScopes;

package/dist/store.js

@@ -10,6 +10,13 @@ const DEFAULT_CACHE_CONFIG = {
     maxScopes: 10,
     maxRecordsPerScope: 1000,
     enabled: true,
+    // SCOPE_CACHE_STALENESS (1.4.0): the version counter only sees THIS
+    // process's writes, so when two opencode processes share one dbPath the
+    // scope cache could serve stale records forever. A modest age-based
+    // staleness bound forces a reload after staleAfterMs even when the local
+    // version is unchanged, bounding cross-process staleness without a schema
+    // change. 0 disables the age check (pure version gating, pre-1.4.0).
+    staleAfterMs: 60 * 1000,
 };
 // ANN_TUNABLES (1.3.0): nprobes controls IVF recall-vs-latency on filtered
 // vector searches; the consolidation query batch controls how many ANN
@@ -49,6 +56,13 @@ export class MemoryStore {
         ftsError: "",
         vectorRetries: 0,
         ftsRetries: 0,
+        // DIMENSION_MISMATCH_DETECT: set by init() by comparing the live
+        // embedder's probed dimension against the "vector" column's actual
+        // physical FixedSizeList width (fixed forever once the table's first
+        // row is written). See getPhysicalVectorDim() / repairEmbeddingDimension().
+        dimensionMismatch: false,
+        expectedDim: null,
+        actualDim: null,
     };
     scopeCache = new Map();
     // SCOPE_CACHE_LAZY (1.1.7): per-scope write counter. invalidateScope()
@@ -355,6 +369,35 @@ export class MemoryStore {
         await this.ensureMemoriesTableCompatibility();
         await this.ensureEventTableCompatibility();
         await this.ensureIndexes();
+        // DIMENSION_MISMATCH_DETECT: compare the embedder dimension this
+        // process just probed (vectorDim, the init() argument) against the
+        // table's actual physical column width. They only diverge when
+        // embedding.provider/embedding.model was changed to a different-
+        // output-size model without resetting the store — and when that
+        // happens, LanceDB does NOT reject the mismatched write; it silently
+        // coerces it into the old fixed-width column (corrupting the vector),
+        // and every vectorSearch() call at the new dimension throws (silently
+        // swallowed by findSimilarVectors's catch), so dedup/consolidation
+        // silently stop finding neighbors for anything written after the
+        // switch. See repairEmbeddingDimension() for the fix.
+        try {
+            const physicalDim = await this.getPhysicalVectorDim();
+            this.indexState.expectedDim = physicalDim;
+            this.indexState.actualDim = vectorDim;
+            this.indexState.dimensionMismatch = physicalDim !== null && physicalDim !== vectorDim;
+            if (this.indexState.dimensionMismatch) {
+                log("warn", `[store] Embedding dimension mismatch: the embedder currently produces ` +
+                    `${vectorDim}-dim vectors, but this store's "vector" column is physically fixed ` +
+                    `at ${physicalDim}-dim (set when the table was first created). New memories will ` +
+                    `be written with corrupted vectors and dedup/consolidation will silently stop ` +
+                    `finding neighbors for anything written from now on. Fix: call the memory_reembed ` +
+                    `tool (dryRun:false, confirm:true) to back up and re-embed every memory under the ` +
+                    `current model.`);
+            }
+        }
+        catch (error) {
+            log("debug", `[store] dimension-mismatch check failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
         const retentionDays = this.retentionConfig?.effectivenessEventsDays;
         if (retentionDays !== undefined && retentionDays > 0) {
             await this.cleanupExpiredEvents(undefined, retentionDays);
@@ -642,6 +685,9 @@ export class MemoryStore {
         }
         const table = this.requireTable();
         const rows = await table.query().limit(100000).toArray();
+        if (rows.length === 100000) {
+            log("warn", "[store] deleteByIdForce fallback scan hit the 100000-row cap; the target may not be found if it lives beyond the cap");
+        }
         const match = rows.find((row) => this.matchesId(row.id, id));
         if (!match)
             return false;
@@ -711,6 +757,9 @@ export class MemoryStore {
     }
     async pruneScope(scope, maxEntries) {
         const rows = await this.list(scope, 100000);
+        if (rows.length === 100000) {
+            log("warn", `[store] pruneScope scanned up to the 100000-row cap for scope=${scope}; entries older than the newest 100k are not candidates for pruning`);
+        }
         if (rows.length <= maxEntries)
             return 0;
         const flagged = rows.filter((r) => {
@@ -748,7 +797,7 @@ export class MemoryStore {
         let rows = await this.readByScopesIncludingMerged([scope]);
         rows = rows.filter((r) => r.status === undefined || r.status === null || r.status === "" || r.status === "active");
         if (rows.length === 0) {
-            return { mergedPairs: 0, updatedRecords: 0, skippedRecords: 0 };
+            return { mergedPairs: 0, updatedRecords: 0, skippedRecords: 0, clearedFlags: 0 };
         }
         const BATCH_SIZE = 100;
         const FALLBACK_THRESHOLD = 500;
@@ -763,12 +812,23 @@ export class MemoryStore {
             row,
             norm: this.scopeCache.get(scope)?.norms.get(row.id) ?? vecNorm(row.vector),
         }));
+        // DEDUP_FLAG_REVALIDATION (1.4.0): the write-time dedup check used to
+        // flag nearly every capture (RRF score >= 1.0 vs writeThreshold in
+        // [0,1]), and the flag was a one-way ratchet — nothing ever cleared it,
+        // so flaggedCount only grew. Consolidation is where a real cosine
+        // comparison happens, so flagged rows whose closest found neighbor
+        // stays below the consolidate threshold get the flag cleared; rows
+        // that DO have a near-duplicate keep it.
+        const metaById = new Map(rowsWithNorms.map(({ row }) => [row.id, parseMetadata(row.metadataJson)]));
+        const flaggedIds = new Set([...metaById].filter(([, meta]) => meta.isPotentialDuplicate === true).map(([id]) => id));
+        const bestSimByFlagged = new Map();
+        const mergedIds = new Set();
+        let clearedFlags = 0;
         log("debug", `[consolidate] scope=${scope} rows=${rows.length} threshold=${threshold} candidateLimit=${candidateLimit} batchSize=${BATCH_SIZE} fallbackThreshold=${FALLBACK_THRESHOLD}`);
         const processWithANN = async () => {
             let localMerged = 0;
             let localUpdated = 0;
             let localSkipped = 0;
-            const mergedIds = new Set();
             const totalChunks = Math.ceil(rowsWithNorms.length / BATCH_SIZE);
             for (let chunkIdx = 0; chunkIdx < totalChunks; chunkIdx++) {
                 const chunkStart = chunkIdx * BATCH_SIZE;
@@ -805,6 +865,12 @@ export class MemoryStore {
                             if (mergedIds.has(b.row.id))
                                 continue;
                             const sim = storeFastCosine(a.row.vector, b.row.vector, a.norm, b.norm);
+                            if (flaggedIds.has(a.row.id)) {
+                                bestSimByFlagged.set(a.row.id, Math.max(bestSimByFlagged.get(a.row.id) ?? -1, sim));
+                            }
+                            if (flaggedIds.has(b.row.id)) {
+                                bestSimByFlagged.set(b.row.id, Math.max(bestSimByFlagged.get(b.row.id) ?? -1, sim));
+                            }
                             if (sim < threshold)
                                 continue;
                             const aMeta = parseMetadata(a.row.metadataJson);
@@ -879,7 +945,6 @@ export class MemoryStore {
             let localMerged = 0;
             let localUpdated = 0;
             let localSkipped = 0;
-            const mergedIds = new Set();
             for (let i = 0; i < rowsWithNorms.length; i += 1) {
                 const a = rowsWithNorms[i];
                 if (mergedIds.has(a.row.id))
@@ -889,6 +954,12 @@ export class MemoryStore {
                     if (mergedIds.has(b.row.id))
                         continue;
                     const sim = storeFastCosine(a.row.vector, b.row.vector, a.norm, b.norm);
+                    if (flaggedIds.has(a.row.id)) {
+                        bestSimByFlagged.set(a.row.id, Math.max(bestSimByFlagged.get(a.row.id) ?? -1, sim));
+                    }
+                    if (flaggedIds.has(b.row.id)) {
+                        bestSimByFlagged.set(b.row.id, Math.max(bestSimByFlagged.get(b.row.id) ?? -1, sim));
+                    }
                     if (sim < threshold)
                         continue;
                     const aMeta = parseMetadata(a.row.metadataJson);
@@ -955,14 +1026,33 @@ export class MemoryStore {
             }
             else {
                 log("warn", `[consolidate] Skipping fallback for large scope (${rows.length} >= ${FALLBACK_THRESHOLD})`);
-                return { mergedPairs: 0, updatedRecords: 0, skippedRecords: 0 };
+                return { mergedPairs: 0, updatedRecords: 0, skippedRecords: 0, clearedFlags: 0 };
             }
         }
-        if (mergedPairs > 0) {
+        // DEDUP_FLAG_REVALIDATION (1.4.0): clear false duplicate flags. Rows
+        // whose best found neighbor never reached the merge threshold were
+        // flagged by the pre-1.4.0 RRF write-check (or carry a flag made stale
+        // by later edits); unsetting isPotentialDuplicate lets flaggedCount
+        // self-correct instead of ratcheting up forever.
+        for (const [id, bestSim] of bestSimByFlagged) {
+            if (mergedIds.has(id) || bestSim >= threshold)
+                continue;
+            const meta = metaById.get(id);
+            if (!meta || meta.isPotentialDuplicate !== true)
+                continue;
+            delete meta.isPotentialDuplicate;
+            delete meta.duplicateOf;
+            await this.requireTable().update({
+                where: `id = '${escapeSql(id)}'`,
+                values: { metadataJson: JSON.stringify(meta) },
+            });
+            clearedFlags += 1;
+        }
+        if (mergedPairs > 0 || clearedFlags > 0) {
             this.invalidateScope(scope);
         }
         await this.maybeOptimizeAll(false);
-        return { mergedPairs, updatedRecords, skippedRecords };
+        return { mergedPairs, updatedRecords, skippedRecords, clearedFlags };
     }
     // ANN_CONSOLIDATION (1.1.7): previously this did
 // query().where(scope).limit(limit).toArray() — which returns the FIRST N
@@ -1619,8 +1709,33 @@ export class MemoryStore {
             ftsError: this.indexState.ftsError || undefined,
             vectorRetries: this.indexState.vectorRetries,
             ftsRetries: this.indexState.ftsRetries,
+            dimensionMismatch: this.indexState.dimensionMismatch,
+            expectedDim: this.indexState.expectedDim,
+            actualDim: this.indexState.actualDim,
         };
     }
+    // DIMENSION_MISMATCH_DETECT: the "vector" column is an Arrow
+    // FixedSizeList whose width is fixed forever by the first row ever
+    // written to the table (LanceDB/Arrow enforce a uniform width per
+    // column) — NOT by whatever `vectorDim` a later write claims in its
+    // bookkeeping column. Reading it back via table.schema() is the only
+    // reliable way to know the table's true, physical embedding dimension.
+    async getPhysicalVectorDim() {
+        const table = this.requireTable();
+        const schema = await table.schema();
+        const vectorField = schema.fields.find((field) => field.name === "vector");
+        const listSize = vectorField?.type?.listSize;
+        return typeof listSize === "number" ? listSize : null;
+    }
+    // DIMENSION_MISMATCH_REPAIR: a dimension mismatch is a whole-table
+    // structural problem (the physical column width is table-wide, not
+    // scope-scoped), so the repair must span every scope present, not just
+    // the caller's current scope.
+    async listDistinctScopes() {
+        const table = this.requireTable();
+        const rows = await table.query().select(["scope"]).limit(200000).toArray();
+        return [...new Set(rows.map((row) => String(row.scope ?? "")).filter((scope) => scope.length > 0))];
+    }
     invalidateScope(scope) {
         this.scopeVersions.set(scope, (this.scopeVersions.get(scope) ?? 0) + 1);
     }
@@ -1647,7 +1762,9 @@ export class MemoryStore {
         for (const scope of scopes) {
             const currentVersion = this.scopeVersions.get(scope) ?? 0;
             let entry = this.scopeCache.get(scope);
-            if (!entry || entry.version !== currentVersion) {
+            const maxAgeMs = Number.isFinite(this.cacheConfig.staleAfterMs) ? this.cacheConfig.staleAfterMs : 0;
+            const staleByAge = maxAgeMs > 0 && (entry ? Date.now() - (entry.loadedAt ?? entry.lastAccessTimestamp) > maxAgeMs : false);
+            if (!entry || entry.version !== currentVersion || staleByAge) {
                 if (entry) {
                     this.cacheStats.evictions++;
                 }
@@ -1667,7 +1784,7 @@ export class MemoryStore {
                 for (const record of sortedRecords) {
                     norms.set(record.id, vecNorm(record.vector));
                 }
-                entry = { records: sortedRecords, tokenized, idf, norms, lastAccessTimestamp: Date.now(), version: currentVersion };
+                entry = { records: sortedRecords, tokenized, idf, norms, loadedAt: Date.now(), lastAccessTimestamp: Date.now(), version: currentVersion };
                 this.scopeCache.set(scope, entry);
                 this.cacheStats.misses++;
                 this.enforceMaxScopes();

package/dist/tools/memory.d.ts

@@ -92,6 +92,17 @@ export declare function createMemoryTools(state: ToolRuntimeState): {
             scope?: string | undefined;
         }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
     };
+    memory_reembed: {
+        description: string;
+        args: {
+            dryRun: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+            confirm: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+        };
+        execute(args: {
+            dryRun: boolean;
+            confirm: boolean;
+        }): Promise<string>;
+    };
     memory_event_cleanup: {
         description: string;
         args: {

package/dist/tools/memory.js

@@ -32,6 +32,12 @@ function computeDegradedFlags(state, embedderHealth, graphStats) {
     if (state.config?.capture?.llm?.provider && state.config?.capture?.llm?.model && getLlmHealth().status === "error") {
         flags.push("llm-unhealthy: last LLM capture/digest call failed — falling back to heuristics/extractive digests");
     }
+    const idx = state.store?.getIndexHealth?.();
+    if (idx?.dimensionMismatch) {
+        flags.push(`embedding-dimension-mismatch: embedder produces ${idx.actualDim}-dim vectors but the ` +
+            `store is fixed at ${idx.expectedDim}-dim — new writes are being silently corrupted and ` +
+            `dedup/consolidation are silently disabled. Run memory_reembed (dryRun:false, confirm:true) to repair.`);
+    }
     return flags;
 }
 // LLM_CAPTURE (1.1): mode-aware digest builder shared by memory_summarize
@@ -1226,6 +1232,117 @@ ${explanations.join("\n")}`;
                 }, null, 2);
             },
         }),
+        // DIMENSION_MISMATCH_REPAIR: the "vector" column's physical width is
+        // fixed for the whole table (set by the first row ever written), not
+        // per-scope, so this operates on every scope in the store — unlike
+        // every other tool here, it does not take a `scope` argument.
+        // Backs up first (always, even dryRun) so the operation is never
+        // riskier than memory_export followed by memory_import(replace).
+        memory_reembed: tool({
+            description: "Detect (and, with confirm:true, repair) an embedding-dimension mismatch between the " +
+                "configured embedder and the on-disk vector store. A mismatch happens when embedding.provider " +
+                "or embedding.model changed to a different output dimension without resetting the store — " +
+                "LanceDB silently corrupts new writes in that state instead of rejecting them, and dedup/" +
+                "consolidation silently stop finding neighbors. Repair backs up every memory (all scopes) to " +
+                "a JSON file, drops and recreates the memories table at the current embedder's dimension, and " +
+                "re-embeds every memory from its stored text under its original id (graph edges and citation " +
+                "chains keyed by id stay valid).",
+            args: {
+                dryRun: tool.schema.boolean().optional().default(true),
+                confirm: tool.schema.boolean().optional().default(false),
+            },
+            execute: async (args) => {
+                await state.ensureInitialized();
+                if (!state.initialized)
+                    return unavailableMessage(state.config.embedding.provider);
+                const actualDim = await state.embedder.dim();
+                const expectedDim = await state.store.getPhysicalVectorDim();
+                if (expectedDim === null || expectedDim === actualDim) {
+                    return JSON.stringify({
+                        mismatch: false,
+                        actualDim,
+                        message: "No dimension mismatch detected. Nothing to repair.",
+                    }, null, 2);
+                }
+                const scopes = await state.store.listDistinctScopes();
+                const records = await state.store.exportAllRecords(scopes);
+                if (args.dryRun && !args.confirm) {
+                    return JSON.stringify({
+                        mismatch: true,
+                        expectedDim,
+                        actualDim,
+                        scopes,
+                        recordCount: records.length,
+                        message: "Dry run — no changes made. Call again with dryRun:false, confirm:true to " +
+                            "repair (this drops and rebuilds the memories table; a backup is written first).",
+                    }, null, 2);
+                }
+                if (!args.confirm) {
+                    return JSON.stringify({
+                        error: "Set confirm:true to actually repair — this drops and rebuilds the memories " +
+                            "table (like memory_clear/memory_forget, destructive operations require confirm:true).",
+                    }, null, 2);
+                }
+                // BACKUP_ALWAYS_FIRST: same JSON shape as memory_export, so
+                // memory_import can restore from it independently if anything
+                // below fails partway through.
+                const fs = await import("node:fs");
+                const dbDirEnd = state.config.dbPath.lastIndexOf("/");
+                const backupDir = (dbDirEnd > 0 ? state.config.dbPath.slice(0, dbDirEnd) : ".") + "/backups";
+                await fs.promises.mkdir(backupDir, { recursive: true }).catch(() => { });
+                const backupPath = `${backupDir}/reembed-repair-${Date.now()}.json`;
+                await fs.promises.writeFile(backupPath, JSON.stringify({
+                    format: "opencode-memory-pro/backup",
+                    version: 1,
+                    exportedAt: new Date().toISOString(),
+                    provider: state.config.provider,
+                    dbPath: state.config.dbPath,
+                    reason: "pre-reembed-repair-backup",
+                    fromDim: expectedDim,
+                    toDim: actualDim,
+                    scopes,
+                    count: records.length,
+                    memories: records,
+                }, null, 2));
+                await state.store.connection.dropTable("memories");
+                state.store.table = null;
+                await state.store.init(actualDim);
+                let repaired = 0;
+                let failed = 0;
+                const failures = [];
+                for (const record of records) {
+                    try {
+                        const vector = await state.embedder.embed(record.text || "");
+                        await state.store.put({
+                            ...record,
+                            vector,
+                            vectorDim: vector.length,
+                            embeddingModel: state.embedder.model,
+                        });
+                        repaired += 1;
+                    }
+                    catch (error) {
+                        failed += 1;
+                        failures.push({ id: record.id, reason: error instanceof Error ? error.message : String(error) });
+                    }
+                }
+                await state.store.ensureIndexes();
+                return JSON.stringify({
+                    mismatch: true,
+                    repaired,
+                    failed,
+                    failures: failures.slice(0, 10),
+                    fromDim: expectedDim,
+                    toDim: actualDim,
+                    backupPath,
+                    scopes,
+                    message: failed > 0
+                        ? `Repaired ${repaired}/${records.length}. ${failed} failed but remain intact in the ` +
+                            `backup at ${backupPath} — re-run memory_reembed once the embedder issue is fixed.`
+                        : `Repaired all ${repaired} memories at ${actualDim}-dim. Backup retained at ${backupPath}.`,
+                }, null, 2);
+            },
+        }),
         memory_summarize: tool({
             description: "Create digests of old memories (store-level summarization). LLM abstractive digests when capture.mode=llm, offline extractive otherwise. Optionally mark originals 'digested' (replace=true) so only the digest remains in recall.",
             args: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-memory-pro",
-  "version": "1.3.9",
+  "version": "1.4.1",
   "description": "LanceDB-backed long-term memory provider for OpenCode — standalone fork of lancedb-opencode-pro with entity graph, lifecycle, and retention",
   "type": "module",
   "main": "dist/index.js",