opencode-rag-plugin 1.18.2 → 1.19.1

package/ReadMe.md

@@ -55,7 +55,7 @@ opencode-rag query "authentication middleware"
 
 A browser-based dashboard for exploring the indexed vector database - browse and inspect chunks and evaluate the OpenCode sessions in terms of retrieved chunks, consumed tokens and more.
 
-![OpenCodeRAG Web UI](doc/assets/eval.png)
+![OpenCodeRAG Web UI](doc/assets/webui-dashboard.png)
 
 Launch with `opencode-rag ui`. See [Web UI documentation](doc/webui.md) for details.
 

package/dist/content/reader.d.ts

@@ -3,6 +3,7 @@
  */
 import type { RagConfig } from "../core/config.js";
 import { type FileManifest } from "../core/manifest.js";
+import { type ExcludeMatcher } from "../core/exclude.js";
 import { DescriptionCache } from "../core/desc-cache.js";
 import { type ImageVisionProvider } from "../chunker/image.js";
 /** Metadata and extracted content for a single workspace file discovered during scanning. */
@@ -27,7 +28,7 @@ interface Logger {
  * Recursively walk a directory tree and collect paths matching the given extension set,
  * respecting exclusion lists and configurable limits for max directories and results.
  */
-export declare function walkFiles(dir: string, extensions: Set<string>, excludeDirs: Set<string>, excludeFiles?: Set<string>, logger?: Logger, dirCount?: {
+export declare function walkFiles(dir: string, extensions: Set<string>, excludeDirs: ExcludeMatcher, excludeFiles?: ExcludeMatcher, rootDir?: string, logger?: Logger, dirCount?: {
     value: number;
 }, maxDirs?: number, maxResults?: number): Promise<string[]>;
 /**

package/dist/content/reader.js

@@ -5,6 +5,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import pLimit from "p-limit";
 import { computeFileHash, computeDescriptionConfigHash, normalizeFilePath } from "../core/manifest.js";
+import { createExcludeMatcher } from "../core/exclude.js";
 import { DescriptionCache } from "../core/desc-cache.js";
 import { createImageVisionProvider, } from "../chunker/image.js";
 import * as pdfExtractor from "./pdf.js";
@@ -16,15 +17,13 @@ import * as imageExtractor from "./image.js";
  * Recursively walk a directory tree and collect paths matching the given extension set,
  * respecting exclusion lists and configurable limits for max directories and results.
  */
-export async function walkFiles(dir, extensions, excludeDirs, excludeFiles, logger, dirCount, maxDirs = 10_000, maxResults = 100_000) {
+export async function walkFiles(dir, extensions, excludeDirs, excludeFiles, rootDir = dir, logger, dirCount, maxDirs = 10_000, maxResults = 100_000) {
     const results = [];
     const entries = await fs.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
         const fullPath = path.join(dir, entry.name);
         if (entry.isDirectory()) {
-            if (excludeDirs.has(entry.name))
-                continue;
-            if (entry.name.startsWith("."))
+            if (excludeDirs.excluded(path.relative(rootDir, fullPath)))
                 continue;
             if (dirCount) {
                 dirCount.value++;
@@ -40,7 +39,7 @@ export async function walkFiles(dir, extensions, excludeDirs, excludeFiles, logg
                 logger?.warn(`Exceeded ${maxResults} matching files — truncating walk at ${fullPath}`);
                 return results;
             }
-            results.push(...(await walkFiles(fullPath, extensions, excludeDirs, excludeFiles, logger, dirCount, maxDirs, maxResults)));
+            results.push(...(await walkFiles(fullPath, extensions, excludeDirs, excludeFiles, rootDir, logger, dirCount, maxDirs, maxResults)));
         }
         else if (entry.isFile()) {
             if (results.length >= maxResults) {
@@ -49,7 +48,7 @@ export async function walkFiles(dir, extensions, excludeDirs, excludeFiles, logg
             }
             const ext = path.extname(entry.name).toLowerCase();
             const basename = entry.name.toLowerCase();
-            if ((extensions.has(ext) || extensions.has(basename)) && !excludeFiles?.has(basename)) {
+            if ((extensions.has(ext) || extensions.has(basename)) && !excludeFiles?.excluded(path.relative(rootDir, fullPath))) {
                 results.push(fullPath);
             }
         }
@@ -103,10 +102,10 @@ export async function scanWorkspaceFiles(cwd, config, logger, manifest, filterPa
         imagePrompt = imageCfg.prompt;
         imageResizeMaxDimension = imageCfg.resizeMaxDimension;
     }
+    const excludeDirMatcher = createExcludeMatcher(config.indexing.excludeDirs);
+    const excludeFileMatcher = createExcludeMatcher(config.indexing.excludeFiles ?? []);
     let files;
     if (filterPaths && filterPaths.length > 0) {
-        const excludeDirs = new Set(config.indexing.excludeDirs);
-        const excludeFiles = new Set(config.indexing.excludeFiles?.map((f) => f.toLowerCase()) ?? []);
         files = filterPaths
             .map((p) => path.resolve(cwd, p))
             .filter((fp) => {
@@ -114,22 +113,17 @@ export async function scanWorkspaceFiles(cwd, config, logger, manifest, filterPa
             const basename = path.basename(fp).toLowerCase();
             if (!extensions.has(ext) && !extensions.has(basename))
                 return false;
-            if (excludeFiles.has(basename))
-                return false;
             const rel = path.relative(cwd, fp);
             if (rel.startsWith(".."))
                 return false;
-            const parts = rel.split(path.sep);
-            if (parts.some((part) => excludeDirs.has(part)))
-                return false;
-            return true;
+            return !excludeDirMatcher.excluded(rel) && !excludeFileMatcher.excluded(rel);
         });
     }
     else {
         logger?.info("Walking directory tree...");
         const walkStart = Date.now();
         const dirCount = { value: 0 };
-        files = await walkFiles(cwd, extensions, new Set(config.indexing.excludeDirs), new Set(config.indexing.excludeFiles?.map((f) => f.toLowerCase()) ?? []), logger, dirCount);
+        files = await walkFiles(cwd, extensions, excludeDirMatcher, excludeFileMatcher, cwd, logger, dirCount);
         const walkSec = ((Date.now() - walkStart) / 1000).toFixed(1);
         logger?.info(`Found ${files.length} matching files in ${walkSec}s (${dirCount.value} dirs traversed)`);
     }

package/dist/core/config.d.ts

@@ -137,6 +137,13 @@ export interface MemoryConfig {
     autoInjectLatencyBudgetMs: number;
     /** Max quirks to auto-inject per turn (default 2). */
     autoInjectTopK: number;
+    /**
+     * Minimum number of shared word tokens (≥3 chars) between a candidate quirk's
+     * content and the user's *current* message for the quirk to be auto-injected
+     * (default 1). Acts as a relevance gate against meta-quirks that match only
+     * the prior assistant text in the combined recall query. Set to `0` to disable.
+     */
+    autoInjectMinTokenOverlap: number;
     /** Automatically extract quirks from each completed agent turn. */
     passiveCapture: boolean;
     /** Upgrade the system-prompt nudge into a mandatory trigger. */
@@ -218,9 +225,28 @@ export interface RagConfig {
     indexing: {
         /** File extensions to include in indexing. */
         includeExtensions: string[];
-        /** Directory name patterns to exclude. */
+        /**
+         * Directory/file name patterns to exclude.
+         *
+         * Semantics (same for `excludeFiles`):
+         * - Plain name (no path separator, no glob chars `* ? [ { (`):
+         *   matches that **basename** at **any depth** (case-insensitive).
+         * - Basename glob (glob chars, no separator):
+         *   matches the segment at any depth via glob.
+         * - Path pattern (contains a separator or `**`):
+         *   **anchored to the workspace root** — matched as a glob against each
+         *   ancestor prefix (so it excludes the matched directory and all contents).
+         *
+         * Supports standard wildcards: `*`, `?`, `[...]`, `{a,b}`, `(pattern)`.
+         * Use `/` as path separator (converted automatically). Matching is
+         * case-insensitive and dot-inclusive.
+         */
         excludeDirs: string[];
-        /** Specific filenames (basenames, case-insensitive) to exclude from indexing. */
+        /**
+         * File-name patterns to exclude (same semantics as `excludeDirs`).
+         * Plain names match any file with that basename at any depth; path
+         * patterns are anchored to the workspace root.
+         */
         excludeFiles?: string[];
         /** Number of overlapping lines between adjacent chunks. */
         chunkOverlap: number;

package/dist/core/config.js

@@ -95,6 +95,17 @@ export const DEFAULT_CONFIG = {
             ".commandcode",
             ".agents",
             "graphify-out",
+            ".vscode",
+            ".vs",
+            ".idea",
+            ".next",
+            ".nuxt",
+            ".turbo",
+            ".angular",
+            ".svelte-kit",
+            ".gradle",
+            ".dart_tool",
+            ".cache",
         ],
         excludeFiles: [
             "package-lock.json",
@@ -103,7 +114,7 @@ export const DEFAULT_CONFIG = {
         minFileSizeBytes: 0,
         concurrency: 8,
         embedBatchSize: 100,
-        embedConcurrency: 6,
+        embedConcurrency: 3,
         ollamaMaxBatchSize: 500,
         descriptionConcurrency: 4,
         maxSvgSizeBytes: 1_048_576,
@@ -261,6 +272,7 @@ export const DEFAULT_CONFIG = {
         autoInjectMinScore: 0.6,
         autoInjectLatencyBudgetMs: 2000,
         autoInjectTopK: 2,
+        autoInjectMinTokenOverlap: 1,
         passiveCapture: false,
         promptEnforcement: true,
         sessionEndExtraction: true,

package/dist/core/exclude.d.ts

@@ -0,0 +1,4 @@
+export interface ExcludeMatcher {
+    excluded(relPath: string): boolean;
+}
+export declare function createExcludeMatcher(patterns: string[]): ExcludeMatcher;

package/dist/core/exclude.js

@@ -0,0 +1,45 @@
+import { Minimatch } from "minimatch";
+const GLOB_MAGIC = /[*?{}()\[\]]/;
+export function createExcludeMatcher(patterns) {
+    const plainBasenames = new Set();
+    const basenameGlobMatchers = [];
+    const pathMatchers = [];
+    for (const pattern of patterns) {
+        const pat = pattern.trim().replace(/\\/g, "/");
+        if (!pat)
+            continue;
+        const hasSep = pat.includes("/");
+        const isGlob = GLOB_MAGIC.test(pat);
+        if (!hasSep && !isGlob) {
+            plainBasenames.add(pat.toLowerCase());
+        }
+        else if (!hasSep && isGlob) {
+            basenameGlobMatchers.push(new Minimatch(pat, { nocase: true, dot: true }));
+        }
+        else {
+            pathMatchers.push(new Minimatch(pat, { nocase: true, dot: true }));
+        }
+    }
+    function excluded(relPath) {
+        const normalized = relPath.replace(/\\/g, "/");
+        const segments = normalized.split("/");
+        let prefix = "";
+        for (const seg of segments) {
+            const segLower = seg.toLowerCase();
+            prefix = prefix ? `${prefix}/${seg}` : seg;
+            if (plainBasenames.has(segLower))
+                return true;
+            for (const mm of basenameGlobMatchers) {
+                if (mm.match(seg))
+                    return true;
+            }
+            for (const mm of pathMatchers) {
+                if (mm.match(prefix))
+                    return true;
+            }
+        }
+        return false;
+    }
+    return { excluded };
+}
+//# sourceMappingURL=exclude.js.map

package/dist/core/interfaces.d.ts

@@ -185,6 +185,12 @@ export interface VectorStore {
     reopen?(newPath?: string): Promise<void>;
     /** Compact fragments and prune old versions to prevent version-manifest accumulation. */
     optimize?(): Promise<void>;
+    /**
+     * Verify that the store's data is actually readable.
+     * Returns false if data integrity is compromised (e.g., data files missing from disk).
+     * Used by the index pipeline to detect silent corruption before scanning.
+     */
+    checkIntegrity?(): Promise<boolean>;
 }
 /** Filter criteria for narrowing search results by file path, language, or kind. */
 export interface MetadataFilter {

package/dist/embedder/factory.d.ts

@@ -16,12 +16,16 @@ import type { RagConfig } from "../core/config.js";
  */
 export declare function createEmbedder(config: RagConfig): EmbeddingProvider;
 /**
- * Embed a list of texts in batches with optional concurrency control.
+ * Embed a list of texts in batches with optional concurrency control and per-batch retry.
  *
  * Splits the input texts into chunks of `batchSize` and embeds them sequentially
  * (or concurrently when `concurrency > 1`). When concurrency is limited, uses
  * `p-limit` to cap the number of in-flight requests.
  *
+ * Each batch is retried up to `retryMax` times with exponential backoff. If all
+ * retries are exhausted, the batch is skipped and empty arrays are returned for
+ * those texts so the caller can still process successfully embedded batches.
+ *
  * @param embedder - The embedding provider to use
  * @param texts - Array of text strings to embed
  * @param batchSize - Number of texts per batch (default 10)
@@ -29,6 +33,9 @@ export declare function createEmbedder(config: RagConfig): EmbeddingProvider;
  * @param concurrency - Maximum number of concurrent batch requests (default 1)
  * @param onProgress - Optional callback invoked after each batch with the running
  *   completed count and total; per-text granularity when `concurrency <= 1`.
- * @returns A promise resolving to a flat array of embedding vectors (one per input text)
+ * @param retryMax - Maximum retry attempts per batch (default 3)
+ * @param retryBaseDelayMs - Base delay for exponential backoff (default 1000)
+ * @returns A promise resolving to a flat array of embedding vectors (one per input text);
+ *   failed batches return empty arrays
  */
-export declare function embedBatch(embedder: EmbeddingProvider, texts: string[], batchSize?: number, purpose?: "query" | "document", concurrency?: number, onProgress?: (completed: number, total: number) => void): Promise<number[][]>;
+export declare function embedBatch(embedder: EmbeddingProvider, texts: string[], batchSize?: number, purpose?: "query" | "document", concurrency?: number, onProgress?: (completed: number, total: number) => void, retryMax?: number, retryBaseDelayMs?: number): Promise<number[][]>;

package/dist/embedder/factory.js

@@ -35,12 +35,16 @@ export function createEmbedder(config) {
     throw new Error(`Unknown embedding provider: ${provider}`);
 }
 /**
- * Embed a list of texts in batches with optional concurrency control.
+ * Embed a list of texts in batches with optional concurrency control and per-batch retry.
  *
  * Splits the input texts into chunks of `batchSize` and embeds them sequentially
  * (or concurrently when `concurrency > 1`). When concurrency is limited, uses
  * `p-limit` to cap the number of in-flight requests.
  *
+ * Each batch is retried up to `retryMax` times with exponential backoff. If all
+ * retries are exhausted, the batch is skipped and empty arrays are returned for
+ * those texts so the caller can still process successfully embedded batches.
+ *
  * @param embedder - The embedding provider to use
  * @param texts - Array of text strings to embed
  * @param batchSize - Number of texts per batch (default 10)
@@ -48,31 +52,56 @@ export function createEmbedder(config) {
  * @param concurrency - Maximum number of concurrent batch requests (default 1)
  * @param onProgress - Optional callback invoked after each batch with the running
  *   completed count and total; per-text granularity when `concurrency <= 1`.
- * @returns A promise resolving to a flat array of embedding vectors (one per input text)
+ * @param retryMax - Maximum retry attempts per batch (default 3)
+ * @param retryBaseDelayMs - Base delay for exponential backoff (default 1000)
+ * @returns A promise resolving to a flat array of embedding vectors (one per input text);
+ *   failed batches return empty arrays
  */
-export async function embedBatch(embedder, texts, batchSize = 10, purpose, concurrency = 1, onProgress) {
+export async function embedBatch(embedder, texts, batchSize = 10, purpose, concurrency = 1, onProgress, retryMax = 3, retryBaseDelayMs = 1000) {
     if (texts.length === 0)
         return [];
     const batches = [];
     for (let i = 0; i < texts.length; i += batchSize) {
         batches.push({ index: i, texts: texts.slice(i, i + batchSize) });
     }
+    async function embedWithRetry(batchTexts) {
+        for (let attempt = 0; attempt <= retryMax; attempt++) {
+            try {
+                return await embedder.embed(batchTexts, purpose);
+            }
+            catch (err) {
+                if (attempt < retryMax) {
+                    const delay = retryBaseDelayMs * Math.pow(2, attempt);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+        return null;
+    }
     if (concurrency <= 1 || batches.length <= 1) {
         const results = [];
         for (const batch of batches) {
-            const embeddings = await embedder.embed(batch.texts, purpose);
-            results.push(...embeddings);
+            const embeddings = await embedWithRetry(batch.texts);
+            if (embeddings) {
+                results.push(...embeddings);
+            }
+            else {
+                for (let i = 0; i < batch.texts.length; i++) {
+                    results.push([]);
+                }
+            }
             onProgress?.(results.length, texts.length);
         }
         return results;
     }
-    const limit = pLimit(concurrency);
     let completedCount = 0;
+    const limit = pLimit(concurrency);
     const batchResults = await Promise.all(batches.map((batch) => limit(async () => {
-        const embeddings = await embedder.embed(batch.texts, purpose);
-        completedCount += embeddings.length;
+        const embeddings = await embedWithRetry(batch.texts);
+        const flatResult = embeddings ?? batch.texts.map(() => []);
+        completedCount += embeddings?.length ?? 0;
         onProgress?.(completedCount, texts.length);
-        return { index: batch.index, embeddings };
+        return { index: batch.index, embeddings: flatResult };
     })));
     batchResults.sort((a, b) => a.index - b.index);
     const results = [];

package/dist/indexer/pipeline.js

@@ -173,6 +173,27 @@ async function runIndexPassInner(options, logger) {
     const storeCountStart = Date.now();
     const existingCount = await options.store.count();
     logger.info(`Store has ${existingCount} existing chunks (${((Date.now() - storeCountStart) / 1000).toFixed(1)}s)`);
+    // Direct data-integrity check: try to actually read a row from the store.
+    // LanceDB's countRows() may return a value from the version manifest
+    // even when the underlying data files are missing from disk, so we need
+    // an explicit probe.  If this fails, treat the store as corrupt.
+    if (!options.force && manifestStatus === "ok" && Object.keys(manifest.files).length > 0) {
+        try {
+            const isIntact = await options.store.checkIntegrity?.();
+            if (isIntact === false) {
+                logger.warn("Vector store data integrity check failed — data files are missing " +
+                    `(${existingCount} chunks in manifest but store can't be read). Re-indexing all files.`);
+                for (const key of Object.keys(manifest.files)) {
+                    delete manifest.files[key];
+                }
+                manifest.lastIndexedAt = undefined;
+                manifestStatus = "missing";
+            }
+        }
+        catch {
+            // checkIntegrity not available (older VectorStore impl) — skip
+        }
+    }
     // Detect data loss: if the store has far fewer chunks than the manifest expects,
     // treat it as a corrupt store (e.g. schema migration dropped the old table).
     if (!options.force && manifestStatus === "ok" && existingCount > 0) {
@@ -569,7 +590,7 @@ async function runIndexPassInner(options, logger) {
                     hash: prepared[fileIdx].hash,
                     chunkCount: 0, fileLabel: prepared[fileIdx].fileLabel,
                     isNew: false, isModified: false, isUnchanged: false, isEmpty: false,
-                    isTooSmall: false, isRemoved: true, hadChunks: false,
+                    isTooSmall: false, isRemoved: false, hadChunks: false,
                     descriptionFailed: prepared[fileIdx].descriptionFailed,
                 });
             }
@@ -618,14 +639,14 @@ async function runIndexPassInner(options, logger) {
         const result = {
             normalizedPath: prep.normalizedPath,
             hash: prep.hash,
-            chunkCount: prep.chunks?.length ?? 0,
+            chunkCount: validChunks.length,
             fileLabel: prep.fileLabel,
             isNew: !prep.isModified,
             isModified: prep.isModified,
             isUnchanged: false,
             isEmpty: false,
             isTooSmall: false,
-            isRemoved: validChunks.length === 0,
+            isRemoved: (prep.chunks?.length ?? 0) > 0 && validChunks.length === 0 ? false : validChunks.length === 0,
             hadChunks: (prep.chunks?.length ?? 0) > 0,
             descriptionFailed: prep.descriptionFailed,
             descHash: prep.descHash,

package/dist/indexer/watch.js

@@ -3,6 +3,7 @@
  */
 import path from "node:path";
 import { manifestPathFor } from "../core/manifest.js";
+import { createExcludeMatcher } from "../core/exclude.js";
 /**
  * Create a scheduler that debounces calls to a re-index pass. While a pass is
  * running, subsequent notifications queue a single rerun. Useful for watching
@@ -117,7 +118,8 @@ export function createWatchPassScheduler(runPass, onError, debounceMs = 300) {
  */
 export function createWatchIgnore(cwd, config, storePath) {
     const manifestPath = manifestPathFor(storePath);
-    const excludeDirs = new Set(config.indexing.excludeDirs);
+    const dirMatcher = createExcludeMatcher(config.indexing.excludeDirs);
+    const fileMatcher = createExcludeMatcher(config.indexing.excludeFiles ?? []);
     return (watchedPath) => {
         const resolved = path.resolve(watchedPath);
         if (resolved.startsWith(storePath))
@@ -127,8 +129,7 @@ export function createWatchIgnore(cwd, config, storePath) {
         const relative = path.relative(cwd, resolved);
         if (!relative || relative.startsWith(".."))
             return false;
-        const segments = relative.split(path.sep);
-        return segments.some((segment) => excludeDirs.has(segment));
+        return dirMatcher.excluded(relative) || fileMatcher.excluded(relative);
     };
 }
 //# sourceMappingURL=watch.js.map

package/dist/indexer.d.ts

@@ -6,6 +6,7 @@ export type { IndexRunStats, IndexStatusSummary } from "./indexer/stats.js";
 export { createIndexStats } from "./indexer/stats.js";
 export type { WorkspaceFile } from "./content/reader.js";
 export { scanWorkspaceFiles, walkFiles } from "./content/reader.js";
+export { createExcludeMatcher, type ExcludeMatcher } from "./core/exclude.js";
 export type { RunIndexPassOptions, WatchPassScheduler } from "./indexer/pipeline.js";
 export { runIndexPass, getIndexStatusSummary, createWatchPassScheduler, createWatchIgnore, type Logger, } from "./indexer/pipeline.js";
 import type { RagConfig } from "./core/config.js";

package/dist/indexer.js

@@ -4,6 +4,7 @@
  */
 export { createIndexStats } from "./indexer/stats.js";
 export { scanWorkspaceFiles, walkFiles } from "./content/reader.js";
+export { createExcludeMatcher } from "./core/exclude.js";
 export { runIndexPass, getIndexStatusSummary, createWatchPassScheduler, createWatchIgnore, } from "./indexer/pipeline.js";
 import { scanWorkspaceFiles } from "./content/reader.js";
 /**

package/dist/plugin.js

@@ -25,7 +25,7 @@ import { countTokens } from "./eval/token-counter.js";
 import { checkForUpdate, getCurrentVersion, installLatestUpdate } from "./core/version-check.js";
 import { loadAutoUpdateState, saveAutoUpdateState, shouldAttemptInstall } from "./core/auto-update-state.js";
 import { destroyAllPooledConnections } from "./embedder/http.js";
-import { listQuirks, lintQuirks, recallQuirks } from "./quirks/quirk-store.js";
+import { listQuirks, lintQuirks, recallQuirks, sharedWords } from "./quirks/quirk-store.js";
 import { autoCaptureQuirks } from "./quirks/auto-capture.js";
 import { buildSystemGuidanceLines } from "./opencode/system-guidance.js";
 import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
@@ -797,6 +797,13 @@ export function createRagHooks(options) {
                             // Dedup: skip quirks already injected into this session
                             const injectedSet = getOrCreateSessionSet(sessionInjectedQuirks, sessionId, MAX_SESSION_MAP_SIZE);
                             quirkResults = quirkResults.filter((qr) => !injectedSet.has(qr.chunk.id));
+                            // Lexical gate: drop quirks that match only the prior assistant text (no token
+                            // overlap with the user's actual request) — prevents meta-quirks (quirks about
+                            // quirks) from being injected into unrelated tasks. Disabled when autoInjectMinTokenOverlap=0.
+                            const minTokenOverlap = memCfg.autoInjectMinTokenOverlap ?? 1;
+                            if (minTokenOverlap > 0 && userReq.length > 0) {
+                                quirkResults = quirkResults.filter((qr) => sharedWords(qr.chunk.content, userReq) >= minTokenOverlap);
+                            }
                             if (quirkResults.length > 0) {
                                 const lines = ["", "⚠ **Relevant quirks for this task:**", ""];
                                 for (const qr of quirkResults) {
@@ -1088,6 +1095,13 @@ export function createRagHooks(options) {
                             // Dedup: skip quirks already injected into this session
                             const injectedSet = getOrCreateSessionSet(sessionInjectedQuirks, input.sessionID, MAX_SESSION_MAP_SIZE);
                             quirkResults = quirkResults.filter((qr) => !injectedSet.has(qr.chunk.id));
+                            // Lexical gate: drop quirks that match only the prior assistant text (no token
+                            // overlap with the user's current message) — prevents meta-quirks (quirks about
+                            // quirks) from being injected into unrelated tasks. Disabled when autoInjectMinTokenOverlap=0.
+                            const minTokenOverlap = quirkMemoryCfg.autoInjectMinTokenOverlap ?? 1;
+                            if (minTokenOverlap > 0 && text.length > 0) {
+                                quirkResults = quirkResults.filter((qr) => sharedWords(qr.chunk.content, text) >= minTokenOverlap);
+                            }
                             if (quirkResults.length > 0) {
                                 const quirkLines = ["", "---", "⚠ **Quirk memory**", ""];
                                 for (const qr of quirkResults) {

package/dist/quirks/quirk-store.d.ts

@@ -27,3 +27,18 @@ export declare function recallQuirks(deps: QuirkStoreDeps, query: string, option
 export declare function lintQuirks(deps: QuirkStoreDeps): Promise<string[]>;
 /** Simple Jaccard-based lexical similarity (word overlap). */
 export declare function lexicalSimilarity(a: string, b: string): number;
+/**
+ * Count of meaningful word tokens shared between two texts (Jaccard numerator).
+ *
+ * Tokens are whitespace/punctuation-split, lowercased, and filtered to those
+ * with length ≥ `minTokenLen` (default 3 — skips short filler like "the").
+ *
+ * Used by the quirk auto-inject gate: candidate quirks that share no tokens
+ * with the user's *current* message (i.e. they matched only against the prior
+ * assistant text in the combined recall query) are filtered out. This prevents
+ * meta-quirks (quirks about quirks themselves) from being injected into
+ * unrelated tasks, e.g. when the agent previously explained how quirks work.
+ *
+ * Set `memory.autoInjectMinTokenOverlap` to `0` to disable the gate.
+ */
+export declare function sharedWords(a: string, b: string, minTokenLen?: number): number;

package/dist/quirks/quirk-store.js

@@ -214,4 +214,31 @@ export function lexicalSimilarity(a, b) {
     const union = new Set([...wordsA, ...wordsB]);
     return union.size === 0 ? 0 : intersection.size / union.size;
 }
+/**
+ * Count of meaningful word tokens shared between two texts (Jaccard numerator).
+ *
+ * Tokens are whitespace/punctuation-split, lowercased, and filtered to those
+ * with length ≥ `minTokenLen` (default 3 — skips short filler like "the").
+ *
+ * Used by the quirk auto-inject gate: candidate quirks that share no tokens
+ * with the user's *current* message (i.e. they matched only against the prior
+ * assistant text in the combined recall query) are filtered out. This prevents
+ * meta-quirks (quirks about quirks themselves) from being injected into
+ * unrelated tasks, e.g. when the agent previously explained how quirks work.
+ *
+ * Set `memory.autoInjectMinTokenOverlap` to `0` to disable the gate.
+ */
+export function sharedWords(a, b, minTokenLen = 3) {
+    const tokensA = a.toLowerCase().split(/\W+/).filter((w) => w.length >= minTokenLen);
+    const wordsB = new Set(b.toLowerCase().split(/\W+/).filter((w) => w.length >= minTokenLen));
+    let count = 0;
+    const seen = new Set();
+    for (const tok of tokensA) {
+        if (wordsB.has(tok) && !seen.has(tok)) {
+            seen.add(tok);
+            count++;
+        }
+    }
+    return count;
+}
 //# sourceMappingURL=quirk-store.js.map

package/dist/vectorstore/lancedb.d.ts

@@ -90,6 +90,20 @@ export declare class LanceDbStore implements VectorStore {
      * @returns An array of chunk summaries.
      */
     getChunks(offset: number, limit: number): Promise<ChunkSummary[]>;
+    /**
+     * Fetch chunks with their embedding vectors included (for embedding projection).
+     * @param limit - Maximum number of rows to return.
+     * @returns Array of { id, filePath, language, startLine, endLine, description, embedding }.
+     */
+    getChunksWithEmbeddings(limit: number): Promise<{
+        id: string;
+        filePath: string;
+        language: string;
+        startLine: number;
+        endLine: number;
+        description: string;
+        embedding: number[];
+    }[]>;
     /**
      * Perform ANN search internally, returning results scored as cosine similarity (0-1).
      * This method is called by `search()` and handles the actual query logic.
@@ -157,5 +171,24 @@ export declare class LanceDbStore implements VectorStore {
      */
     deleteByFilePath(filePath: string): Promise<void>;
     private deleteByFilePathInternal;
+    /**
+     * Verify that data in the store is actually readable.
+     * Reads the `content` column (a large text field stored in data fragments,
+     * not in the version manifest) for the first few rows.  If any of the
+     * underlying `.lance` data files are missing from disk, LanceDB throws a
+     * corruption error ("Not found: ... .lance") and we return false.
+     *
+     * This catches silent corruption where countRows() returns metadata from
+     * the version manifest while the actual row data on disk is gone.
+     */
+    checkIntegrity(): Promise<boolean>;
+    /**
+     * Execute an async function with automatic corruption recovery.
+     * If the function throws a LanceDB corruption error, tryRepair() is run
+     * and the function is retried once.  If repair fails, the original error
+     * is re-thrown so callers/higher layers can handle it (e.g. return
+     * fallback data, clear the manifest, or trigger a rebuild).
+     */
+    private withCorruptionRecovery;
     private tryRepair;
 }