opencode-rag-plugin 1.18.1 → 1.19.0

package/ReadMe.md

@@ -128,7 +128,7 @@ See [Plugin documentation](doc/plugin.md#6-wiki-mode--slash-command-wiki) for th
 
 ## Quirk Memory
 
-OpenCodeRAG gives your agent **persistent, cross-session memory** of non-obvious facts — gotchas, preferences, decisions, and environment constraints — that it can recall and extend over time. Quirks are embedded and stored in the same vector store as your code, then recalled via semantic search whenever they're relevant. This lets the agent avoid repeating mistakes and accumulate project knowledge across sessions.
+OpenCodeRAG gives your agent **persistent, cross-session memory** of non-obvious facts — gotchas, preferences, decisions, and environment constraints — that it can recall and extend over time. Quirks are embedded and stored in the same vector store as your code, then **automatically injected into the agent's context on every user message** when their relevance score exceeds the configured threshold. Injection uses two thresholds: the stricter `recallMinScore` (0.72) for the user message context, and the more permissive `autoInjectMinScore` (0.45) for the system prompt. This lets the agent avoid repeating mistakes and accumulate project knowledge across sessions without manual recall.
 
 **Enabled by default.** Turn it on/off in `opencode-rag.json`:
 
@@ -138,8 +138,11 @@ OpenCodeRAG gives your agent **persistent, cross-session memory** of non-obvious
     "enabled": true,
     "autoInject": true,
     "minConfidence": 0.5,
-    "recallMinScore": 0.3,
-    "decay": { "enabled": true, "halfLifeDays": 30 }
+    "recallMinScore": 0.8,
+    "autoInjectMinScore": 0.6,
+    "autoInjectTopK": 2,
+    "autoInjectLatencyBudgetMs": 2000,
+    "decay": { "enabled": false, "halfLifeDays": 30 }
   }
 }
 ```
@@ -163,7 +166,7 @@ opencode-rag quirk test "npm needs --legacy-peer-deps"
 #   99% confidence
 ```
 
-When `memory.autoInject` is `true`, relevant quirks are automatically injected into the prompt during retrieval (via the `chat.message` hook). Every `add_quirk` is vetted by an immutable trust monitor that rejects destructive patterns (e.g. `rm -rf`, `force push`, `bypass security`). See [Plugin documentation](doc/plugin.md#9-quirk-memory-experiential-memory) and [CLI Reference: `quirk`](doc/cli.md#quirk).
+When `memory.autoInject` is `true`, the plugin checks for relevant quirks on every user message using the combined agent-response + user-query as the search query. Quirks are only injected when their relevance score exceeds the threshold — `recallMinScore` (default 0.72) for the user message, `autoInjectMinScore` (default 0.45) for the system prompt. A latency budget (`autoInjectLatencyBudgetMs`, default 2000ms) prevents slow embedders from blocking message processing. To avoid polluting the context window, each quirk is injected **at most once per session** — once recalled, it is filtered out from all subsequent auto-injections. Every `add_quirk` is vetted by an immutable trust monitor that rejects destructive patterns (e.g. `rm -rf`, `force push`, `bypass security`). See [Plugin documentation](doc/plugin.md#9-quirk-memory-experiential-memory) and [CLI Reference: `quirk`](doc/cli.md#quirk).
 
 ## MCP Server (Optional)
 

package/dist/cli/commands/query.js

@@ -74,7 +74,7 @@ export function registerQueryCommand(program) {
                         logCliInfo(logFilePath, "query", `  ${c.label("  Matched:")} ${c.lang(r.explanation.matchedTerms.join(", "))}`);
                     }
                 }
-                logCliInfo(logFilePath, "query", `  ${pc.dim(r.chunk.content.slice(0, 200).replace(/\n/g, "\n  "))}`);
+                logCliInfo(logFilePath, "query", `  ${pc.dim(r.chunk.content.replace(/\n/g, "\n  "))}`);
             }
             await cleanupContext(ctx);
         }

package/dist/cli/commands/quirk.js

@@ -51,7 +51,7 @@ export function registerQuirkCommand(program) {
                 const badge = q.quirkType ? `[${q.quirkType}] ` : "";
                 const tags = q.tags.length > 0 ? ` (${q.tags.join(", ")})` : "";
                 const date = q.lastObserved ? new Date(q.lastObserved).toLocaleDateString() : "";
-                logCliInfo(ctx.logFilePath, "quirk list", `  ${c.value(badge)}${c.file(q.content.slice(0, 120))}${c.dim(tags)} ${c.dim(date)}`);
+                logCliInfo(ctx.logFilePath, "quirk list", `  ${c.value(badge)}${c.file(q.content)}${c.dim(tags)} ${c.dim(date)}`);
             }
             await cleanupContext(ctx);
         }
@@ -119,7 +119,7 @@ export function registerQuirkCommand(program) {
                     const badge = r.chunk.metadata.quirkType ? `[${r.chunk.metadata.quirkType}] ` : "";
                     const tags = r.chunk.metadata.tags?.length ? ` (${r.chunk.metadata.tags.join(", ")})` : "";
                     const confidence = r.chunk.metadata.confidence ? `${(r.chunk.metadata.confidence * 100).toFixed(0)}% confidence` : "";
-                    logCliInfo(ctx.logFilePath, "quirk test", `  ${c.value(badge)}${c.file(r.chunk.content.slice(0, 120))}${c.dim(tags)}`);
+                    logCliInfo(ctx.logFilePath, "quirk test", `  ${c.value(badge)}${c.file(r.chunk.content)}${c.dim(tags)}`);
                     logCliInfo(ctx.logFilePath, "quirk test", `  ${c.dim(confidence)}`);
                     logCliInfo(ctx.logFilePath, "quirk test", "");
                 }

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

@@ -131,6 +131,19 @@ export interface MemoryConfig {
     minConfidence: number;
     /** Minimum query-relevance score (0-1) for a quirk to be recalled. */
     recallMinScore: number;
+    /** Minimum relevance score for auto-injected quirks (lower than recallMinScore for manual calls). */
+    autoInjectMinScore: number;
+    /** Maximum latency budget (ms) for auto-inject quirk recall. If exceeded, injection is skipped. */
+    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. */
@@ -212,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",
@@ -258,6 +269,10 @@ export const DEFAULT_CONFIG = {
         autoInject: false,
         minConfidence: 0.5,
         recallMinScore: 0.72,
+        autoInjectMinScore: 0.6,
+        autoInjectLatencyBudgetMs: 2000,
+        autoInjectTopK: 2,
+        autoInjectMinTokenOverlap: 1,
         passiveCapture: false,
         promptEnforcement: true,
         sessionEndExtraction: true,
@@ -350,6 +365,19 @@ export function validateConfig(config) {
         if (r < 0 || r > 1)
             warnings.push("memory.recallMinScore must be between 0 and 1");
     }
+    if (config.memory?.autoInjectMinScore != null) {
+        const r = config.memory.autoInjectMinScore;
+        if (r < 0 || r > 1)
+            warnings.push("memory.autoInjectMinScore must be between 0 and 1");
+    }
+    if (config.memory?.autoInjectLatencyBudgetMs != null) {
+        const r = config.memory.autoInjectLatencyBudgetMs;
+        if (r < 0)
+            warnings.push("memory.autoInjectLatencyBudgetMs must be >= 0");
+    }
+    if (config.memory?.autoInjectTopK != null && config.memory.autoInjectTopK < 1) {
+        warnings.push("memory.autoInjectTopK must be >= 1");
+    }
     if (config.openCode.maxContextChunks <= 0) {
         warnings.push("openCode.maxContextChunks must be > 0");
     }

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/core/runtime-overrides.d.ts

@@ -48,6 +48,9 @@ export interface RuntimeOverrides {
         sessionEndExtraction?: boolean;
         autoCaptureMaxPerTurn?: number;
         autoCaptureDedupThreshold?: number;
+        autoInjectMinScore?: number;
+        autoInjectLatencyBudgetMs?: number;
+        autoInjectTopK?: number;
     };
     tui?: {
         fileListKeybinding?: string;
@@ -57,6 +60,6 @@ export interface RuntimeOverrides {
 /** Load runtime overrides from the store directory. Returns empty object if none exist. */
 export declare function loadRuntimeOverrides(storePath: string): RuntimeOverrides;
 /** Save a single runtime override value at a dotted path. Creates intermediate objects as needed. */
-export declare function saveRuntimeOverride(storePath: string, path: string[], value: boolean | number | string): void;
+export declare function saveRuntimeOverride(storePath: string, path: string[], value: boolean | number | string | Record<string, unknown>): void;
 /** Deep-merge runtime overrides into a config object. Returns a new object without mutating the original. */
 export declare function applyRuntimeOverrides(cfg: RagConfig, overrides: RuntimeOverrides): RagConfig;

package/dist/core/runtime-overrides.js

@@ -136,6 +136,12 @@ export function applyRuntimeOverrides(cfg, overrides) {
             m.autoCaptureMaxPerTurn = overrides.memory.autoCaptureMaxPerTurn;
         if (overrides.memory.autoCaptureDedupThreshold !== undefined)
             m.autoCaptureDedupThreshold = overrides.memory.autoCaptureDedupThreshold;
+        if (overrides.memory.autoInjectMinScore !== undefined)
+            m.autoInjectMinScore = overrides.memory.autoInjectMinScore;
+        if (overrides.memory.autoInjectLatencyBudgetMs !== undefined)
+            m.autoInjectLatencyBudgetMs = overrides.memory.autoInjectLatencyBudgetMs;
+        if (overrides.memory.autoInjectTopK !== undefined)
+            m.autoInjectTopK = overrides.memory.autoInjectTopK;
     }
     if (overrides.tui) {
         merged.tui = {

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) {

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";
@@ -95,6 +95,15 @@ function boundedSet(map, key, value, maxSize) {
     }
     map.set(key, value);
 }
+/** Get or create a Set for a session key in the given Map, bounded by maxSize. */
+function getOrCreateSessionSet(map, key, maxSize) {
+    let set = map.get(key);
+    if (!set) {
+        set = new Set();
+        boundedSet(map, key, set, maxSize);
+    }
+    return set;
+}
 /** Name of the semantic search tool as exposed to the LLM. */
 const CONTEXT_TOOL_NAME = "search_semantic";
 /** Marker string injected into context output to identify RAG-sourced content. */
@@ -440,6 +449,8 @@ export function createRagHooks(options) {
     const sessionPrevUserReq = new Map();
     const sessionToolResults = new Map();
     const sessionTranscript = new Map();
+    // Track quirk IDs already injected per session to avoid duplicate injection
+    const sessionInjectedQuirks = new Map();
     // Evaluation session logger — captures OpenCode events for analysis
     const sessionLogger = createSessionLogger(options.storePath);
     appendDebugLog(options.logFilePath, {
@@ -767,6 +778,49 @@ export function createRagHooks(options) {
             if (wikiMode?.enabled && wikiMode.systemPrompt) {
                 output.system.unshift(wikiMode.systemPrompt);
             }
+            // Inject relevant quirks into system prompt when memory.autoInject is enabled
+            try {
+                const sessionId = _input?.sessionID;
+                if (sessionId) {
+                    const memCfg = getEffectiveCfg().memory;
+                    if (memCfg?.enabled && memCfg?.autoInject) {
+                        const assistantText = sessionAssistantText.get(sessionId) ?? "";
+                        const userReq = sessionPrevUserReq.get(sessionId) ?? "";
+                        const query = [assistantText, userReq].filter((t) => t.length > 0).join("\n");
+                        if (query.length > 0) {
+                            const quirkDeps = { embedder, store, keywordIndex: keywordIndex, cfg: getEffectiveCfg(), storePath: options.storePath };
+                            const budgetMs = memCfg.autoInjectLatencyBudgetMs ?? 2000;
+                            let quirkResults = await Promise.race([
+                                recallQuirks(quirkDeps, query, { topK: memCfg.autoInjectTopK ?? 2, minScore: memCfg.autoInjectMinScore }),
+                                new Promise((resolve) => setTimeout(() => resolve([]), budgetMs)),
+                            ]);
+                            // 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) {
+                                    const m = qr.chunk.metadata;
+                                    const badge = m.quirkType ? `[${m.quirkType}] ` : "";
+                                    lines.push(`- ${badge}${qr.chunk.content}`);
+                                    injectedSet.add(qr.chunk.id);
+                                }
+                                output.system.unshift(lines.join("\n"));
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // Non-critical — must never throw
+            }
         },
         async "chat.message"(input, output) {
             try {
@@ -996,7 +1050,7 @@ export function createRagHooks(options) {
                             for (const q of quirks) {
                                 const badge = q.quirkType ? `[\`${q.quirkType}\`] ` : "";
                                 const tags = q.tags.length > 0 ? ` _(${q.tags.join(", ")})_` : "";
-                                lines.push(`- ${badge}${q.content.slice(0, 100)}${tags}  `);
+                                lines.push(`- ${badge}${q.content}${tags}  `);
                             }
                         }
                         const memCfg = getEffectiveCfg().memory;
@@ -1021,6 +1075,63 @@ export function createRagHooks(options) {
                     }
                     return;
                 }
+                // Always-on quirk injection when memory.autoInject is enabled
+                // (runs on every non-slash message, not just hotkey injection)
+                const quirkMemoryCfg = getEffectiveCfg().memory;
+                if (quirkMemoryCfg?.enabled && quirkMemoryCfg?.autoInject) {
+                    try {
+                        const assistantText = sessionAssistantText.get(input.sessionID) ?? "";
+                        const quirkQuery = [assistantText, text].filter((t) => t.length > 0).join("\n");
+                        if (quirkQuery.length > 0) {
+                            const quirkDeps = { embedder, store, keywordIndex: keywordIndex, cfg: getEffectiveCfg(), storePath: options.storePath };
+                            const budgetMs = quirkMemoryCfg.autoInjectLatencyBudgetMs ?? 2000;
+                            // Use the stricter recallMinScore for user-prompt injection
+                            // (system prompt injection uses the lower autoInjectMinScore)
+                            const minScore = quirkMemoryCfg.recallMinScore ?? 0.72;
+                            let quirkResults = await Promise.race([
+                                recallQuirks(quirkDeps, quirkQuery, { topK: quirkMemoryCfg.autoInjectTopK ?? 2, minScore }),
+                                new Promise((resolve) => setTimeout(() => resolve([]), budgetMs)),
+                            ]);
+                            // 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) {
+                                    const m = qr.chunk.metadata;
+                                    const badge = m.quirkType ? `[\`${m.quirkType}\`] ` : "";
+                                    quirkLines.push(`- ${badge}${qr.chunk.content}`);
+                                    injectedSet.add(qr.chunk.id);
+                                }
+                                const quirkBlock = quirkLines.join("\n");
+                                const parts = output?.parts ?? output?.message?.parts;
+                                if (Array.isArray(parts) && parts.length > 0) {
+                                    const first = parts[0];
+                                    if (typeof first.text === "string") {
+                                        parts[0] = { ...first, text: first.text + "\n\n" + quirkBlock };
+                                    }
+                                    const msgParts = output?.message?.parts;
+                                    if (Array.isArray(msgParts) && msgParts !== parts) {
+                                        const mfirst = msgParts[0];
+                                        if (typeof mfirst.text === "string") {
+                                            msgParts[0] = { ...mfirst, text: mfirst.text + "\n\n" + quirkBlock };
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // Non-critical — must never throw
+                    }
+                }
                 // Handle hotkey-triggered RAG injection (Ctrl+Enter / Ctrl+Alt+Enter)
                 const pendingInjection = consumePendingRagInjection(options.storePath);
                 if (pendingInjection) {
@@ -1077,40 +1188,6 @@ export function createRagHooks(options) {
                                 });
                             }
                         }
-                        // Auto-inject quirks when memory.autoInject is enabled
-                        const memoryCfg = effectiveCfg.memory;
-                        if (memoryCfg?.autoInject) {
-                            try {
-                                const quirkDeps = { embedder, store, keywordIndex: keywordIndex, cfg: effectiveCfg, storePath: options.storePath };
-                                const quirkResults = await recallQuirks(quirkDeps, searchQuery, { topK: 3 });
-                                if (quirkResults.length > 0) {
-                                    const quirkLines = ["", "---", "⚠ **Quirk memory**", ""];
-                                    for (const qr of quirkResults) {
-                                        const m = qr.chunk.metadata;
-                                        const badge = m.quirkType ? `[\`${m.quirkType}\`] ` : "";
-                                        quirkLines.push(`- ${badge}${qr.chunk.content.slice(0, 200)}`);
-                                    }
-                                    const quirkBlock = quirkLines.join("\n");
-                                    const parts = output?.parts ?? output?.message?.parts;
-                                    if (Array.isArray(parts) && parts.length > 0) {
-                                        const first = parts[0];
-                                        if (typeof first.text === "string") {
-                                            parts[0] = { ...first, text: first.text + "\n\n" + quirkBlock };
-                                        }
-                                        const msgParts = output?.message?.parts;
-                                        if (Array.isArray(msgParts) && msgParts !== parts) {
-                                            const mfirst = msgParts[0];
-                                            if (typeof mfirst.text === "string") {
-                                                msgParts[0] = { ...mfirst, text: mfirst.text + "\n\n" + quirkBlock };
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                            catch {
-                                // Non-critical — must never throw
-                            }
-                        }
                     }
                     appendDebugLog(options.logFilePath, {
                         scope: "chat.message",

package/dist/quirks/prompts.js

@@ -3,7 +3,7 @@ export const MEMORY_CAPTURE_SYSTEM_PROMPT = "You are a quirk-extraction assistan
     "Rules:\n" +
     "- Output exactly one line per quirk in the format: TYPE|content\n" +
     "- TYPE must be one of: gotcha, preference, decision, environment-constraint\n" +
-    "- content is a single short sentence (max 200 chars)\n" +
+    "- Keep content brief and to the point — one short sentence capturing the essential fact\n" +
     "- If no quirks are present, output exactly: NOTHING\n" +
     "- Do not include explanations, numbering, or markdown\n\n" +
     "Examples:\n" +