opencode-memory-pro 1.4.0 → 1.4.2

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.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).
-
-Remove the old plugin pin at the same time:
-
-```bash
-opencode plugin lancedb-opencode-pro -g   # removes pin (if installed)
-```
+The latest release is 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
 
@@ -181,9 +175,11 @@ index and capture still works — the plugin is offline-tolerant by design.
 
 | Key | Default | Description |
 |---|---|---|
-| `retrieval.mode` | `"hybrid"` | `"hybrid"` (vector+BM25 RRF) or `"vector"`. |
-| `retrieval.vectorWeight` | `0.7` | Vector/BM25 ratio before normalization. |
+| `retrieval.mode` | `"hybrid"` | `"hybrid"` (vector+BM25+fuzzy RRF) or `"vector"`. |
+| `retrieval.vectorWeight` | `0.7` | Vector/BM25/fuzzy ratio before normalization. |
 | `retrieval.bm25Weight` | `0.3` | (Weights are normalized to sum 1.) |
+| `retrieval.fuzzyWeight` | `0.15` | fuse.js typo-tolerant fuzzy channel weight; `0` disables it. |
+| `retrieval.fuzzyThreshold` | `0.5` | fuse.js match threshold (lower = stricter). |
 | `retrieval.minScore` | `0.2` | Minimum score for a result to qualify. |
 | `retrieval.rrfK` | `60` | RRF constant. |
 | `retrieval.recencyBoost` | `true` | Boost recently recalled/created memories. |
@@ -192,9 +188,34 @@ index and capture still works — the plugin is offline-tolerant by design.
 | `retrieval.feedbackWeight` | `0.3` | Weight of feedback history in scoring (0–1). |
 
 Env: `OPENCODE_MEMORY_PRO_RETRIEVAL_MODE`, `..._VECTOR_WEIGHT`,
-`..._BM25_WEIGHT`, `..._MIN_SCORE`, `..._RRF_K`, `..._RECENCY_BOOST`,
+`..._BM25_WEIGHT`, `..._FUZZY_WEIGHT`, `..._FUZZY_THRESHOLD`, `..._MIN_SCORE`,
+`..._RRF_K`, `..._RECENCY_BOOST`,
 `..._RECENCY_HALF_LIFE_HOURS`, `..._IMPORTANCE_WEIGHT`, `..._FEEDBACK_WEIGHT`.
 
+## Changelog
+
+### v1.4.2 (2026-09-06)
+
+New **fuzzy search channel** — fuse.js joins the RRF merge as a third
+retrieval channel alongside vector and BM25, giving typo-tolerant matching
+out of the box:
+
+- **Typo tolerance**: `memory_search "lancedb vectr srch"` now surfaces the
+  right memory even when vector and BM25 both miss — useful for queries with
+  misspellings, partial words, or accented text (`ignoreDiacritics`).
+- **Zero-config**: `retrieval.fuzzyWeight` defaults to `0.15` (renormalized
+  with vector/BM25); set it to `0` to restore pre-1.4.2 scores exactly.
+- **Channel semantics**: records that don't appear in the fuzzy top-N
+  contribute no RRF rank, same as the other channels; `fuzzyThreshold`
+  (default `0.5`) drops weak matches.
+- **Fallback-aware**: the fuzzy channel stays active in the BM25-only
+  fallback (embedder unavailable) — that's exactly when typo tolerance helps
+  most — and is disabled only in explicit `retrieval.mode = "vector"`.
+- **Index lifecycle**: fuse.js index is built lazily over the scope cache,
+  reused across single-scope searches, and rebuilt automatically on cache
+  invalidation or threshold change.
+- `memory_stats` now reports the fuzzy channel (`enabled`/`weight`/`threshold`).
+
 ### Injection
 
 How memories are injected into the model context.
@@ -432,6 +453,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 +502,47 @@ 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

package/dist/config.js

@@ -18,9 +18,14 @@ export function resolveMemoryConfig(config, worktree) {
     const dbPath = expandHomePath(firstString(process.env.OPENCODE_MEMORY_PRO_DB_PATH, raw.dbPath) ?? DEFAULT_DB_PATH);
     const vectorWeight = clamp(toNumber(process.env.OPENCODE_MEMORY_PRO_VECTOR_WEIGHT ?? retrievalRaw.vectorWeight, 0.7), 0, 1);
     const bm25Weight = clamp(toNumber(process.env.OPENCODE_MEMORY_PRO_BM25_WEIGHT ?? retrievalRaw.bm25Weight, 0.3), 0, 1);
-    const weightSum = vectorWeight + bm25Weight;
+    // FUZZY_CHANNEL (1.4.2): fuse.js fuzzy-match channel participates in the
+    // RRF merge alongside vector + BM25. Weight 0 disables it entirely.
+    const fuzzyWeight = clamp(toNumber(process.env.OPENCODE_MEMORY_PRO_FUZZY_WEIGHT ?? retrievalRaw.fuzzyWeight, 0.15), 0, 1);
+    const fuzzyThreshold = clamp(toNumber(process.env.OPENCODE_MEMORY_PRO_FUZZY_THRESHOLD ?? retrievalRaw.fuzzyThreshold, 0.5), 0, 1);
+    const weightSum = vectorWeight + bm25Weight + fuzzyWeight;
     const normalizedVectorWeight = weightSum > 0 ? vectorWeight / weightSum : 0.7;
     const normalizedBm25Weight = weightSum > 0 ? bm25Weight / weightSum : 0.3;
+    const normalizedFuzzyWeight = weightSum > 0 ? fuzzyWeight / weightSum : 0;
     const rrfK = Math.max(1, Math.floor(toNumber(process.env.OPENCODE_MEMORY_PRO_RRF_K ?? retrievalRaw.rrfK, 60)));
     const recencyBoost = toBoolean(process.env.OPENCODE_MEMORY_PRO_RECENCY_BOOST ?? retrievalRaw.recencyBoost, true);
     const recencyHalfLifeHours = Math.max(1, toNumber(process.env.OPENCODE_MEMORY_PRO_RECENCY_HALF_LIFE_HOURS ?? retrievalRaw.recencyHalfLifeHours, 72));
@@ -74,6 +79,8 @@ export function resolveMemoryConfig(config, worktree) {
             mode,
             vectorWeight: normalizedVectorWeight,
             bm25Weight: normalizedBm25Weight,
+            fuzzyWeight: normalizedFuzzyWeight,
+            fuzzyThreshold,
             minScore: clamp(toNumber(process.env.OPENCODE_MEMORY_PRO_MIN_SCORE ?? retrievalRaw.minScore, 0.2), 0, 1),
             rrfK,
             recencyBoost,

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.4.0";
+const PLUGIN_VERSION = "1.4.2";
 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)

package/dist/store.d.ts

@@ -40,6 +40,8 @@ export declare class MemoryStore {
         limit: number;
         vectorWeight: number;
         bm25Weight: number;
+        fuzzyWeight?: number;
+        fuzzyThreshold?: number;
         minScore: number;
         rrfK?: number;
         recencyBoost?: boolean;
@@ -98,7 +100,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

@@ -1,5 +1,6 @@
 import { mkdir, open, readFile, readdir, rm } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import Fuse from "fuse.js";
 import { validateEpisodicRecord, validateEpisodicRecordArray } from "./types.js";
 import { tokenize } from "./utils.js";
 import { log, logFileOnly } from "./logger.js";
@@ -56,6 +57,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()
@@ -362,6 +370,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);
@@ -552,13 +589,21 @@ export class MemoryStore {
         const queryNorm = vecNorm(params.queryVector);
         const useVectorChannel = params.queryVector.length > 0 && params.vectorWeight > 0;
         const useBm25Channel = queryTokens.length > 0 && params.bm25Weight > 0;
-        const { vectorWeight, bm25Weight } = normalizeChannelWeights(useVectorChannel ? params.vectorWeight : 0, useBm25Channel ? params.bm25Weight : 0);
+        // FUZZY_CHANNEL (1.4.2): fuse.js typo-tolerant channel. On by default
+        // (weight 0.15) unless the caller passes fuzzyWeight 0.
+        const fuzzyWeight = Math.max(0, Number(params.fuzzyWeight) || 0);
+        const useFuzzyChannel = params.query.trim().length > 0 && fuzzyWeight > 0;
+        const fuzzyThreshold = params.fuzzyThreshold !== undefined ? Math.max(0, Math.min(1, params.fuzzyThreshold)) : 0.5;
+        const { vectorWeight, bm25Weight, fuzzyWeight: normalizedFuzzyWeight } = normalizeChannelWeights(useVectorChannel ? params.vectorWeight : 0, useBm25Channel ? params.bm25Weight : 0, useFuzzyChannel ? fuzzyWeight : 0);
         const rrfK = Math.max(1, Math.floor(params.rrfK ?? 60));
         const recencyBoostEnabled = params.recencyBoost ?? true;
         const recencyHalfLifeHours = Math.max(1, params.recencyHalfLifeHours ?? 72);
         const importanceWeight = clampImportanceWeight(params.importanceWeight ?? 0.4);
         const feedbackWeight = Math.max(0, Math.min(1, params.feedbackWeight ?? 0));
         const globalDiscountFactor = params.globalDiscountFactor ?? 1.0;
+        const fuzzyResults = useFuzzyChannel ? this.getFuzzyIndex(cached, params.scopes, fuzzyThreshold).search(params.query.trim(), { limit: Math.max(50, params.limit * 4) }) : [];
+        const fuzzyRanks = useFuzzyChannel ? buildRankMap(fuzzyResults.map((r) => ({ record: r.item, fuzzyScore: 1 - (r.score ?? 1) })), (item) => item.fuzzyScore) : null;
+        const fuzzyScoreMap = new Map(fuzzyResults.map((r) => [r.item.id, 1 - (r.score ?? 1)]));
         const candidates = cached.records
             .filter((record) => params.queryVector.length === 0 || record.vector.length === params.queryVector.length)
             .map((record, index) => {
@@ -566,7 +611,7 @@ export class MemoryStore {
             const vectorScore = useVectorChannel ? fastCosine(params.queryVector, record.vector, queryNorm, recordNorm) : 0;
             const bm25Score = useBm25Channel ? bm25LikeScore(queryTokens, cached.tokenized[index], cached.idf) : 0;
             const isGlobal = record.scope === "global";
-            return { record, vectorScore, bm25Score, isGlobal };
+            return { record, vectorScore, bm25Score, fuzzyScore: fuzzyScoreMap.get(record.id) ?? 0, isGlobal };
         });
         if (candidates.length === 0)
             return [];
@@ -588,6 +633,14 @@ export class MemoryStore {
                 if (rank !== undefined)
                     rrfScore += bm25Weight / (rrfK + rank);
             }
+            // FUZZY_CHANNEL (1.4.2): only records that appear in the fuzzy
+            // top-N contribute a rank; the rest get nothing (same semantics
+            // as the other channels).
+            if (fuzzyRanks) {
+                const rank = fuzzyRanks.get(item.record.id);
+                if (rank !== undefined)
+                    rrfScore += normalizedFuzzyWeight / (rrfK + rank);
+            }
             rrfScore *= rrfK + 1;
             const recencyFactor = recencyBoostEnabled
                 ? computeRecencyMultiplier(item.record.timestamp, recencyHalfLifeHours)
@@ -604,6 +657,7 @@ export class MemoryStore {
                 score,
                 vectorScore: item.vectorScore,
                 bm25Score: item.bm25Score,
+                fuzzyScore: item.fuzzyScore,
             };
         })
             .filter((item) => item.score >= params.minScore)
@@ -1673,8 +1727,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);
     }
@@ -1741,7 +1820,34 @@ export class MemoryStore {
         const idf = scopes.length === 1 && this.scopeCache.has(scopes[0])
             ? this.scopeCache.get(scopes[0]).idf
             : computeIdf(allTokenized);
-        return { records: allRecords, tokenized: allTokenized, idf, norms: allNorms, lastAccessTimestamp: Date.now() };
+        const cached = { records: allRecords, tokenized: allTokenized, idf, norms: allNorms, lastAccessTimestamp: Date.now() };
+        // FUZZY_CHANNEL (1.4.2): reuse the per-scope entry index when the
+        // request is single-scope (the common path); multi-scope requests
+        // build a merged index on each call. Threshold changes rebuild.
+        if (scopes.length === 1 && this.scopeCache.has(scopes[0])) {
+            const entry = this.scopeCache.get(scopes[0]);
+            if (entry?.fuse) {
+                cached.fuse = entry.fuse;
+            }
+        }
+        return cached;
+    }
+    // FUZZY_CHANNEL (1.4.2): lazily build (and cache) the fuse.js index over
+    // the records a search is about to score. Built once per scope-cache
+    // entry and reused across searches; rebuilt when the threshold changes or
+    // the cache entry is invalidated (the entry itself is replaced on
+    // invalidation, so this never serves stale text).
+    getFuzzyIndex(cached, scopes, threshold) {
+        if (cached.fuse && cached.fuse.threshold === threshold) {
+            return cached.fuse;
+        }
+        const fuse = buildFuseIndex(cached.records, threshold);
+        fuse.threshold = threshold;
+        cached.fuse = fuse;
+        if (scopes.length === 1 && this.scopeCache.has(scopes[0])) {
+            this.scopeCache.get(scopes[0]).fuse = fuse;
+        }
+        return fuse;
     }
     enforceMaxScopes() {
         while (this.scopeCache.size > this.cacheConfig.maxScopes) {
@@ -2891,14 +2997,27 @@ function buildRankMap(items, scoreOf) {
     }
     return ranks;
 }
-function normalizeChannelWeights(vectorWeight, bm25Weight) {
-    const sum = vectorWeight + bm25Weight;
+// FUZZY_CHANNEL (1.4.2): fuse.js index over memory text. ignoreLocation
+// keeps substring matches relevant, ignoreDiacritics tolerates accents, and
+// threshold (default 0.5) drops results whose match score is too weak.
+function buildFuseIndex(records, threshold = 0.5) {
+    return new Fuse(records, {
+        keys: ["text"],
+        includeScore: true,
+        ignoreLocation: true,
+        ignoreDiacritics: true,
+        threshold,
+    });
+}
+function normalizeChannelWeights(vectorWeight, bm25Weight, fuzzyWeight = 0) {
+    const sum = vectorWeight + bm25Weight + fuzzyWeight;
     if (sum <= 0) {
-        return { vectorWeight: 0.5, bm25Weight: 0.5 };
+        return { vectorWeight: 0.5, bm25Weight: 0.5, fuzzyWeight: 0 };
     }
     return {
         vectorWeight: vectorWeight / sum,
         bm25Weight: bm25Weight / sum,
+        fuzzyWeight: fuzzyWeight / sum,
     };
 }
 function computeRecencyMultiplier(timestamp, halfLifeHours) {

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
@@ -83,6 +89,10 @@ export function createMemoryTools(state) {
                 const isFallback = embedderFailed || queryVector.length === 0;
                 const effectiveVectorWeight = isFallback ? 0 : (state.config.retrieval.mode === "vector" ? 1 : state.config.retrieval.vectorWeight);
                 const effectiveBm25Weight = isFallback ? 1 : (state.config.retrieval.mode === "vector" ? 0 : state.config.retrieval.bm25Weight);
+                // FUZZY_CHANNEL (1.4.2): fuzzy stays on in the bm25-only
+                // fallback (that's when typo tolerance helps most); it is
+                // disabled only in explicit vector-only mode.
+                const effectiveFuzzyWeight = state.config.retrieval.mode === "vector" ? 0 : state.config.retrieval.fuzzyWeight;
                 if (isFallback) {
                     log("info", "Using BM25-only search (embedder unavailable)");
                 }
@@ -93,6 +103,8 @@ export function createMemoryTools(state) {
                     limit: args.limit ?? 5,
                     vectorWeight: effectiveVectorWeight,
                     bm25Weight: effectiveBm25Weight,
+                    fuzzyWeight: effectiveFuzzyWeight,
+                    fuzzyThreshold: state.config.retrieval.fuzzyThreshold,
                     minScore: state.config.retrieval.minScore,
                     rrfK: state.config.retrieval.rrfK,
                     recencyBoost: state.config.retrieval.recencyBoost,
@@ -300,6 +312,11 @@ export function createMemoryTools(state) {
                     recentCount: entries.length,
                     incompatibleVectors,
                     index: health,
+                    fuzzy: {
+                        enabled: (state.config.retrieval.fuzzyWeight ?? 0) > 0,
+                        weight: state.config.retrieval.fuzzyWeight ?? 0,
+                        threshold: state.config.retrieval.fuzzyThreshold ?? 0.5,
+                    },
                     embeddingModel: state.config.embedding.model,
                     searchMode,
                     embedderHealth,
@@ -781,6 +798,7 @@ ${explanations.join("\n")}`;
                         limit: args.limit ?? 20,
                         vectorWeight: 0.7,
                         bm25Weight: 0.3,
+                        fuzzyWeight: 0,
                         minScore: 0.2,
                         globalDiscountFactor: 1.0,
                     }).then((results) => results.map((r) => r.record));
@@ -1226,6 +1244,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/dist/types.d.ts

@@ -54,6 +54,8 @@ export interface RetrievalConfig {
     mode: RetrievalMode;
     vectorWeight: number;
     bm25Weight: number;
+    fuzzyWeight: number;
+    fuzzyThreshold: number;
     minScore: number;
     rrfK: number;
     recencyBoost: boolean;
@@ -197,6 +199,7 @@ export interface SearchResult {
     score: number;
     vectorScore: number;
     bm25Score: number;
+    fuzzyScore: number;
 }
 export interface CaptureCandidate {
     text: string;

package/opencode-memory-pro.example.json

@@ -19,6 +19,8 @@
     "mode": "hybrid",
     "vectorWeight": 0.7,
     "bm25Weight": 0.3,
+    "fuzzyWeight": 0.15,
+    "fuzzyThreshold": 0.5,
     "minScore": 0.2,
     "rrfK": 60,
     "recencyBoost": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-memory-pro",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "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",
@@ -44,7 +44,8 @@
   "dependencies": {
     "@lancedb/lancedb": "^0.38.0",
     "@opencode-ai/plugin": "^1.4.10",
-    "@opencode-ai/sdk": "^1.4.10"
+    "@opencode-ai/sdk": "^1.4.10",
+    "fuse.js": "^7.5.0"
   },
   "devDependencies": {
     "@types/node": "^22.13.9",