opencode-rag-plugin 1.19.4 → 1.19.8

package/dist/indexer/stats.d.ts

@@ -38,6 +38,8 @@ export interface IndexRunStats {
     }>;
     /** Number of files where description generation failed. */
     descriptionFailedFiles: number;
+    /** True when the pass was skipped because another pass holds the lock. */
+    skipped: boolean;
 }
 /** Summary of the current index health without running a full pass. */
 export interface IndexStatusSummary {

package/dist/indexer/stats.js

@@ -24,6 +24,7 @@ export function createIndexStats(totalFiles, manifestStatus) {
         extractionFailures: 0,
         extractionErrors: [],
         descriptionFailedFiles: 0,
+        skipped: false,
     };
 }
 //# sourceMappingURL=stats.js.map

package/dist/indexer/watch.js

@@ -120,9 +120,16 @@ export function createWatchIgnore(cwd, config, storePath) {
     const manifestPath = manifestPathFor(storePath);
     const dirMatcher = createExcludeMatcher(config.indexing.excludeDirs);
     const fileMatcher = createExcludeMatcher(config.indexing.excludeFiles ?? []);
+    // Prefix check with a trailing separator so sibling dirs like
+    // `<storePath>2` are NOT ignored; case-insensitive on win32 so a
+    // differently-cased store path cannot cause self-triggering watch loops.
+    const storePrefix = storePath.endsWith(path.sep) ? storePath : storePath + path.sep;
+    const win32 = process.platform === "win32";
     return (watchedPath) => {
         const resolved = path.resolve(watchedPath);
-        if (resolved.startsWith(storePath))
+        const compareResolved = win32 ? resolved.toLowerCase() : resolved;
+        const compareStorePrefix = win32 ? storePrefix.toLowerCase() : storePrefix;
+        if (resolved === storePath || compareResolved.startsWith(compareStorePrefix))
             return true;
         if (resolved === manifestPath)
             return true;

package/dist/indexer/worker.js

@@ -128,6 +128,21 @@ export async function prepareFile(file, cwd, previous, config, keywordIndex, des
                 },
             };
         }
+        // No chunks from non-empty content: file may genuinely be chunk-less.
+        // BUT if the content is empty and the file is unchanged (hash matches),
+        // this is the re-describe fast-path edge — keep the old index entry
+        // instead of deleting it (a delete would wipe previously-indexed chunks
+        // just because we lacked content to re-chunk).
+        if (previous && previous.hash === file.hash && file.content.trim().length === 0) {
+            return {
+                normalizedPath: file.normalizedPath, hash: file.hash, fileLabel,
+                isModified: false,
+                earlyResult: {
+                    normalizedPath: file.normalizedPath, hash: file.hash, chunkCount: previous.chunkCount, fileLabel,
+                    isNew: false, isModified: false, isUnchanged: true, isEmpty: false, isTooSmall: false, isRemoved: false, hadChunks: previous.chunkCount > 0,
+                },
+            };
+        }
         return {
             normalizedPath: file.normalizedPath, hash: file.hash, fileLabel,
             isModified: false,
@@ -138,6 +153,12 @@ export async function prepareFile(file, cwd, previous, config, keywordIndex, des
         };
     }
     logger.debug(`  ${fileLabel}: ${chunks.length} chunks produced`);
+    // Remove stale keyword entries for a previously-indexed revision of this
+    // file (new UUIDs are generated for every chunk) so hybrid search never
+    // surfaces old content and the persisted index stops growing unboundedly.
+    if (previous) {
+        keywordIndex?.removeByFilePath(file.normalizedPath);
+    }
     keywordIndex?.addChunks(chunks);
     const docPrefix = config.embedding.documentPrefix ?? "";
     const relPath = path.relative(cwd, file.filePath).replace(/\\/g, "/");

package/dist/mcp/cli.js

@@ -16,6 +16,10 @@ export async function runMcpServer(options) {
     }
     process.on("SIGINT", shutdown);
     process.on("SIGTERM", shutdown);
+    // If the parent MCP client disconnects, stdin closes — exit instead of
+    // becoming a zombie that holds the store open forever.
+    process.stdin.on("end", shutdown);
+    process.stdin.on("close", shutdown);
     await new Promise(() => { });
 }
 //# sourceMappingURL=cli.js.map

package/dist/mcp/handlers.js

@@ -8,7 +8,7 @@ import { optimizeContext, DEFAULT_CONTEXT_OPTIMIZATION } from "../retriever/cont
 import { Parser } from "web-tree-sitter";
 import { initParser, loadLanguage, walkTree } from "../chunker/grammar.js";
 import { readFileSync } from "node:fs";
-import { resolve, isAbsolute, relative } from "node:path";
+import { resolve, isAbsolute, relative, sep as pathSep } from "node:path";
 /**
  * Resolve a user-supplied file path against the worktree root, refusing to
  * escape the worktree. Absolute paths are accepted only if they already reside
@@ -23,7 +23,9 @@ export function resolveFilePath(filePath, worktree) {
     const rel = relative(root, candidate);
     if (rel === "")
         return root;
-    if (rel.startsWith("..") || isAbsolute(rel)) {
+    // ".." or "../..." escapes; a sibling literally named "..foo" must NOT be
+    // rejected. isAbsolute(rel) covers cross-drive paths on Windows.
+    if (rel === ".." || rel.startsWith(`..${pathSep}`) || isAbsolute(rel)) {
         throw new Error(`Path "${filePath}" escapes worktree root "${root}" — access denied.`);
     }
     return candidate;
@@ -308,7 +310,10 @@ export async function handleFindUsages(params, embedder, store, cfg, keywordInde
         }
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
-            const lineNum = i + 1;
+            // tree-sitter line numbers are absolute file lines (startLine + offset),
+            // NOT chunk-relative — chunk-relative numbers were wrong for every
+            // chunk not starting at line 1 and broke the definition skip.
+            const lineNum = m.startLine + i;
             if (definitionLine !== undefined && lineNum === definitionLine)
                 continue;
             const symbolPattern = new RegExp(`\\b${escapeRegex(symbolName)}\\b`);
@@ -323,7 +328,12 @@ export async function handleFindUsages(params, embedder, store, cfg, keywordInde
                 fileGroups.set(m.filePath, group);
             }
             if (!group.usages.some((g) => g.line === lineNum)) {
-                group.usages.push({ line: lineNum, content: line.trimEnd(), context: contextLines });
+                group.usages.push({
+                    line: lineNum,
+                    content: line.trimEnd(),
+                    context: contextLines,
+                    matchedIndex: i - ctxStart,
+                });
             }
         }
     }
@@ -346,7 +356,8 @@ export async function handleFindUsages(params, embedder, store, cfg, keywordInde
         formattedLines.push("|------|------|");
         for (const usage of group.usages) {
             const ctx = usage.context;
-            const codeLine = ctx[Math.min(2, ctx.length - 1)] ?? usage.content;
+            // Show the actual matched line (not an arbitrary middle context line)
+            const codeLine = ctx[usage.matchedIndex] ?? usage.content;
             const escaped = codeLine.length > 100 ? codeLine.slice(0, 97) + "..." : codeLine;
             formattedLines.push(`| ${usage.line} | \`${escaped}\` |`);
             allMatches.push({ ...usage, filePath, language: group.language });

package/dist/mcp/server.js

@@ -97,6 +97,9 @@ export async function createMcpServer(options) {
             await server.close();
             await ctx.store.close();
             ctx.keywordIndex.close();
+            // Release keep-alive sockets held by the embedder/description providers
+            const { destroyAllPooledConnections } = await import("../embedder/http.js");
+            destroyAllPooledConnections();
         },
     };
 }

package/dist/opencode/create-read-tool.js

@@ -59,7 +59,11 @@ export function createRagReadTool(options) {
                         let rawResults;
                         if (sessionID && sessionRetrievalCache) {
                             const cached = sessionRetrievalCache.get(sessionID);
-                            if (cached && cached.messageText === messageText) {
+                            // The cache key must include the FILE and line range: without
+                            // them, the first read of a message reused its retrieval results
+                            // for every later read of a DIFFERENT file in the same message.
+                            const cacheKey = `${messageText}::${resolvedPath}::${normalized.startLine ?? ""}-${normalized.endLine ?? ""}`;
+                            if (cached && cached.messageText === cacheKey) {
                                 rawResults = cached.rawResults;
                             }
                             else {
@@ -71,7 +75,7 @@ export function createRagReadTool(options) {
                                     if (oldest !== undefined)
                                         sessionRetrievalCache.delete(oldest);
                                 }
-                                sessionRetrievalCache.set(sessionID, { messageText, rawResults });
+                                sessionRetrievalCache.set(sessionID, { messageText: cacheKey, rawResults });
                             }
                         }
                         else {
@@ -121,9 +125,16 @@ export function createRagReadTool(options) {
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
+                const code = err?.code;
+                // Distinguish path problems (ENOENT / outside workspace) from RAG
+                // retrieval failures — "OpenCodeRAG retrieval failed" was misleading
+                // for a simple missing file.
+                const isPathProblem = code === "ENOENT" || code === "EACCES" || /ENOENT|outside the workspace|does not exist/i.test(message);
                 return {
                     title: "Read",
-                    output: retrievalErrorMessage(message),
+                    output: isPathProblem
+                        ? `Could not read file: ${message}`
+                        : retrievalErrorMessage(message),
                     metadata: {
                         tool: "read",
                         filePath: resolvedPath,

package/dist/opencode/tool-args.js

@@ -2,6 +2,7 @@
  * @fileoverview Normalizes and validates read tool arguments, and resolves file paths relative to the workspace root.
  */
 import path from "node:path";
+import { realpathSync } from "node:fs";
 /**
  * Normalize raw read tool arguments into a consistent internal shape.
  *
@@ -58,10 +59,31 @@ export function resolveWorkspacePath(worktree, inputPath) {
         : path.resolve(worktree, inputPath);
     const normalizedWorktree = path.resolve(worktree);
     const normalizedResolved = path.resolve(resolved);
-    if (!normalizedResolved.startsWith(normalizedWorktree + path.sep) &&
+    // Case-insensitive on win32: an absolute path with different casing must
+    // not be falsely rejected as "outside the workspace".
+    const cmp = (p) => (process.platform === "win32" ? p.toLowerCase() : p);
+    if (!cmp(normalizedResolved).startsWith(cmp(normalizedWorktree) + path.sep) &&
         normalizedResolved !== normalizedWorktree) {
         throw new Error(`read path "${inputPath}" resolves outside the workspace "${normalizedWorktree}"`);
     }
+    // Resolve symlinks/junctions: a link INSIDE the workspace pointing outside
+    // must not let the agent read arbitrary files (node_modules junctions are
+    // common on Windows). realpath failure (e.g. missing file) falls back to
+    // the lexical check above — the read itself will fail with ENOENT.
+    try {
+        const realResolved = realpathSync(normalizedResolved);
+        const realWorktree = realpathSync(normalizedWorktree);
+        if (!cmp(realResolved).startsWith(cmp(realWorktree) + path.sep) &&
+            realResolved !== realWorktree) {
+            throw new Error(`read path "${inputPath}" resolves outside the workspace "${normalizedWorktree}" (via symlink "${realResolved}")`);
+        }
+    }
+    catch (err) {
+        if (err instanceof Error && /outside the workspace/.test(err.message)) {
+            throw err;
+        }
+        // otherwise: realpath unavailable — keep the lexical result
+    }
     return toForwardSlash(normalizedResolved);
 }
 /**

package/dist/plugin.js

@@ -18,7 +18,7 @@ import { createBackgroundIndexer } from "./watcher.js";
 import { createRagReadTool } from "./opencode/create-read-tool.js";
 import { createFileSkeletonTool, createFindUsagesTool, createDescribeImageTool, createRecallQuirksTool, createAddQuirkTool, createUpdateQuirkTool, createDeleteQuirkTool, } from "./opencode/tools.js";
 import { resolveApiKey } from "./core/resolve-api-key.js";
-import { consumePendingRagInjection } from "./core/rag-injection-flag.js";
+import { consumePendingRagInjection, peekPendingRagInjection } from "./core/rag-injection-flag.js";
 import { loadDocProgress, markSubdirectoryDocumented } from "./core/doc-progress.js";
 import { loadManifest } from "./core/manifest.js";
 import { createSessionLogger } from "./eval/session-logger.js";
@@ -31,17 +31,16 @@ import { autoCaptureQuirks } from "./quirks/auto-capture.js";
 import { buildSystemGuidanceLines } from "./opencode/system-guidance.js";
 import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { spawn, execSync } from "node:child_process";
-import { tmpdir } from "node:os";
 /** Maximum entries per session map before oldest entries are evicted. */
 const MAX_SESSION_MAP_SIZE = 50;
+/** Maximum tool results kept per session (for quirk extraction). */
+const MAX_SESSION_TOOL_RESULTS = 20;
 /** Cache of loaded RAG configurations keyed by workspace directory. */
 const configCache = new Map();
 /** Active background indexer instances keyed by workspace directory. */
 const backgroundIndexers = new Map();
-/** Active MCP server instances keyed by workspace directory. */
-const mcpServers = new Map();
+/** Active vector stores keyed by workspace directory — closed on reload/shutdown. */
+const ragStores = new Map();
 /** Pending update notifications keyed by workspace directory. */
 const pendingUpdateInfo = new Map();
 /** Workspace directories that have already been prompted about an update this session. */
@@ -50,7 +49,7 @@ const notifiedUpdateDirs = new Set();
 const pendingRestartNotice = new Map();
 /** Guard flag to prevent re-entrant shutdown. */
 let shutdownRegistered = false;
-/** Close all active background indexers and MCP servers, then destroy idle sockets. */
+/** Close all active background indexers and vector stores, then destroy idle sockets. */
 async function shutdownPluginResources() {
     for (const [dir, indexer] of backgroundIndexers) {
         try {
@@ -59,12 +58,12 @@ async function shutdownPluginResources() {
         catch { /* best-effort */ }
         backgroundIndexers.delete(dir);
     }
-    for (const [dir, server] of mcpServers) {
+    for (const [dir, store] of ragStores) {
         try {
-            await server.close();
+            await store.close();
         }
         catch { /* best-effort */ }
-        mcpServers.delete(dir);
+        ragStores.delete(dir);
     }
     configCache.clear();
     pendingUpdateInfo.clear();
@@ -766,7 +765,10 @@ export function createRagHooks(options) {
             try {
                 const results = sessionToolResults.get(input.sessionID) ?? [];
                 results.push({ tool: input.tool, output: output.output ?? "" });
-                boundedSet(sessionToolResults, input.sessionID, results, MAX_SESSION_MAP_SIZE);
+                // Cap the per-session list — long sessions accumulate full tool
+                // outputs; only the recent entries matter for quirk extraction.
+                const capped = results.length > MAX_SESSION_TOOL_RESULTS ? results.slice(-MAX_SESSION_TOOL_RESULTS) : results;
+                boundedSet(sessionToolResults, input.sessionID, capped, MAX_SESSION_MAP_SIZE);
             }
             catch {
                 // Non-critical — must never throw
@@ -825,9 +827,17 @@ export function createRagHooks(options) {
                         if (query.length > 0) {
                             const quirkDeps = { embedder, store, keywordIndex: keywordIndex, cfg: getEffectiveCfg(), storePath: options.storePath };
                             const budgetMs = memCfg.autoInjectLatencyBudgetMs ?? 2000;
+                            let timer;
                             let quirkResults = await Promise.race([
-                                recallQuirks(quirkDeps, query, { topK: memCfg.autoInjectTopK ?? 2, minScore: memCfg.autoInjectMinScore }),
-                                new Promise((resolve) => setTimeout(() => resolve([]), budgetMs)),
+                                recallQuirks(quirkDeps, query, { topK: memCfg.autoInjectTopK ?? 2, minScore: memCfg.autoInjectMinScore })
+                                    .then((r) => {
+                                    if (timer)
+                                        clearTimeout(timer);
+                                    return r;
+                                }),
+                                new Promise((resolve) => {
+                                    timer = setTimeout(() => resolve([]), budgetMs);
+                                }),
                             ]);
                             // Dedup: skip quirks already injected into this session
                             const injectedSet = getOrCreateSessionSet(sessionInjectedQuirks, sessionId, MAX_SESSION_MAP_SIZE);
@@ -894,8 +904,8 @@ export function createRagHooks(options) {
                         }
                     }
                 }
-                sessionPrevUserReq.set(input.sessionID, text);
-                sessionToolResults.set(input.sessionID, []);
+                boundedSet(sessionPrevUserReq, input.sessionID, text, MAX_SESSION_MAP_SIZE);
+                boundedSet(sessionToolResults, input.sessionID, [], MAX_SESSION_MAP_SIZE);
                 boundedSet(sessionLastMessage, input.sessionID, text, MAX_SESSION_MAP_SIZE);
                 // Handle /doc slash command
                 if (text.startsWith("/doc")) {
@@ -1123,9 +1133,17 @@ export function createRagHooks(options) {
                             // Use the stricter recallMinScore for user-prompt injection
                             // (system prompt injection uses the lower autoInjectMinScore)
                             const minScore = quirkMemoryCfg.recallMinScore ?? 0.72;
+                            let timer;
                             let quirkResults = await Promise.race([
-                                recallQuirks(quirkDeps, quirkQuery, { topK: quirkMemoryCfg.autoInjectTopK ?? 2, minScore }),
-                                new Promise((resolve) => setTimeout(() => resolve([]), budgetMs)),
+                                recallQuirks(quirkDeps, quirkQuery, { topK: quirkMemoryCfg.autoInjectTopK ?? 2, minScore })
+                                    .then((r) => {
+                                    if (timer)
+                                        clearTimeout(timer);
+                                    return r;
+                                }),
+                                new Promise((resolve) => {
+                                    timer = setTimeout(() => resolve([]), budgetMs);
+                                }),
                             ]);
                             // Dedup: skip quirks already injected into this session
                             const injectedSet = getOrCreateSessionSet(sessionInjectedQuirks, input.sessionID, MAX_SESSION_MAP_SIZE);
@@ -1168,15 +1186,19 @@ export function createRagHooks(options) {
                     }
                 }
                 // Handle hotkey-triggered RAG injection (Ctrl+Enter / Ctrl+Alt+Enter)
-                const pendingInjection = consumePendingRagInjection(options.storePath);
+                // Peek FIRST and only consume once we know the index is usable —
+                // otherwise the flag is dropped on an empty index and the hotkey
+                // press is silently lost.
+                const pendingInjection = peekPendingRagInjection(options.storePath);
                 if (pendingInjection) {
+                    const count = await store.count();
+                    if (count === 0)
+                        return;
+                    consumePendingRagInjection(options.storePath);
                     appendDebugLog(options.logFilePath, {
                         scope: "chat.message",
                         message: `pending injection: ${pendingInjection}`,
                     });
-                    const count = await store.count();
-                    if (count === 0)
-                        return;
                     const effectiveCfg = getEffectiveCfg();
                     const hybridCfg = effectiveCfg.retrieval.hybridSearch;
                     const retrievalStart = Date.now();
@@ -1274,122 +1296,12 @@ async function loadKeywordIndex(storePath, logFilePath, logLevel) {
         return new KeywordIndex(storePath);
     }
 }
-let _cachedNodeExecutable;
-/**
- * Resolve the path to the Node.js executable, caching the result.
- * Checks `process.execPath` first, then falls back to `where`/`which`.
- */
-function resolveNodeExecutable() {
-    if (_cachedNodeExecutable !== undefined)
-        return _cachedNodeExecutable;
-    const execPath = process.execPath;
-    const basename = path.basename(execPath).toLowerCase();
-    if (basename === "node" || basename === "node.exe") {
-        _cachedNodeExecutable = execPath;
-        return _cachedNodeExecutable;
-    }
-    const tryCmd = (cmd) => {
-        try {
-            const result = execSync(cmd, { encoding: "utf-8", timeout: 5000, stdio: ["pipe", "pipe", "pipe"] }).trim();
-            return result.split("\n")[0]?.trim() || null;
-        }
-        catch {
-            return null;
-        }
-    };
-    const found = process.platform === "win32"
-        ? tryCmd("where node")
-        : tryCmd("which node");
-    _cachedNodeExecutable = found;
-    return _cachedNodeExecutable;
-}
-/**
- * Resolve the MCP CLI entry point script path.
- * Checks `dist/cli.js` first, then falls back to `src/cli.ts`.
- */
-function resolveMcpCliEntry() {
-    const selfDir = path.dirname(fileURLToPath(import.meta.url));
-    const packageRoot = path.resolve(selfDir, "..");
-    const distCli = path.join(packageRoot, "dist", "cli.js");
-    if (existsSync(distCli))
-        return distCli;
-    const srcCli = path.join(packageRoot, "src", "cli.ts");
-    if (existsSync(srcCli))
-        return srcCli;
-    return null;
-}
-/**
- * Start an MCP server process for the given workspace directory.
- * Spawns the CLI in MCP mode as a child process and wires stdout/stderr
- * to the debug log. Returns a handle for graceful shutdown.
- */
-function startMcpServerProcess(cwd, logFilePath, logLevel) {
-    const cliEntry = resolveMcpCliEntry();
-    if (!cliEntry) {
-        appendDebugLog(logFilePath, {
-            scope: "mcp",
-            message: "Could not resolve MCP CLI entry point; skipping autostart",
-        }, logLevel);
-        return { close: async () => { } };
-    }
-    const nodeExec = resolveNodeExecutable();
-    if (!nodeExec) {
-        appendDebugLog(logFilePath, {
-            scope: "mcp",
-            message: "Could not resolve Node.js executable; skipping MCP autostart",
-        }, logLevel);
-        return { close: async () => { } };
-    }
-    const args = cliEntry.endsWith(".ts")
-        ? ["--import", "tsx", cliEntry, "mcp"]
-        : [cliEntry, "mcp"];
-    appendDebugLog(logFilePath, {
-        scope: "mcp",
-        message: `Starting MCP server: ${nodeExec} ${args.join(" ")}`,
-    }, logLevel);
-    const child = spawn(nodeExec, args, {
-        cwd,
-        stdio: "pipe",
-        detached: false,
-    });
-    child.stdout?.on("data", (chunk) => {
-        appendDebugLog(logFilePath, {
-            scope: "mcp",
-            message: `stdout: ${chunk.toString().trim()}`,
-        }, logLevel);
-    });
-    child.stderr?.on("data", (chunk) => {
-        appendDebugLog(logFilePath, {
-            scope: "mcp",
-            message: `stderr: ${chunk.toString().trim()}`,
-        }, logLevel);
-    });
-    child.on("error", (err) => {
-        appendDebugLog(logFilePath, {
-            scope: "mcp",
-            message: "MCP server process error",
-            error: err,
-        }, logLevel);
-    });
-    child.on("exit", (code, signal) => {
-        appendDebugLog(logFilePath, {
-            scope: "mcp",
-            message: `MCP server exited (code=${code}, signal=${signal})`,
-        });
-        mcpServers.delete(cwd);
-    });
-    return {
-        close: async () => {
-            if (child.exitCode !== null || child.killed)
-                return;
-            appendDebugLog(logFilePath, {
-                scope: "mcp",
-                message: "Shutting down MCP server",
-            });
-            child.kill("SIGTERM");
-        },
-    };
-}
+// NOTE: There is deliberately NO autostart of an MCP child process here.
+// A stdio MCP server can only be reached by the client that spawns it —
+// a plugin-spawned child with an unwired stdin would sit idle forever,
+// holding its own LanceDB connection (and locking the store directory on
+// Windows). External MCP clients must run `opencode-rag mcp` themselves;
+// the plugin's agent tools run in-process regardless.
 /**
  * OpenCodeRAG plugin factory — invoked by OpenCode's plugin system for each workspace.
  *
@@ -1444,20 +1356,22 @@ export const ragPlugin = async (input, _options) => {
         }
         backgroundIndexers.delete(input.directory);
     }
-    // Close existing MCP server for this directory if one exists (e.g. on plugin reload)
-    const existingMcp = mcpServers.get(input.directory);
-    if (existingMcp) {
+    // Close the previous plugin instance's vector store — without this every
+    // reload leaks a LanceDB connection (and on Windows holds the store
+    // directory open, breaking the atomic swap on `index --force`).
+    const existingStore = ragStores.get(input.directory);
+    if (existingStore) {
         try {
-            await existingMcp.close();
+            await existingStore.close();
         }
         catch (err) {
             appendDebugLog(logFilePath, {
                 scope: "plugin",
-                message: "Failed to close existing MCP server",
+                message: "Failed to close existing vector store",
                 error: err,
             }, logLevel);
         }
-        mcpServers.delete(input.directory);
+        ragStores.delete(input.directory);
     }
     // Clean up stale config cache and pending update info for this directory
     configCache.delete(input.directory);
@@ -1508,6 +1422,7 @@ export const ragPlugin = async (input, _options) => {
         }
     }
     const store = createVectorStore(effectiveCfg, storePath, vectorDimension);
+    ragStores.set(input.directory, store);
     // Load or create keyword index for hybrid search
     const keywordIndex = await loadKeywordIndex(storePath, logFilePath, logLevel);
     // Create description provider (enabled by default)
@@ -1555,15 +1470,14 @@ export const ragPlugin = async (input, _options) => {
             catch { /* ignore */ }
         }
     }
-    // Auto-start standalone MCP server if enabled (default: off). Agent tools
-    // (search_semantic, get_file_skeleton, find_usages, describe_image) and the
-    // chat.message hook run in-process regardless. Enable only when an external
-    // MCP client connects to `opencode-rag mcp`.
-    const mcpCfg = effectiveCfg.mcp ?? { enabled: false };
-    const isTempDir = path.resolve(input.directory).startsWith(tmpdir());
-    if (mcpCfg.enabled && !isTempDir) {
-        const mcpInstance = startMcpServerProcess(input.directory, logFilePath, logLevel);
-        mcpServers.set(input.directory, mcpInstance);
+    // NOTE: no MCP child-process autostart — a stdio MCP server is only
+    // reachable by the client that spawns it. External MCP clients run
+    // `opencode-rag mcp` themselves; agent tools run in-process regardless.
+    if (effectiveCfg.mcp?.enabled) {
+        appendDebugLog(logFilePath, {
+            scope: "mcp",
+            message: "mcp.enabled is set, but the plugin does not autostart a child server — run `opencode-rag mcp` from your MCP client",
+        }, logLevel);
     }
     // Auto-update check (non-blocking, best-effort). On by default; can be
     // disabled via `autoUpdate.enabled: false` in opencode-rag.json. When a newer

package/dist/quirks/auto-capture.js

@@ -21,6 +21,7 @@ function buildExchangeText(exchanges) {
     }
     return lines.join("\n");
 }
+const VALID_QUIRK_TYPES = new Set(["gotcha", "preference", "decision", "environment-constraint"]);
 function parseExtractionOutput(text) {
     const results = [];
     for (const line of text.split("\n")) {
@@ -34,6 +35,10 @@ function parseExtractionOutput(text) {
         const content = trimmed.slice(pipeIdx + 1).trim();
         if (!quirkType || !content || content.length > 200)
             continue;
+        // An LLM emitting a garbage type would otherwise pollute recall filters —
+        // skip unknown types (or default them to "gotcha").
+        if (!VALID_QUIRK_TYPES.has(quirkType))
+            continue;
         results.push({ quirkType, content });
     }
     return results;

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

@@ -44,7 +44,7 @@ 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").
+ * 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