opencode-rag-plugin 1.18.1 → 1.18.2

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

@@ -131,6 +131,12 @@ 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;
     /** Automatically extract quirks from each completed agent turn. */
     passiveCapture: boolean;
     /** Upgrade the system-prompt nudge into a mandatory trigger. */

package/dist/core/config.js

@@ -258,6 +258,9 @@ export const DEFAULT_CONFIG = {
         autoInject: false,
         minConfidence: 0.5,
         recallMinScore: 0.72,
+        autoInjectMinScore: 0.6,
+        autoInjectLatencyBudgetMs: 2000,
+        autoInjectTopK: 2,
         passiveCapture: false,
         promptEnforcement: true,
         sessionEndExtraction: true,
@@ -350,6 +353,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/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/plugin.js

@@ -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,42 @@ 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));
+                            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 +1043,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 +1068,56 @@ 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));
+                            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 +1174,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" +

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

@@ -20,6 +20,8 @@ export declare function recallQuirks(deps: QuirkStoreDeps, query: string, option
     topK?: number;
     quirkType?: string;
     tags?: string[];
+    /** Override recallMinScore from config. Used by auto-inject for a lower threshold. */
+    minScore?: number;
 }): Promise<SearchResult[]>;
 /** Lint quirks for low confidence, staleness, duplicates, and orphan source refs. */
 export declare function lintQuirks(deps: QuirkStoreDeps): Promise<string[]>;

package/dist/quirks/quirk-store.js

@@ -146,13 +146,13 @@ export async function recallQuirks(deps, query, options) {
     if (options?.quirkType) {
         filter.languages = [options.quirkType];
     }
-    const recallMinScore = deps.cfg.memory?.recallMinScore ?? 0.72;
+    const recallMinScore = options?.minScore ?? deps.cfg.memory?.recallMinScore ?? 0.72;
     const raw = await retrieve(query, deps.embedder, deps.store, {
         topK: topK * 3,
         minScore: recallMinScore,
         keywordIndex: deps.keywordIndex,
         keywordWeight: deps.cfg.retrieval.hybridSearch?.keywordWeight,
-        hybridEnabled: false,
+        hybridEnabled: true,
         queryPrefix: deps.cfg.embedding.queryPrefix,
         filter,
     });
@@ -185,13 +185,13 @@ export async function lintQuirks(deps) {
     const cfg = deps.cfg.memory;
     for (const q of quirks) {
         if (q.confidence < (cfg?.minConfidence ?? 0.5)) {
-            issues.push(`Low confidence (${q.confidence}): "${q.content.slice(0, 60)}..." [${q.id}]`);
+            issues.push(`Low confidence (${q.confidence}): "${q.content}" [${q.id}]`);
         }
         if (cfg?.decay?.enabled && q.lastObserved) {
             const ageDays = (Date.now() - new Date(q.lastObserved).getTime()) / 86_400_000;
             const halfLife = cfg.decay.halfLifeDays;
             if (halfLife > 0 && ageDays > halfLife * 2) {
-                issues.push(`Stale (${Math.round(ageDays)}d old): "${q.content.slice(0, 60)}..." [${q.id}]`);
+                issues.push(`Stale (${Math.round(ageDays)}d old): "${q.content}" [${q.id}]`);
             }
         }
     }
@@ -200,7 +200,7 @@ export async function lintQuirks(deps) {
         for (let j = i + 1; j < quirks.length; j++) {
             const sim = lexicalSimilarity(quirks[i].content, quirks[j].content);
             if (sim > 0.85) {
-                issues.push(`Near-duplicate (${(sim * 100).toFixed(0)}% similar): "${quirks[i].content.slice(0, 50)}..." ↔ "${quirks[j].content.slice(0, 50)}..."`);
+                issues.push(`Near-duplicate (${(sim * 100).toFixed(0)}% similar): "${quirks[i].content}" ↔ "${quirks[j].content}"`);
             }
         }
     }

package/dist/tui.js

@@ -345,10 +345,16 @@ function buildSettingCategories(cfg, ro, providers) {
     const docModeRo = (ro.documentationMode ?? {});
     const wikiModeCfg = (cfg.wikiMode ?? {});
     const wikiModeRo = (ro.wikiMode ?? {});
+    const memoryCfg = (cfg.memory ?? {});
+    const memoryRo = (ro.memory ?? {});
     const embeddingCfg = (cfg.embedding ?? {});
     const embeddingRo = (ro.embedding ?? {});
     const tuiCfg = (cfg.tui ?? {});
     const tuiRo = (ro.tui ?? {});
+    const indexingCfg = (cfg.indexing ?? {});
+    const indexingRo = (ro.indexing ?? {});
+    const chunkingCfg = (cfg.chunking ?? {});
+    const chunkingRo = (ro.chunking ?? {});
     const modelOptions = providers ? buildModelOptions(providers) : undefined;
     function displayModel(roProvider, roModel, cfgProvider, cfgModel, defaultProvider, defaultModel) {
         const p = roProvider ?? cfgProvider ?? defaultProvider;
@@ -416,6 +422,31 @@ function buildSettingCategories(cfg, ro, providers) {
                 },
             ],
         },
+        {
+            id: "chunking",
+            label: "Chunking",
+            description: "Configure how files are split into chunks",
+            entries: [
+                {
+                    path: ["indexing", "chunkOverlap"],
+                    label: "Chunk overlap (lines)",
+                    type: "number",
+                    currentValue: indexingRo.chunkOverlap ?? indexingCfg.chunkOverlap ?? 0,
+                },
+                {
+                    path: ["indexing", "maxSvgSizeBytes"],
+                    label: "Max SVG size (bytes)",
+                    type: "number",
+                    currentValue: indexingRo.maxSvgSizeBytes ?? indexingCfg.maxSvgSizeBytes ?? 1_048_576,
+                },
+                {
+                    path: ["chunking", "nodeTypes"],
+                    label: "Node types (JSON)",
+                    type: "json",
+                    currentValue: chunkingRo.nodeTypes ?? chunkingCfg.nodeTypes ?? {},
+                },
+            ],
+        },
         {
             id: "embedding",
             label: "Embedding",
@@ -488,6 +519,67 @@ function buildSettingCategories(cfg, ro, providers) {
                 },
             ],
         },
+        {
+            id: "memory",
+            label: "Quirk Memory",
+            description: "Configure experiential memory — gotchas, preferences, decisions recalled across sessions",
+            entries: [
+                {
+                    path: ["memory", "enabled"],
+                    label: "Quirk memory enabled",
+                    type: "boolean",
+                    currentValue: memoryRo.enabled ?? memoryCfg.enabled ?? true,
+                },
+                {
+                    path: ["memory", "autoInject"],
+                    label: "Auto-inject quirks",
+                    type: "boolean",
+                    currentValue: memoryRo.autoInject ?? memoryCfg.autoInject ?? false,
+                },
+                {
+                    path: ["memory", "recallMinScore"],
+                    label: "User prompt min score",
+                    type: "number",
+                    currentValue: memoryRo.recallMinScore ?? memoryCfg.recallMinScore ?? 0.72,
+                },
+                {
+                    path: ["memory", "autoInjectMinScore"],
+                    label: "System prompt min score",
+                    type: "number",
+                    currentValue: memoryRo.autoInjectMinScore ?? memoryCfg.autoInjectMinScore ?? 0.6,
+                },
+                {
+                    path: ["memory", "autoInjectLatencyBudgetMs"],
+                    label: "Latency budget (ms)",
+                    type: "number",
+                    currentValue: memoryRo.autoInjectLatencyBudgetMs ?? memoryCfg.autoInjectLatencyBudgetMs ?? 2000,
+                },
+                {
+                    path: ["memory", "minConfidence"],
+                    label: "Min confidence",
+                    type: "number",
+                    currentValue: memoryRo.minConfidence ?? memoryCfg.minConfidence ?? 0.5,
+                },
+                {
+                    path: ["memory", "passiveCapture"],
+                    label: "Passive capture",
+                    type: "boolean",
+                    currentValue: memoryRo.passiveCapture ?? memoryCfg.passiveCapture ?? false,
+                },
+                {
+                    path: ["memory", "promptEnforcement"],
+                    label: "Prompt enforcement",
+                    type: "boolean",
+                    currentValue: memoryRo.promptEnforcement ?? memoryCfg.promptEnforcement ?? true,
+                },
+                {
+                    path: ["memory", "sessionEndExtraction"],
+                    label: "Session-end extraction",
+                    type: "boolean",
+                    currentValue: memoryRo.sessionEndExtraction ?? memoryCfg.sessionEndExtraction ?? true,
+                },
+            ],
+        },
         {
             id: "keybindings",
             label: "Keybindings",
@@ -564,7 +656,7 @@ async function openSettingsDialog(api) {
     function showSettingMenu(cat) {
         const options = [
             ...cat.entries.map((s) => ({
-                title: `${s.label}: ${s.type === "boolean" ? (s.currentValue ? "Yes" : "No") : String(s.currentValue)}`,
+                title: `${s.label}: ${s.type === "boolean" ? (s.currentValue ? "Yes" : "No") : s.type === "json" ? JSON.stringify(s.currentValue) : String(s.currentValue)}`,
                 value: s.path.join("."),
                 description: s.options ? "Select to open model picker" : (s.type === "boolean" ? "Select to toggle" : "Select to edit"),
             })),
@@ -594,6 +686,9 @@ async function openSettingsDialog(api) {
                         title: "Settings",
                         message: `${entry.label}: ${newVal ? "Yes" : "No"}`,
                     });
+                    if (entry.path[0] === "indexing" || entry.path[0] === "chunking") {
+                        api.ui.toast({ variant: "warning", title: "Settings", message: "Chunking changed. Re-index required." });
+                    }
                     entry.currentValue = newVal;
                     showSettingMenu(cat);
                 }
@@ -612,6 +707,9 @@ async function openSettingsDialog(api) {
                                     title: "Settings",
                                     message: `${entry.label}: ${num}`,
                                 });
+                                if (entry.path[0] === "indexing" || entry.path[0] === "chunking") {
+                                    api.ui.toast({ variant: "warning", title: "Settings", message: "Chunking changed. Re-index required." });
+                                }
                                 entry.currentValue = num;
                             }
                             showSettingMenu(cat);
@@ -621,6 +719,41 @@ async function openSettingsDialog(api) {
                         },
                     }));
                 }
+                else if (entry.type === "json") {
+                    api.ui.dialog.replace(() => api.ui.DialogPrompt({
+                        title: `Edit ${entry.label}`,
+                        placeholder: "JSON",
+                        value: JSON.stringify(entry.currentValue, null, 2),
+                        onConfirm: (input) => {
+                            try {
+                                const parsed = JSON.parse(input);
+                                if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                                    api.ui.toast({ variant: "error", title: "Settings", message: "Value must be a JSON object" });
+                                    showSettingMenu(cat);
+                                    return;
+                                }
+                                saveRuntimeOverride(storePath, entry.path, parsed);
+                                saveConfigValue(configPath, entry.path, parsed);
+                                api.ui.toast({
+                                    variant: "success",
+                                    title: "Settings",
+                                    message: `${entry.label}: updated`,
+                                });
+                                if (entry.path[0] === "indexing" || entry.path[0] === "chunking") {
+                                    api.ui.toast({ variant: "warning", title: "Settings", message: "Chunking changed. Re-index required." });
+                                }
+                                entry.currentValue = parsed;
+                            }
+                            catch {
+                                api.ui.toast({ variant: "error", title: "Settings", message: "Invalid JSON" });
+                            }
+                            showSettingMenu(cat);
+                        },
+                        onCancel: () => {
+                            showSettingMenu(cat);
+                        },
+                    }));
+                }
                 else {
                     api.ui.dialog.replace(() => api.ui.DialogPrompt({
                         title: `Edit ${entry.label}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-rag-plugin",
-  "version": "1.18.1",
+  "version": "1.18.2",
   "description": "OpenCode plugin for local-first RAG-based semantic code search",
   "type": "module",
   "main": "./dist/plugin-entry.js",