opencode-rag-plugin 1.18.0 → 1.18.2

package/dist/indexer/pipeline.js

@@ -169,7 +169,10 @@ async function runIndexPassInner(options, logger) {
     const workspaceFiles = await scanWorkspaceFiles(options.cwd, options.config, logger, options.force ? undefined : manifest, filterPaths, options.imageVisionProvider, descCache);
     const scanSec = ((Date.now() - scanStart) / 1000).toFixed(1);
     logger.info(`Workspace scan complete: ${workspaceFiles.length} files in ${scanSec}s`);
+    logger.info(`Querying vector store for existing chunk count...`);
+    const storeCountStart = Date.now();
     const existingCount = await options.store.count();
+    logger.info(`Store has ${existingCount} existing chunks (${((Date.now() - storeCountStart) / 1000).toFixed(1)}s)`);
     // 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) {
@@ -276,6 +279,11 @@ async function runIndexPassInner(options, logger) {
     logger.debug(`Processing ${workspaceFiles.length} files (${newCount} new, ${modifiedCount} modified, ${unchangedCount} unchanged)...`);
     const limit = pLimit(options.config.indexing.concurrency);
     const deferDescriptions = !!options.descriptionProvider;
+    const activeCount = workspaceFiles.filter((f) => !f.isEmpty && !f.isTooSmall && (!manifest.files[f.normalizedPath] || manifest.files[f.normalizedPath].hash !== f.hash)).length;
+    logger.info(`Chunking ${activeCount} file(s)...`);
+    let chunkedDone = 0;
+    const chunkProgressInterval = Math.max(1, Math.floor(activeCount / 20));
+    const chunkPhaseStart = Date.now();
     const prepared = await Promise.all(workspaceFiles.map((file) => limit(async () => {
         const fileLabel = path.relative(options.cwd, file.normalizedPath).replace(/\\/g, "/");
         const isActive = !file.isEmpty && !file.isTooSmall &&
@@ -284,11 +292,20 @@ async function runIndexPassInner(options, logger) {
             options.progress?.startFile(fileLabel);
         }
         const prep = await prepareFile(file, options.cwd, manifest.files[file.normalizedPath], options.config, options.keywordIndex, options.descriptionProvider, logger, deferDescriptions, descHash);
+        if (isActive) {
+            chunkedDone++;
+            if (chunkedDone % chunkProgressInterval === 0 || chunkedDone === activeCount) {
+                const pct = ((chunkedDone / activeCount) * 100).toFixed(1);
+                logger.info(`  Chunking: ${chunkedDone}/${activeCount} files (${pct}%)`);
+            }
+        }
         if (prep.earlyResult && isActive) {
             options.progress?.finishFile(fileLabel);
         }
         return prep;
     })));
+    const chunkPhaseSec = ((Date.now() - chunkPhaseStart) / 1000).toFixed(1);
+    logger.info(`Chunking complete: ${activeCount} files in ${chunkPhaseSec}s`);
     const aborted = () => options.abortSignal?.aborted ?? false;
     // Shared progress logger: "stage <file> (chunk i/n) — X/total remaining (P%)".
     const logChunkProgress = (stage, fileLabel, index, count, completed, total) => {
@@ -302,6 +319,7 @@ async function runIndexPassInner(options, logger) {
             const allChunks = [];
             const oversizedChunks = [];
             const maxContentChars = options.config.description?.maxContentChars;
+            logger.info(`Description phase: ${deferredPreps.length} files with chunks to describe`);
             for (const prep of deferredPreps) {
                 for (const chunk of prep.chunks) {
                     if (chunk.metadata.contentType !== "image") {
@@ -469,6 +487,8 @@ async function runIndexPassInner(options, logger) {
             for (const prep of deferredPreps) {
                 prep.textToEmbed = buildTextsToEmbed(prep.chunks, prep.relPath, prep.metaHeader ?? "", prep.docPrefix ?? "", prep.isImageFile ?? false);
             }
+            const totalDescribedChunks = deferredPreps.reduce((s, p) => s + (p.chunks?.length ?? 0), 0);
+            logger.info(`Description phase complete: ${totalDescribedChunks} chunks across ${deferredPreps.length} files`);
         }
     }
     // Cross-file embedding batch: collect all texts into a single queue,
@@ -530,12 +550,15 @@ async function runIndexPassInner(options, logger) {
     let embeddedDone = 0;
     const allTexts = embedQueue.map(item => item.text);
     let allEmbeddings = [];
+    const embedPhaseStart = Date.now();
     if (allTexts.length > 0) {
+        logger.info(`Embedding phase: ${allTexts.length} texts in batches of ${batchSize}...`);
         try {
             allEmbeddings = await embedBatch(options.embedder, allTexts, batchSize, "document", defaultConcurrency, (completed, total) => {
                 embeddedDone = completed;
                 logChunkProgress("Embedding", "", completed, total, embeddedDone, totalEmbedChunks);
             });
+            logger.info(`Embedding complete: ${allTexts.length} texts in ${((Date.now() - embedPhaseStart) / 1000).toFixed(1)}s`);
         }
         catch (err) {
             logger.warn(`  Global embedding failed: ${err.message}`);
@@ -564,6 +587,8 @@ async function runIndexPassInner(options, logger) {
     }
     // ── Phase 3: Store + manifest update per file (parallel) ──────────────
     const filesToStore = prepared.filter((p) => !earlyWorkerResults.has(prepared.indexOf(p)) && p.chunks && (p.textToEmbed?.length ?? 0) > 0).length;
+    const storePhaseStart = Date.now();
+    logger.info(`Store phase: storing ${filesToStore} file(s) into vector database...`);
     let storedFiles = 0;
     const storeLimit = pLimit(options.config.indexing.concurrency);
     const storeResults = await Promise.all(prepared.map((prep, fi) => storeLimit(async () => {
@@ -648,6 +673,8 @@ async function runIndexPassInner(options, logger) {
             entry.size = size;
         }
     }
+    const storePhaseSec = ((Date.now() - storePhaseStart) / 1000).toFixed(1);
+    logger.info(`Store phase complete: ${storedFiles} files stored in ${storePhaseSec}s (${stats.totalChunks} total chunks)`);
     aggregateStats(stats, finalResults);
     // Update timestamps; advance lastGitCommit ONLY on a complete pass
     manifest.lastIndexedAt = Date.now();
@@ -696,6 +723,19 @@ async function runIndexPassInner(options, logger) {
     // a successful swap this points to the new data; after an abort it's the old).
     await saveManifest(options.storePath, manifest);
     await options.keywordIndex?.save(options.storePath);
+    // Compact fragments and prune old version manifests so countRows() can't
+    // hang on accumulated versions from many add/delete cycles.
+    if (!aborted()) {
+        logger.info("Optimizing vector store (compacting fragments, pruning old versions)...");
+        const optimizeStart = Date.now();
+        try {
+            await effectiveStore.optimize?.();
+            logger.info(`Vector store optimized in ${((Date.now() - optimizeStart) / 1000).toFixed(1)}s`);
+        }
+        catch (err) {
+            logger.warn(`Vector store optimization failed: ${err.message}`);
+        }
+    }
     // Persist description cache
     await descCache.save();
     // Count from the store — after a successful swap, the original handle has

package/dist/opencode/system-guidance.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview Single source of truth for the mandatory OpenCodeRAG tool-usage guidance
+ * that is injected into both the runtime system prompt (via plugin.ts) and the AGENTS.md
+ * directive (via init-helpers.ts).
+ */
+/** Sentinel marker that opens the managed section. */
+export declare const BEGIN_MARKER = "<!-- BEGIN opencode-rag -->";
+/** Sentinel marker that closes the managed section. */
+export declare const END_MARKER = "<!-- END opencode-rag -->";
+/**
+ * The always-on mandatory guidance lines — tool list, decision tree,
+ * proactive triggers, and anti-patterns. Used verbatim by the runtime
+ * system prompt injector.
+ */
+export declare const MANDATORY_GUIDANCE_LINES: readonly string[];
+/**
+ * The conditional quirk-capture enforcement lines. Only included when
+ * `memory.promptEnforcement` is true.
+ */
+export declare const QUIRK_ENFORCEMENT_LINES: readonly string[];
+/**
+ * Build the flat guidance lines array for the runtime system-prompt injector.
+ * Returns a new array each call.
+ */
+export declare function buildSystemGuidanceLines(opts: {
+    promptEnforcement: boolean;
+}): string[];
+/**
+ * Build the markdown-formatted AGENTS.md directive section, wrapped in sentinel
+ * markers so `mergeAgentsMdContent` can replace it in place on re-runs.
+ */
+export declare function buildAgentsMdDirective(opts: {
+    promptEnforcement: boolean;
+}): string;

package/dist/opencode/system-guidance.js

@@ -0,0 +1,127 @@
+/**
+ * @fileoverview Single source of truth for the mandatory OpenCodeRAG tool-usage guidance
+ * that is injected into both the runtime system prompt (via plugin.ts) and the AGENTS.md
+ * directive (via init-helpers.ts).
+ */
+/** Sentinel marker that opens the managed section. */
+export const BEGIN_MARKER = "<!-- BEGIN opencode-rag -->";
+/** Sentinel marker that closes the managed section. */
+export const END_MARKER = "<!-- END opencode-rag -->";
+/**
+ * The always-on mandatory guidance lines — tool list, decision tree,
+ * proactive triggers, and anti-patterns. Used verbatim by the runtime
+ * system prompt injector.
+ */
+export const MANDATORY_GUIDANCE_LINES = [
+    "MANDATORY: OpenCodeRAG tools MUST be used before any code task:",
+    "- `search_semantic(query)`: retrieve relevant code chunks. Call BEFORE planning, editing, or answering. Accepts `pathHints` and `languageHints`.",
+    "- `get_file_skeleton(filePath)`: structural overview of a file. Call BEFORE reading any file.",
+    "- `find_usages(symbolName)`: find all references. Call BEFORE editing any function, class, or variable.",
+    "- `describe_image(filePath)`: describe an image file using a vision model. Call when user refers to a screenshot, diagram, or image.",
+    "- `recall_quirks(query)`: query experiential quirk memory (gotchas, preferences, decisions). Call when you hit an error or need to recall known pitfalls.",
+    "- `add_quirk(content)`: store a new experiential memory. Call when you discover a non-obvious fact, gotcha, or coding convention.",
+    "",
+    "Decision tree — ALWAYS follow this order:",
+    "1. User mentions code behavior/architecture → `search_semantic(query)`",
+    "2. User mentions a file path → `get_file_skeleton(filePath)` THEN `read` on specific lines",
+    "3. User mentions a function/class/variable to edit → `find_usages(symbolName)` THEN `search_semantic` THEN `edit`",
+    "4. User asks a code question → `search_semantic` to gather context before answering",
+    "5. User asks about an image or visual asset → `describe_image(filePath)` to retrieve its generated description, then optionally `search_semantic` for related code",
+    "6. You encounter an error or need to recall a known pitfall → `recall_quirks(query)`",
+    "7. You discover a non-obvious fact or workaround → `add_quirk(content)` to persist it for future sessions",
+    "",
+    "Proactive triggers — you MUST call these tools when:",
+    "- User asks about code behavior, architecture, or implementation details",
+    "- User asks to edit, refactor, or fix code — call `find_usages` first",
+    "- User references files or functions you haven't read yet",
+    "- User says \"find\", \"search\", \"look up\", \"where is\", \"how does\"",
+    "- User refers to an image, screenshot, diagram, or visual asset",
+    "- Before answering ANY code-related question, retrieve context first",
+    "- Before reading ANY file, call `get_file_skeleton` to orient first",
+    "",
+    "Anti-patterns — NEVER do these:",
+    "- Reading full files without calling `get_file_skeleton` first (wastes tokens)",
+    "- Editing a function without calling `find_usages` first (breaks call sites)",
+    "- Answering code questions without calling `search_semantic` first (you guess at behavior)",
+    "- Using `grep`/`glob` when `search_semantic` would find the answer faster",
+    "- Treating image files as text — use `describe_image` instead of reading raw bytes",
+    "- Using `npx opencode-rag quirk` shell commands instead of the built-in `add_quirk` / `recall_quirks` tools (the tools are faster, already loaded in-process, and go through the trust monitor)",
+];
+/**
+ * The conditional quirk-capture enforcement lines. Only included when
+ * `memory.promptEnforcement` is true.
+ */
+export const QUIRK_ENFORCEMENT_LINES = [
+    "",
+    "MANDATORY quirk capture rules — you MUST call `add_quirk` when:",
+    "- A build, test, or type-check command fails and you resolve it",
+    "- You discover an undocumented library constraint, peer dep, or workaround",
+    "- You learn an environment-specific requirement (OS, tool version, etc.)",
+    "- You make a design decision that future sessions should remember",
+    "- You resolve a gotcha that cost more than one attempt",
+    "",
+    "Anti-pattern — NEVER finish a coding session without adding quirks for resolved errors.",
+];
+/**
+ * Build the flat guidance lines array for the runtime system-prompt injector.
+ * Returns a new array each call.
+ */
+export function buildSystemGuidanceLines(opts) {
+    const lines = [...MANDATORY_GUIDANCE_LINES];
+    if (opts.promptEnforcement) {
+        lines.push(...QUIRK_ENFORCEMENT_LINES);
+    }
+    return lines;
+}
+/**
+ * Build the markdown-formatted AGENTS.md directive section, wrapped in sentinel
+ * markers so `mergeAgentsMdContent` can replace it in place on re-runs.
+ */
+export function buildAgentsMdDirective(opts) {
+    const lines = [
+        BEGIN_MARKER,
+        "## Code Navigation",
+        "",
+        "ALWAYS use OpenCodeRAG tools before reading or editing:",
+        "- **Search first** — `search_semantic(query)` instead of grep/glob",
+        "- **Skeleton before read** — `get_file_skeleton(filePath)` then read specific lines",
+        "- **Usages before edit** — `find_usages(symbolName)` before modifying any symbol",
+        "- **Images via describe** — `describe_image(filePath)` — never read raw bytes",
+        "- **Recall quirks** — `recall_quirks(query)` when you hit a known pitfall",
+        "- **Add quirks** — `add_quirk(content)` when you discover a non-obvious fact",
+        "",
+        "If no results, run `opencode-rag index`.",
+        "",
+        "### Decision tree — ALWAYS follow this order",
+        "1. User mentions code behavior/architecture → `search_semantic(query)`",
+        "2. User mentions a file path → `get_file_skeleton(filePath)` THEN `read` on specific lines",
+        "3. User mentions a function/class/variable to edit → `find_usages(symbolName)` THEN `search_semantic` THEN `edit`",
+        "4. User asks a code question → `search_semantic` to gather context before answering",
+        "5. User asks about an image or visual asset → `describe_image(filePath)` to retrieve its generated description, then optionally `search_semantic` for related code",
+        "6. You encounter an error or need to recall a known pitfall → `recall_quirks(query)`",
+        "7. You discover a non-obvious fact or workaround → `add_quirk(content)` to persist it for future sessions",
+        "",
+        "### Proactive triggers — you MUST call these tools when",
+        "- User asks about code behavior, architecture, or implementation details",
+        "- User asks to edit, refactor, or fix code — call `find_usages` first",
+        "- User references files or functions you haven't read yet",
+        "- User says \"find\", \"search\", \"look up\", \"where is\", \"how does\"",
+        "- User refers to an image, screenshot, diagram, or visual asset",
+        "- Before answering ANY code-related question, retrieve context first",
+        "- Before reading ANY file, call `get_file_skeleton` to orient first",
+        "",
+        "### Anti-patterns — NEVER do these",
+        "- Reading full files without calling `get_file_skeleton` first (wastes tokens)",
+        "- Editing a function without calling `find_usages` first (breaks call sites)",
+        "- Answering code questions without calling `search_semantic` first (you guess at behavior)",
+        "- Using `grep`/`glob` when `search_semantic` would find the answer faster",
+        "- Treating image files as text — use `describe_image` instead of reading raw bytes",
+        "- Using `npx opencode-rag quirk` shell commands instead of the built-in `add_quirk` / `recall_quirks` tools (the tools are faster, already loaded in-process, and go through the trust monitor)",
+    ];
+    if (opts.promptEnforcement) {
+        lines.push("", "### MANDATORY quirk capture rules — you MUST call `add_quirk` when", "- A build, test, or type-check command fails and you resolve it", "- You discover an undocumented library constraint, peer dep, or workaround", "- You learn an environment-specific requirement (OS, tool version, etc.)", "- You make a design decision that future sessions should remember", "- You resolve a gotcha that cost more than one attempt", "- NEVER finish a coding session without adding quirks for resolved errors.");
+    }
+    lines.push(END_MARKER);
+    return lines.join("\n");
+}
+//# sourceMappingURL=system-guidance.js.map

package/dist/plugin.js

@@ -26,6 +26,8 @@ import { checkForUpdate, getCurrentVersion, installLatestUpdate } from "./core/v
 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 { 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";
@@ -93,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. */
@@ -434,6 +445,12 @@ export function createRagHooks(options) {
     // Track the current assistant message text per session for 2-message search queries.
     const sessionAssistantMessageId = new Map();
     const sessionAssistantText = new Map();
+    // Auto-capture maps: previous user request per session, tool results, and full transcript
+    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, {
@@ -686,8 +703,40 @@ export function createRagHooks(options) {
             catch {
                 // Non-critical — must never throw
             }
+            // Session-end extraction: when we see a non-message lifecycle event,
+            // attempt to extract quirks from the full transcript.
+            try {
+                if (!event.type.startsWith("message.")) {
+                    const sessionID = event.sessionID;
+                    if (sessionID) {
+                        const transcript = sessionTranscript.get(sessionID);
+                        if (transcript && transcript.length > 0) {
+                            const effCfg = getEffectiveCfg();
+                            const memCfg = effCfg.memory;
+                            if (memCfg?.sessionEndExtraction && options.descriptionProvider) {
+                                const qDeps = { embedder, store, keywordIndex: keywordIndex, cfg: effCfg, storePath: options.storePath };
+                                void autoCaptureQuirks(qDeps, options.descriptionProvider, transcript, effCfg, { captureAll: true }).catch(() => { });
+                            }
+                            boundedSet(sessionTranscript, sessionID, [], MAX_SESSION_MAP_SIZE);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Non-critical — must never throw
+            }
         },
         tool: tools,
+        async "tool.execute.after"(input, output) {
+            try {
+                const results = sessionToolResults.get(input.sessionID) ?? [];
+                results.push({ tool: input.tool, output: output.output ?? "" });
+                boundedSet(sessionToolResults, input.sessionID, results, MAX_SESSION_MAP_SIZE);
+            }
+            catch {
+                // Non-critical — must never throw
+            }
+        },
         async "experimental.chat.system.transform"(_input, output) {
             appendDebugLog(options.logFilePath, {
                 scope: "experimental.chat.system.transform",
@@ -695,40 +744,7 @@ export function createRagHooks(options) {
             });
             const cfg = getEffectiveCfg();
             if (cfg.openCode.injectSystemPrompt !== false) {
-                const guidance = [
-                    "MANDATORY: OpenCodeRAG tools MUST be used before any code task:",
-                    "- `search_semantic(query)`: retrieve relevant code chunks. Call BEFORE planning, editing, or answering. Accepts `pathHints` and `languageHints`.",
-                    "- `get_file_skeleton(filePath)`: structural overview of a file. Call BEFORE reading any file.",
-                    "- `find_usages(symbolName)`: find all references. Call BEFORE editing any function, class, or variable.",
-                    "- `describe_image(filePath)`: describe an image file using a vision model. Call when user refers to a screenshot, diagram, or image.",
-                    "- `recall_quirks(query)`: query experiential quirk memory (gotchas, preferences, decisions). Call when you hit an error or need to recall known pitfalls.",
-                    "- `add_quirk(content)`: store a new experiential memory. Call when you discover a non-obvious fact, gotcha, or coding convention.",
-                    "",
-                    "Decision tree — ALWAYS follow this order:",
-                    "1. User mentions code behavior/architecture → `search_semantic(query)`",
-                    "2. User mentions a file path → `get_file_skeleton(filePath)` THEN `read` on specific lines",
-                    "3. User mentions a function/class/variable to edit → `find_usages(symbolName)` THEN `search_semantic` THEN `edit`",
-                    "4. User asks a code question → `search_semantic` to gather context before answering",
-                    "5. User asks about an image or visual asset → `describe_image(filePath)` to retrieve its generated description, then optionally `search_semantic` for related code",
-                    "6. You encounter an error or need to recall a known pitfall → `recall_quirks(query)`",
-                    "7. You discover a non-obvious fact or workaround → `add_quirk(content)` to persist it for future sessions",
-                    "",
-                    "Proactive triggers — you MUST call these tools when:",
-                    "- User asks about code behavior, architecture, or implementation details",
-                    "- User asks to edit, refactor, or fix code — call `find_usages` first",
-                    "- User references files or functions you haven't read yet",
-                    "- User says \"find\", \"search\", \"look up\", \"where is\", \"how does\"",
-                    "- User refers to an image, screenshot, diagram, or visual asset",
-                    "- Before answering ANY code-related question, retrieve context first",
-                    "- Before reading ANY file, call `get_file_skeleton` to orient first",
-                    "",
-                    "Anti-patterns — NEVER do these:",
-                    "- Reading full files without calling `get_file_skeleton` first (wastes tokens)",
-                    "- Editing a function without calling `find_usages` first (breaks call sites)",
-                    "- Answering code questions without calling `search_semantic` first (you guess at behavior)",
-                    "- Using `grep`/`glob` when `search_semantic` would find the answer faster",
-                    "- Treating image files as text — use `describe_image` instead of reading raw bytes",
-                ];
+                const guidance = buildSystemGuidanceLines({ promptEnforcement: !!cfg.memory?.promptEnforcement });
                 output.system.unshift(guidance.join("\n"));
             }
             // Inject a one-time update prompt so the agent asks the user to install.
@@ -762,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 {
@@ -778,6 +830,30 @@ export function createRagHooks(options) {
                 });
                 if (text.length === 0)
                     return;
+                // Passive capture: process the completed exchange before overwriting session state
+                const prevUserReq = sessionPrevUserReq.get(input.sessionID) ?? "";
+                if (prevUserReq) {
+                    const effCfg = getEffectiveCfg();
+                    const memCfg = effCfg.memory;
+                    if (options.descriptionProvider) {
+                        const assistantText = sessionAssistantText.get(input.sessionID) ?? "";
+                        const toolResults = sessionToolResults.get(input.sessionID) ?? [];
+                        if (assistantText) {
+                            const qDeps = { embedder, store, keywordIndex: keywordIndex, cfg: effCfg, storePath: options.storePath };
+                            const exchange = { userReq: prevUserReq, assistantText, toolResults };
+                            if (memCfg?.passiveCapture) {
+                                void autoCaptureQuirks(qDeps, options.descriptionProvider, [exchange], effCfg).catch(() => { });
+                            }
+                            if (memCfg?.sessionEndExtraction) {
+                                const t = sessionTranscript.get(input.sessionID) ?? [];
+                                t.push(exchange);
+                                boundedSet(sessionTranscript, input.sessionID, t, MAX_SESSION_MAP_SIZE);
+                            }
+                        }
+                    }
+                }
+                sessionPrevUserReq.set(input.sessionID, text);
+                sessionToolResults.set(input.sessionID, []);
                 boundedSet(sessionLastMessage, input.sessionID, text, MAX_SESSION_MAP_SIZE);
                 // Handle /doc slash command
                 if (text.startsWith("/doc")) {
@@ -967,10 +1043,20 @@ 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}  `);
                             }
-                            lines.push("", "Commands:", "- `/quirk` — show this status", "- `/quirk lint` — health-check quirks", "- `/quirk add <text>` — instructions to use the add_quirk tool");
                         }
+                        const memCfg = getEffectiveCfg().memory;
+                        const flags = [
+                            memCfg?.autoInject ? "auto-inject" : "",
+                            memCfg?.passiveCapture ? "passive-capture" : "",
+                            memCfg?.promptEnforcement ? "prompt-enforce" : "",
+                            memCfg?.sessionEndExtraction ? "session-end" : "",
+                        ].filter(Boolean);
+                        if (flags.length > 0) {
+                            lines.push(`Flags: ${flags.join(", ")}`);
+                        }
+                        lines.push("", "Commands:", "- `/quirk` — show this status", "- `/quirk lint` — health-check quirks", "- `/quirk add <text>` — instructions to use the add_quirk tool");
                     }
                     const quirkMsg = lines.join("\n");
                     const parts = output?.parts ?? output?.message?.parts;
@@ -982,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) {
@@ -1038,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/auto-capture.d.ts

@@ -0,0 +1,14 @@
+import type { DescriptionProvider } from "../core/interfaces.js";
+import type { RagConfig } from "../core/config.js";
+import { type QuirkStoreDeps } from "./quirk-store.js";
+export interface CaptureExchange {
+    userReq: string;
+    assistantText: string;
+    toolResults: {
+        tool: string;
+        output: string;
+    }[];
+}
+export declare function autoCaptureQuirks(deps: QuirkStoreDeps, descriptionProvider: DescriptionProvider, exchanges: CaptureExchange[], cfg: RagConfig, opts?: {
+    captureAll?: boolean;
+}): Promise<void>;