grepmax 0.25.1 → 0.26.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "grepmax",
       "source": "./plugins/grepmax",
       "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
-      "version": "0.25.1",
+      "version": "0.26.0",
       "author": {
         "name": "Robert Owens",
         "email": "robowens@me.com"

package/README.md

@@ -347,6 +347,11 @@ gmax repair --rebuild               # guarded whole-corpus rebuild through the d
 the previous registry shape. Run `gmax index` in that project to persist exact identity; no reset or
 re-embedding is required when the cached files are unchanged.
 
+Cache metadata migrations are lazy and do not require a reset. Catchup stamps compatible legacy
+entries in place, hashes Markdown and MDX by exact bytes, and reprocesses only legacy Markdown or
+paths whose declared vector state disagrees with LanceDB. Files that intentionally produce no
+vectors remain valid cached entries.
+
 A model change cannot be applied by a per-project `gmax index --reset`, even when vector widths
 match: one query embedding cannot safely search rows from another embedding space. Stale-generation
 search and sync fail before mutation, preserving the existing index. Run `gmax repair --rebuild` to

package/dist/commands/doctor.js

@@ -435,21 +435,38 @@ exports.doctor = new commander_1.Command("doctor")
             if (projects.length > 0) {
                 console.log("\nCache Coherence\n");
                 try {
+                    const { reconcileMetaEntry } = yield Promise.resolve().then(() => __importStar(require("../lib/index/cache-coherence")));
                     const { MetaCache } = yield Promise.resolve().then(() => __importStar(require("../lib/store/meta-cache")));
                     const mc = new MetaCache(config_1.PATHS.lmdbPath);
-                    for (const project of projects.filter((p) => p.status === "indexed")) {
-                        const prefix = project.root.endsWith("/")
-                            ? project.root
-                            : `${project.root}/`;
-                        const cachedCount = (yield mc.getKeysWithPrefix(prefix)).size;
-                        const vectorCount = yield db.countDistinctFilesForPath(prefix);
-                        if (cachedCount > 0) {
-                            const pct = Math.round((vectorCount / cachedCount) * 100);
-                            const status = pct >= 80 ? "ok" : "WARN";
-                            console.log(`${status}  ${project.name || path.basename(project.root)}: ${vectorCount} indexed / ${cachedCount} cached (${pct}%)`);
+                    try {
+                        for (const project of projects.filter((p) => p.status === "indexed")) {
+                            const prefix = project.root.endsWith("/")
+                                ? project.root
+                                : `${project.root}/`;
+                            const cachedPaths = yield mc.getKeysWithPrefix(prefix);
+                            const vectorPaths = yield db.getDistinctPathsForPrefix(prefix);
+                            let pending = 0;
+                            let legacy = 0;
+                            for (const cachedPath of cachedPaths) {
+                                const reconciliation = reconcileMetaEntry(cachedPath, mc.get(cachedPath), vectorPaths.has(cachedPath));
+                                if (reconciliation.action === "reprocess")
+                                    pending++;
+                                else if (reconciliation.action === "stamp")
+                                    legacy++;
+                            }
+                            for (const vectorPath of vectorPaths) {
+                                if (!cachedPaths.has(vectorPath))
+                                    pending++;
+                            }
+                            if (cachedPaths.size > 0 || vectorPaths.size > 0) {
+                                const status = pending === 0 ? "ok" : "WARN";
+                                console.log(`${status}  ${project.name || path.basename(project.root)}: ${vectorPaths.size} vector-backed / ${cachedPaths.size} cached; ${pending} pending reconciliation, ${legacy} legacy metadata`);
+                            }
                         }
                     }
-                    yield mc.close();
+                    finally {
+                        yield mc.close();
+                    }
                 }
                 catch (_k) { }
             }

package/dist/lib/daemon/watcher-manager.js

@@ -53,6 +53,7 @@ exports.WatcherManager = void 0;
 const path = __importStar(require("node:path"));
 const watcher = __importStar(require("@parcel/watcher"));
 const batch_processor_1 = require("../index/batch-processor");
+const cache_coherence_1 = require("../index/cache-coherence");
 const file_policy_1 = require("../index/file-policy");
 const walker_1 = require("../index/walker");
 const watcher_1 = require("../index/watcher");
@@ -451,9 +452,12 @@ class WatcherManager {
             var _d, _e;
             const { isFileCached } = yield Promise.resolve().then(() => __importStar(require("../utils/cache-check")));
             const metaCache = this.deps.getMetaCache();
+            const vectorDb = this.deps.getVectorDb();
             processor.filePolicy.invalidateIgnoreCache();
             const rootPrefix = root.endsWith("/") ? root : `${root}/`;
             const cachedPaths = yield metaCache.getKeysWithPrefix(rootPrefix);
+            const vectorPaths = yield vectorDb.getDistinctPathsForPrefix(rootPrefix);
+            const knownPaths = new Set([...cachedPaths, ...vectorPaths]);
             if (signal.aborted)
                 return false;
             const seenPaths = new Set();
@@ -486,7 +490,23 @@ class WatcherManager {
                             continue;
                         const stats = classification.stat;
                         seenPaths.add(absPath);
-                        const cached = metaCache.get(absPath);
+                        let cached = metaCache.get(absPath);
+                        const reconciliation = (0, cache_coherence_1.reconcileMetaEntry)(absPath, cached, vectorPaths.has(absPath));
+                        if (reconciliation.action === "stamp") {
+                            cached = reconciliation.entry;
+                            metaCache.put(absPath, cached);
+                        }
+                        else if (reconciliation.action === "reprocess") {
+                            processor.handleFileEvent("change", absPath, {
+                                forceReprocess: true,
+                            });
+                            queued++;
+                            if (queued % 500 === 0) {
+                                (0, logger_1.debug)("catchup", `${path.basename(root)}: throttle pause at ${queued} queued`);
+                                yield abortableDelay(5000, signal);
+                            }
+                            continue;
+                        }
                         if (!isFileCached(cached, stats)) {
                             // Fast path: if only mtime changed but size is identical and we have a hash,
                             // just verify the hash in-process instead of sending to a worker.
@@ -545,12 +565,12 @@ class WatcherManager {
             (0, logger_1.debug)("catchup", `${path.basename(root)}: ${queued} queued, ${skipped} skipped (cached ok), ${seenPaths.size} total`);
             // Purge files deleted while daemon was offline
             let purged = 0;
-            for (const cachedPath of cachedPaths) {
+            for (const cachedPath of knownPaths) {
                 if (signal.aborted)
                     return false;
                 if (!seenPaths.has(cachedPath) &&
                     !(0, walker_1.isPathProtectedByWalkState)(cachedPath, walkState)) {
-                    processor.handleFileEvent("unlink", cachedPath);
+                    processor.handleFileEvent("unlink", cachedPath, { forceDelete: true });
                     purged++;
                 }
             }

package/dist/lib/index/batch-processor.js

@@ -49,6 +49,7 @@ const cache_check_1 = require("../utils/cache-check");
 const file_utils_1 = require("../utils/file-utils");
 const logger_1 = require("../utils/logger");
 const pool_1 = require("../workers/pool");
+const cache_coherence_1 = require("./cache-coherence");
 const file_policy_1 = require("./file-policy");
 const watcher_batch_1 = require("./watcher-batch");
 const DEBOUNCE_MS = 2000;
@@ -61,6 +62,8 @@ class ProjectBatchProcessor {
         this.retryCount = new Map();
         this.retryAt = new Map();
         this.terminalFailures = new Set();
+        this.forcedReprocess = new Map();
+        this.forceGeneration = 0;
         this.debounceTimer = null;
         this.debounceDueMs = 0;
         this.activeBatch = null;
@@ -89,7 +92,7 @@ class ProjectBatchProcessor {
         })();
         this.batchTimeoutMs = Math.max(Math.ceil(taskTimeoutMs * 1.5), 120000);
     }
-    handleFileEvent(event, absPath) {
+    handleFileEvent(event, absPath, options) {
         var _a, _b;
         if (this.closed)
             return;
@@ -108,8 +111,13 @@ class ProjectBatchProcessor {
             (_a = this.onPolicyChange) === null || _a === void 0 ? void 0 : _a.call(this);
             return;
         }
-        if (!(0, file_utils_1.isIndexableFile)(normalized, 1) && !this.metaCache.get(normalized))
+        if (!(0, file_utils_1.isIndexableFile)(normalized, 1) &&
+            !this.metaCache.get(normalized) &&
+            !(event === "unlink" && (options === null || options === void 0 ? void 0 : options.forceDelete)))
             return;
+        if (options === null || options === void 0 ? void 0 : options.forceReprocess) {
+            this.forcedReprocess.set(normalized, ++this.forceGeneration);
+        }
         this.retryAt.delete(normalized);
         this.pending.set(normalized, event);
         (_b = this.onActivity) === null || _b === void 0 ? void 0 : _b.call(this);
@@ -199,12 +207,17 @@ class ProjectBatchProcessor {
                 return;
             }
             const batch = new Map();
+            const batchForceGenerations = new Map();
             const now = Date.now();
             let taken = 0;
             for (const [absPath, event] of this.pending) {
                 if (((_a = this.retryAt.get(absPath)) !== null && _a !== void 0 ? _a : 0) > now)
                     continue;
                 batch.set(absPath, event);
+                const forceGeneration = this.forcedReprocess.get(absPath);
+                if (forceGeneration !== undefined) {
+                    batchForceGenerations.set(absPath, forceGeneration);
+                }
                 taken++;
                 if (taken >= MAX_BATCH_SIZE)
                     break;
@@ -292,13 +305,16 @@ class ProjectBatchProcessor {
                         }
                         const stats = classification.stat;
                         const cached = this.metaCache.get(absPath);
-                        if ((0, cache_check_1.isFileCached)(cached, stats)) {
+                        const forceReprocess = batchForceGenerations.has(absPath);
+                        if (!forceReprocess &&
+                            (0, cache_coherence_1.isMetaEntryCacheCurrent)(cached, absPath) &&
+                            (0, cache_check_1.isFileCached)(cached, stats)) {
                             completed.add(absPath);
                             continue;
                         }
                         // Fast path: if only mtime changed but size matches and we have a hash,
                         // verify in-process instead of dispatching to a worker (~220ms saved).
-                        if ((cached === null || cached === void 0 ? void 0 : cached.hash) && cached.size === stats.size) {
+                        if (!forceReprocess && (cached === null || cached === void 0 ? void 0 : cached.hash) && cached.size === stats.size) {
                             const snapshot = yield (0, file_utils_1.readFileSnapshot)(absPath, {
                                 projectRoot: this.projectRoot,
                             });
@@ -341,8 +357,13 @@ class ProjectBatchProcessor {
                             hash: result.hash,
                             mtimeMs: result.mtimeMs,
                             size: result.size,
+                            hashVersion: cache_coherence_1.CURRENT_META_HASH_VERSION,
+                            hasVectors: result.vectors.length > 0,
                         };
-                        if (cached && cached.hash === result.hash) {
+                        if (!forceReprocess &&
+                            (0, cache_coherence_1.isMetaEntryCacheCurrent)(cached, absPath) &&
+                            cached.hash === result.hash &&
+                            cached.hasVectors === result.vectors.length > 0) {
                             metaUpdates.set(absPath, metaEntry);
                             completed.add(absPath);
                             continue;
@@ -441,6 +462,11 @@ class ProjectBatchProcessor {
                 const remaining = this.pending.size;
                 (0, logger_1.log)(this.wtag, `Batch complete: ${batch.size} files, ${reindexed} reindexed (${(duration / 1000).toFixed(1)}s)${remaining > 0 ? ` — ${remaining} remaining` : ""}`);
                 for (const absPath of completed) {
+                    const processedForce = batchForceGenerations.get(absPath);
+                    if (processedForce !== undefined &&
+                        this.forcedReprocess.get(absPath) === processedForce) {
+                        this.forcedReprocess.delete(absPath);
+                    }
                     this.retryCount.delete(absPath);
                     this.retryAt.delete(absPath);
                     this.terminalFailures.delete(absPath);

package/dist/lib/index/cache-coherence.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CURRENT_META_HASH_VERSION = void 0;
+exports.isMetaEntryCacheCurrent = isMetaEntryCacheCurrent;
+exports.reconcileMetaEntry = reconcileMetaEntry;
+const path = __importStar(require("node:path"));
+exports.CURRENT_META_HASH_VERSION = 1;
+function usesLegacyMarkdownHash(filePath, entry) {
+    if (entry.hashVersion === exports.CURRENT_META_HASH_VERSION)
+        return false;
+    const extension = path.extname(filePath).toLowerCase();
+    return extension === ".md" || extension === ".mdx";
+}
+function isMetaEntryCacheCurrent(entry, _filePath) {
+    return ((entry === null || entry === void 0 ? void 0 : entry.hashVersion) === exports.CURRENT_META_HASH_VERSION &&
+        typeof entry.hasVectors === "boolean");
+}
+function reconcileMetaEntry(filePath, entry, vectorPresent) {
+    if (!entry) {
+        return { action: "reprocess", mustRewriteVectors: vectorPresent };
+    }
+    const explicitVectorState = typeof entry.hasVectors === "boolean";
+    if ((entry.hasVectors === true && !vectorPresent) ||
+        (entry.hasVectors === false && vectorPresent) ||
+        (!explicitVectorState && !vectorPresent)) {
+        return { action: "reprocess", mustRewriteVectors: true };
+    }
+    if (entry.hashVersion !== undefined &&
+        entry.hashVersion !== exports.CURRENT_META_HASH_VERSION) {
+        return { action: "reprocess", mustRewriteVectors: false };
+    }
+    if (usesLegacyMarkdownHash(filePath, entry)) {
+        return { action: "reprocess", mustRewriteVectors: false };
+    }
+    if (entry.hashVersion !== exports.CURRENT_META_HASH_VERSION || !explicitVectorState) {
+        return {
+            action: "stamp",
+            entry: Object.assign(Object.assign({}, entry), { hashVersion: exports.CURRENT_META_HASH_VERSION, hasVectors: vectorPresent }),
+        };
+    }
+    return { action: "current" };
+}

package/dist/lib/index/syncer.js

@@ -56,12 +56,13 @@ const path = __importStar(require("node:path"));
 const config_1 = require("../../config");
 const meta_cache_1 = require("../store/meta-cache");
 const vector_db_1 = require("../store/vector-db");
-// isIndexableFile no longer used — extension check inlined for performance
+const cache_check_1 = require("../utils/cache-check");
 const lock_1 = require("../utils/lock");
 const logger_1 = require("../utils/logger");
 const project_registry_1 = require("../utils/project-registry");
 const project_root_1 = require("../utils/project-root");
 const pool_1 = require("../workers/pool");
+const cache_coherence_1 = require("./cache-coherence");
 const embedding_generation_1 = require("./embedding-generation");
 const file_policy_1 = require("./file-policy");
 const index_config_1 = require("./index-config");
@@ -185,33 +186,35 @@ function initialSync(options) {
             }
             // At this point metaCache is always initialized (injected, created, or noop)
             const mc = metaCache;
+            let vectorPaths = new Set();
+            const reprocessPaths = new Set();
+            const mustRewritePaths = new Set();
             if (!dryRun) {
                 // Scope checks to this project's paths only
                 const projectKeys = yield mc.getKeysWithPrefix(rootPrefix);
                 (0, logger_1.log)("index", `Cached files: ${projectKeys.size}`);
-                // Coherence check: if LMDB has substantially more entries than LanceDB
-                // has distinct files, the vector store is out of sync (e.g. batch
-                // timeouts wrote MetaCache but not vectors, compaction failure, etc.).
-                // Clear the stale cache entries so those files get re-embedded.
-                const vectorFileCount = yield vectorDb.countDistinctFilesForPath(rootPrefix);
-                if (projectKeys.size > 0) {
-                    const pct = Math.round((vectorFileCount / projectKeys.size) * 100);
-                    (0, logger_1.log)("index", `Coherence: ${vectorFileCount} vectors / ${projectKeys.size} cached (${pct}%)`);
-                }
-                if (projectKeys.size > 0 && vectorFileCount === 0) {
-                    (0, logger_1.log)("index", `Stale cache detected: ${projectKeys.size} cached files but no vectors — clearing cache`);
-                    for (const key of projectKeys) {
-                        mc.delete(key);
+                vectorPaths = yield vectorDb.getDistinctPathsForPrefix(rootPrefix);
+                let stamped = 0;
+                for (const key of projectKeys) {
+                    const reconciliation = (0, cache_coherence_1.reconcileMetaEntry)(key, mc.get(key), vectorPaths.has(key));
+                    if (reconciliation.action === "stamp") {
+                        mc.put(key, reconciliation.entry);
+                        stamped++;
                     }
-                    projectKeys.clear();
-                }
-                else if (projectKeys.size > 0 &&
-                    vectorFileCount < projectKeys.size * 0.8) {
-                    (0, logger_1.log)("index", `Partial cache detected: ${vectorFileCount} files in vectors vs ${projectKeys.size} in cache — clearing cache to re-embed missing files`);
-                    for (const key of projectKeys) {
-                        mc.delete(key);
+                    else if (reconciliation.action === "reprocess") {
+                        reprocessPaths.add(key);
+                        if (reconciliation.mustRewriteVectors)
+                            mustRewritePaths.add(key);
                     }
-                    projectKeys.clear();
+                }
+                for (const vectorPath of vectorPaths) {
+                    if (projectKeys.has(vectorPath))
+                        continue;
+                    reprocessPaths.add(vectorPath);
+                    mustRewritePaths.add(vectorPath);
+                }
+                if (projectKeys.size > 0 || vectorPaths.size > 0) {
+                    (0, logger_1.log)("index", `Coherence: ${vectorPaths.size} vector files / ${projectKeys.size} cached; ${stamped} metadata stamps, ${reprocessPaths.size} paths to reconcile`);
                 }
                 if (reset) {
                     forceReprocess = true;
@@ -431,10 +434,9 @@ function initialSync(options) {
                                 return;
                             const stats = classified.stat;
                             // Use absolute path as the key for MetaCache
-                            const cached = forceReprocess ? undefined : mc.get(absPath);
-                            if (cached &&
-                                cached.mtimeMs === stats.mtimeMs &&
-                                cached.size === stats.size) {
+                            const cached = mc.get(absPath);
+                            const forcePath = forceReprocess || reprocessPaths.has(absPath);
+                            if (!forcePath && (0, cache_check_1.isFileCached)(cached, stats)) {
                                 cacheHits++;
                                 (0, logger_1.debug)("index", `file ${relPath}: cached`);
                                 processed += 1;
@@ -475,6 +477,8 @@ function initialSync(options) {
                                 hash: result.hash,
                                 mtimeMs: result.mtimeMs,
                                 size: result.size,
+                                hashVersion: cache_coherence_1.CURRENT_META_HASH_VERSION,
+                                hasVectors: result.vectors.length > 0,
                             };
                             if (result.shouldDelete) {
                                 (0, logger_1.debug)("index", `file ${relPath}: non-indexable (delete)`);
@@ -489,7 +493,10 @@ function initialSync(options) {
                                 markProgress(relPath);
                                 return;
                             }
-                            if (cached && cached.hash === result.hash) {
+                            if (!forceReprocess &&
+                                !mustRewritePaths.has(absPath) &&
+                                (cached === null || cached === void 0 ? void 0 : cached.hash) === result.hash &&
+                                vectorPaths.has(absPath) === result.vectors.length > 0) {
                                 (0, logger_1.debug)("index", `file ${relPath}: hash unchanged`);
                                 if (!dryRun) {
                                     mc.put(absPath, metaEntry);
@@ -568,14 +575,9 @@ function initialSync(options) {
                     : new Error(String(flushError));
             }
             throwIfSyncAborted();
-            // Stale cleanup: only remove paths scoped to this project's root.
-            // If MetaCache was cleared (coherence check), fall back to LanceDB paths
-            // so we can still detect orphaned vectors from absorbed/removed sub-projects.
-            let staleSource = cachedPaths;
-            if (staleSource.size === 0 && !dryRun && !shouldSkipCleanup) {
-                (0, logger_1.log)("index", "MetaCache empty — querying LanceDB for stale path detection");
-                staleSource = yield vectorDb.getDistinctPathsForPrefix(rootPrefix);
-            }
+            // Stale cleanup uses both stores so vector-only orphans cannot survive
+            // merely because another path still has metadata.
+            const staleSource = new Set([...cachedPaths, ...vectorPaths]);
             throwIfSyncAborted();
             const staleCandidates = computeStaleFiles(staleSource, seenPaths).filter((candidate) => !(0, walker_1.isPathProtectedByWalkState)(candidate, walkState));
             const stale = [];

package/dist/lib/index/watcher-batch.js

@@ -49,6 +49,7 @@ exports.computeRetryAction = computeRetryAction;
 const fs = __importStar(require("node:fs"));
 const cache_check_1 = require("../utils/cache-check");
 const file_utils_1 = require("../utils/file-utils");
+const cache_coherence_1 = require("./cache-coherence");
 function processBatchCore(batch, metaCache, pool, signal) {
     return __awaiter(this, void 0, void 0, function* () {
         let reindexed = 0;
@@ -80,7 +81,8 @@ function processBatchCore(batch, metaCache, pool, signal) {
                     continue;
                 }
                 const cached = metaCache.get(absPath);
-                if ((0, cache_check_1.isFileCached)(cached, stats)) {
+                if ((0, cache_coherence_1.isMetaEntryCacheCurrent)(cached, absPath) &&
+                    (0, cache_check_1.isFileCached)(cached, stats)) {
                     continue;
                 }
                 const result = yield pool.processFile({
@@ -91,8 +93,12 @@ function processBatchCore(batch, metaCache, pool, signal) {
                     hash: result.hash,
                     mtimeMs: result.mtimeMs,
                     size: result.size,
+                    hashVersion: cache_coherence_1.CURRENT_META_HASH_VERSION,
+                    hasVectors: result.vectors.length > 0,
                 };
-                if (cached && cached.hash === result.hash) {
+                if ((0, cache_coherence_1.isMetaEntryCacheCurrent)(cached, absPath) &&
+                    cached.hash === result.hash &&
+                    cached.hasVectors === result.vectors.length > 0) {
                     metaUpdates.set(absPath, metaEntry);
                     continue;
                 }

package/dist/lib/index/watcher.js

@@ -54,6 +54,7 @@ exports.startWatcher = startWatcher;
 const path = __importStar(require("node:path"));
 const watcher = __importStar(require("@parcel/watcher"));
 const batch_processor_1 = require("./batch-processor");
+const cache_coherence_1 = require("./cache-coherence");
 const file_policy_1 = require("./file-policy");
 const walker_1 = require("./walker");
 // Ignore patterns for @parcel/watcher (micromatch globs + directory names).
@@ -124,6 +125,8 @@ function startWatcher(opts) {
                         ? projectRoot
                         : `${projectRoot}/`;
                     const cached = yield opts.metaCache.getKeysWithPrefix(rootPrefix);
+                    const vectorPaths = yield opts.vectorDb.getDistinctPathsForPrefix(rootPrefix);
+                    const knownPaths = new Set([...cached, ...vectorPaths]);
                     const seen = new Set();
                     const state = (0, walker_1.createWalkState)();
                     try {
@@ -138,7 +141,13 @@ function startWatcher(opts) {
                                 return;
                             const absolute = path.join(projectRoot, relative);
                             seen.add(absolute);
-                            processor.handleFileEvent("change", absolute);
+                            const reconciliation = (0, cache_coherence_1.reconcileMetaEntry)(absolute, opts.metaCache.get(absolute), vectorPaths.has(absolute));
+                            if (reconciliation.action === "stamp") {
+                                opts.metaCache.put(absolute, reconciliation.entry);
+                            }
+                            processor.handleFileEvent("change", absolute, {
+                                forceReprocess: reconciliation.action === "reprocess",
+                            });
                         }
                     }
                     catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -148,12 +157,14 @@ function startWatcher(opts) {
                         }
                         finally { if (e_1) throw e_1.error; }
                     }
-                    for (const cachedPath of cached) {
+                    for (const cachedPath of knownPaths) {
                         if (closing)
                             return;
                         if (!seen.has(cachedPath) &&
                             !(0, walker_1.isPathProtectedByWalkState)(cachedPath, state)) {
-                            processor.handleFileEvent("unlink", cachedPath);
+                            processor.handleFileEvent("unlink", cachedPath, {
+                                forceDelete: true,
+                            });
                         }
                     }
                     if (!state.rootComplete || state.errors.length > 0) {

package/dist/lib/utils/file-utils.js

@@ -43,7 +43,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.computeBufferHash = computeBufferHash;
-exports.stripMarkdownFrontmatter = stripMarkdownFrontmatter;
 exports.computeContentHash = computeContentHash;
 exports.hasNullByte = hasNullByte;
 exports.readFileSnapshot = readFileSnapshot;
@@ -62,35 +61,8 @@ const path_containment_1 = require("./path-containment");
 function computeBufferHash(buffer) {
     return (0, node_crypto_1.createHash)("sha256").update(buffer).digest("hex");
 }
-// Files whose leading YAML frontmatter is metadata, not content. A status:/tags:
-// edit bumps mtime and changes the bytes, but the embedding ignores frontmatter —
-// so hashing it would force a needless GPU re-embed on every metadata touch.
-const FRONTMATTER_EXTENSIONS = new Set([".md", ".mdx"]);
-// Leading YAML frontmatter: a whole `---` line at the very top (NOT a bare
-// `startsWith("---")`, which would also match a `---` thematic break or `--- x`),
-// through the next whole `---`/`...` line. Anchored at string start (no `m` flag)
-// with an optional BOM, so only true file-leading frontmatter matches; a doc that
-// opens with a thematic break and no closing fence is left untouched.
-const FRONTMATTER_BLOCK = /^\uFEFF?---[ \t]*\r?\n[\s\S]*?\r?\n(?:---|\.\.\.)[ \t]*(?:\r?\n|$)/;
-/** Strip leading YAML frontmatter from markdown bytes; returns input unchanged otherwise. */
-function stripMarkdownFrontmatter(buffer) {
-    const text = buffer.toString("utf8");
-    const match = text.match(FRONTMATTER_BLOCK);
-    if (!match)
-        return buffer;
-    return Buffer.from(text.slice(match[0].length), "utf8");
-}
-/**
- * Hash file content for change detection. For markdown, YAML frontmatter is
- * stripped first so a metadata-only edit doesn't bust `isFileCached` and trigger
- * a re-embed; every other file hashes its exact bytes. Must be used identically
- * across the catchup, watcher, and worker hash paths or they will disagree and
- * re-index in a loop.
- */
-function computeContentHash(buffer, filePath) {
-    if (FRONTMATTER_EXTENSIONS.has((0, node_path_1.extname)(filePath).toLowerCase())) {
-        return computeBufferHash(stripMarkdownFrontmatter(buffer));
-    }
+/** Hash the exact bytes passed to chunking and embedding. */
+function computeContentHash(buffer, _filePath) {
     return computeBufferHash(buffer);
 }
 function hasNullByte(buffer, sampleLength = 1024) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.25.1",
+  "version": "0.26.0",
   "author": "Robert Owens <78518764+reowens@users.noreply.github.com>",
   "homepage": "https://github.com/reowens/grepmax",
   "bugs": {

package/plugins/grepmax/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "grepmax",
-  "version": "0.25.1",
+  "version": "0.26.0",
   "description": "Semantic code search for Claude Code. Automatically indexes your project and provides intelligent search capabilities.",
   "author": {
     "name": "Robert Owens",