opencode-rag-plugin 1.18.0 → 1.18.2

package/dist/quirks/auto-capture.js

@@ -0,0 +1,112 @@
+import { addQuirk, recallQuirks, lexicalSimilarity } from "./quirk-store.js";
+import { isQuirkAllowed } from "./monitor.js";
+import { MEMORY_CAPTURE_SYSTEM_PROMPT } from "./prompts.js";
+const ERROR_SIGNAL_RE = /(error|failure|fail|failed|err(?:or)?\s*:|stack\s*trace|exit\s+code\s*[1-9]|npm\s+ERR|build\s+failed|test\s+fail|cannot\s+find\s+module|command\s+failed|unresolved|conflict|peer.dep|not\s+found|enoent|eaccess|econnrefused)/i;
+function detectErrorSignal(text) {
+    return ERROR_SIGNAL_RE.test(text);
+}
+function buildExchangeText(exchanges) {
+    const lines = [];
+    for (const ex of exchanges) {
+        lines.push("=== User ===");
+        lines.push(ex.userReq);
+        if (ex.toolResults.length > 0) {
+            for (const tr of ex.toolResults) {
+                lines.push(`--- Tool: ${tr.tool} ---`);
+                lines.push(tr.output.slice(0, 500));
+            }
+        }
+        lines.push("=== Assistant ===");
+        lines.push(ex.assistantText);
+    }
+    return lines.join("\n");
+}
+function parseExtractionOutput(text) {
+    const results = [];
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed === "NOTHING")
+            continue;
+        const pipeIdx = trimmed.indexOf("|");
+        if (pipeIdx <= 0)
+            continue;
+        const quirkType = trimmed.slice(0, pipeIdx).trim();
+        const content = trimmed.slice(pipeIdx + 1).trim();
+        if (!quirkType || !content || content.length > 200)
+            continue;
+        results.push({ quirkType, content });
+    }
+    return results;
+}
+async function extractQuirksFromText(provider, exchangeText) {
+    const raw = await provider.generateText(MEMORY_CAPTURE_SYSTEM_PROMPT, exchangeText);
+    return parseExtractionOutput(raw);
+}
+async function dedupCandidates(deps, exchangeHead, candidates, threshold) {
+    const existing = await recallQuirks(deps, exchangeHead, { topK: 5 });
+    if (existing.length === 0)
+        return candidates;
+    const existingContent = existing.map((r) => r.chunk.content);
+    return candidates.filter((c) => {
+        for (const ec of existingContent) {
+            if (lexicalSimilarity(c.content, ec) >= threshold) {
+                return false;
+            }
+        }
+        return true;
+    });
+}
+export async function autoCaptureQuirks(deps, descriptionProvider, exchanges, cfg, opts) {
+    const memoryCfg = cfg.memory;
+    if (!memoryCfg)
+        return;
+    const maxPerTurn = memoryCfg.autoCaptureMaxPerTurn ?? 2;
+    const dedupThreshold = memoryCfg.autoCaptureDedupThreshold ?? 0.85;
+    const captureAll = opts?.captureAll ?? false;
+    if (!captureAll) {
+        const combined = exchanges.map((e) => e.userReq + "\n" + e.assistantText + "\n" + e.toolResults.map((t) => t.output).join("\n")).join("\n");
+        if (!detectErrorSignal(combined))
+            return;
+    }
+    const exchangeText = buildExchangeText(exchanges);
+    if (!exchangeText.trim())
+        return;
+    let candidates;
+    try {
+        candidates = await extractQuirksFromText(descriptionProvider, exchangeText);
+    }
+    catch {
+        return;
+    }
+    if (candidates.length === 0)
+        return;
+    const exchangeHead = exchanges.map((e) => e.userReq).join(" ");
+    let deduped;
+    try {
+        deduped = await dedupCandidates(deps, exchangeHead, candidates, dedupThreshold);
+    }
+    catch {
+        deduped = candidates;
+    }
+    let added = 0;
+    for (const c of deduped) {
+        if (added >= maxPerTurn)
+            break;
+        const allowed = isQuirkAllowed(c.content);
+        if (!allowed.ok)
+            continue;
+        try {
+            await addQuirk(deps, {
+                content: c.content,
+                quirkType: c.quirkType,
+                tags: ["auto-captured"],
+                confidence: 0.7,
+            });
+            added++;
+        }
+        catch {
+            // skip individual failures
+        }
+    }
+}
+//# sourceMappingURL=auto-capture.js.map

package/dist/quirks/prompts.d.ts

@@ -0,0 +1 @@
+export declare const MEMORY_CAPTURE_SYSTEM_PROMPT: string;

package/dist/quirks/prompts.js

@@ -0,0 +1,13 @@
+export const MEMORY_CAPTURE_SYSTEM_PROMPT = "You are a quirk-extraction assistant. Given a transcript excerpt of an AI agent resolving a " +
+    "coding problem, extract concise experiential quirks that are worth remembering.\n\n" +
+    "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" +
+    "- 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" +
+    "gotcha|npm install needs --legacy-peer-deps due to LanceDB peer dep conflicts\n" +
+    "preference|Use tsx over ts-node for running TypeScript scripts\n" +
+    "NOTHING";
+//# sourceMappingURL=prompts.js.map

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

@@ -20,6 +20,10 @@ 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[]>;
+/** Simple Jaccard-based lexical similarity (word overlap). */
+export declare function lexicalSimilarity(a: string, b: string): number;

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,14 +200,14 @@ 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}"`);
             }
         }
     }
     return issues;
 }
 /** Simple Jaccard-based lexical similarity (word overlap). */
-function lexicalSimilarity(a, b) {
+export function lexicalSimilarity(a, b) {
     const wordsA = new Set(a.toLowerCase().split(/\W+/).filter(Boolean));
     const wordsB = new Set(b.toLowerCase().split(/\W+/).filter(Boolean));
     const intersection = new Set([...wordsA].filter((w) => wordsB.has(w)));

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/dist/vectorstore/lancedb.d.ts

@@ -100,9 +100,18 @@ export declare class LanceDbStore implements VectorStore {
     private searchInternal;
     /**
      * Return the total number of chunks stored in the table.
-     * @returns The chunk count, or 0 if the table does not exist.
+     * Guarded by a 30s timeout — returns 0 if the store is unresponsive
+     * (e.g. corrupted version-manifest accumulation) so the pipeline can
+     * proceed with a fresh index instead of hanging forever.
+     * @returns The chunk count, or 0 if the table does not exist or times out.
      */
     count(): Promise<number>;
+    /**
+     * Compact fragments and prune old version manifests to prevent the
+     * version-manifest accumulation that causes countRows() to hang.
+     * Should be called at the end of a successful index pass.
+     */
+    optimize(): Promise<void>;
     /**
      * Return all unique file paths currently stored in the index.
      * @returns An array of normalized file paths.

package/dist/vectorstore/lancedb.js

@@ -513,7 +513,10 @@ export class LanceDbStore {
     }
     /**
      * Return the total number of chunks stored in the table.
-     * @returns The chunk count, or 0 if the table does not exist.
+     * Guarded by a 30s timeout — returns 0 if the store is unresponsive
+     * (e.g. corrupted version-manifest accumulation) so the pipeline can
+     * proceed with a fresh index instead of hanging forever.
+     * @returns The chunk count, or 0 if the table does not exist or times out.
      */
     async count() {
         try {
@@ -522,12 +525,35 @@ export class LanceDbStore {
             if (!tableNames.includes(TABLE_NAME))
                 return 0;
             const table = await this.getTable();
-            return await table.countRows();
+            const COUNT_TIMEOUT_MS = 30_000;
+            const result = await Promise.race([
+                table.countRows(),
+                new Promise((resolve) => setTimeout(() => resolve(null), COUNT_TIMEOUT_MS)),
+            ]);
+            if (result === null) {
+                console.warn(`[lancedb] count() timed out after ${COUNT_TIMEOUT_MS / 1000}s — treating store as empty.`);
+                return 0;
+            }
+            return result;
         }
         catch {
             return 0;
         }
     }
+    /**
+     * Compact fragments and prune old version manifests to prevent the
+     * version-manifest accumulation that causes countRows() to hang.
+     * Should be called at the end of a successful index pass.
+     */
+    async optimize() {
+        try {
+            const table = await this.getTable();
+            await table.optimize({ cleanupOlderThan: new Date(), deleteUnverified: false });
+        }
+        catch {
+            // Optimize is best-effort — must not break indexing.
+        }
+    }
     /**
      * Return all unique file paths currently stored in the index.
      * @returns An array of normalized file paths.

package/dist/vectorstore/memory.d.ts

@@ -21,4 +21,6 @@ export declare class InMemoryVectorStore implements VectorStore {
     getChunksByFilePath(filePath: string): Promise<Chunk[]>;
     /** Release any held resources. No-op for the in-memory store. */
     close(): Promise<void>;
+    /** No-op for the in-memory store. */
+    optimize(): Promise<void>;
 }

package/dist/vectorstore/memory.js

@@ -73,6 +73,9 @@ export class InMemoryVectorStore {
     /** Release any held resources. No-op for the in-memory store. */
     async close() {
     }
+    /** No-op for the in-memory store. */
+    async optimize() {
+    }
 }
 /**
  * Compute the cosine similarity between two equal-length vectors.

package/dist/web/api.d.ts

@@ -4,6 +4,7 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { LanceDbStore } from "../vectorstore/lancedb.js";
 import { KeywordIndex } from "../retriever/keyword-index.js";
+import type { RagConfig } from "../core/config.js";
 /** Internal shape for a JSON API response: an HTTP status code and a serialisable body. */
 interface ApiResponse {
     status: number;
@@ -23,9 +24,10 @@ interface ApiResponse {
  * @param keywordIndex - The keyword-index instance for text search.
  * @param storePath    - Filesystem path to the store directory (used by eval endpoints).
  * @param cwd          - Optional workspace root for resolving file paths.
+ * @param cfg          - Active RAG configuration (used by quirk endpoints).
  * @returns An async handler that returns `true` when a route matched or `false` otherwise.
  */
-export declare function createApiHandler(store: LanceDbStore, keywordIndex: KeywordIndex, storePath: string, cwd?: string): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
+export declare function createApiHandler(store: LanceDbStore, keywordIndex: KeywordIndex, storePath: string, cwd?: string, cfg?: RagConfig): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
 /**
  * Perform token-usage analysis for a single evaluation session.
  *

package/dist/web/api.js

@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
 import { extname, resolve as resolvePathModule } from "node:path";
 import { listSessions, getSession, deleteSession, compareSessions, validateSessionID } from "../eval/storage.js";
 import { analyzeTokenUsage, compareTokenAnalyses, projectTokenSavings } from "../eval/token-analysis.js";
+import { listQuirks, lintQuirks, removeQuirk } from "../quirks/quirk-store.js";
 const FILE_MIME_TYPES = {
     ".png": "image/png",
     ".jpg": "image/jpeg",
@@ -11,6 +12,13 @@ const FILE_MIME_TYPES = {
     ".bmp": "image/bmp",
     ".svg": "image/svg+xml",
 };
+/** No-op embedder used by quirk endpoints that never need to embed text in the read-only UI context. */
+const stubEmbedder = {
+    name: "stub",
+    embed: async () => {
+        throw new Error("Embedder is not available in the Web UI context");
+    },
+};
 /** Split a raw URL into its pathname and parsed query-string parameters. */
 function parseQuery(url) {
     const [path, queryString] = url.split("?");
@@ -43,13 +51,22 @@ function sendJson(res, response) {
  * @param keywordIndex - The keyword-index instance for text search.
  * @param storePath    - Filesystem path to the store directory (used by eval endpoints).
  * @param cwd          - Optional workspace root for resolving file paths.
+ * @param cfg          - Active RAG configuration (used by quirk endpoints).
  * @returns An async handler that returns `true` when a route matched or `false` otherwise.
  */
-export function createApiHandler(store, keywordIndex, storePath, cwd) {
+export function createApiHandler(store, keywordIndex, storePath, cwd, cfg) {
     return async (req, res) => {
         const url = req.url ?? "/";
         const method = req.method ?? "GET";
         const { path, params } = parseQuery(url);
+        // Quirk store dependencies (embedder is a no-op stub for the read-only UI context).
+        const quirkDeps = {
+            embedder: stubEmbedder,
+            store,
+            keywordIndex,
+            cfg: cfg ?? {},
+            storePath,
+        };
         // CORS preflight
         if (method === "OPTIONS") {
             res.writeHead(204, {
@@ -143,6 +160,22 @@ export function createApiHandler(store, keywordIndex, storePath, cwd) {
                 const body = await readBody(req);
                 response = handleEvalProjectSavings(body);
             }
+            // Quirk memory endpoints
+            else if (path === "/api/quirks" && method === "GET") {
+                response = await handleQuirks(quirkDeps);
+            }
+            else if (path === "/api/quirks/lint" && method === "GET") {
+                response = await handleQuirkLint(quirkDeps);
+            }
+            else if (path.startsWith("/api/quirks/") && method === "DELETE") {
+                const id = path.slice("/api/quirks/".length);
+                if (!id) {
+                    response = { status: 400, body: { error: "Missing quirk ID" } };
+                }
+                else {
+                    response = await handleQuirkDelete(quirkDeps, id);
+                }
+            }
             else {
                 return false;
             }
@@ -181,6 +214,22 @@ async function handleFiles(store) {
     const files = await store.listFiles();
     return { status: 200, body: files };
 }
+// ── Quirk Memory API ─────────────────────────────────────────────────
+/** Respond with all stored quirks, sorted by last-observed time (most recent first). */
+async function handleQuirks(deps) {
+    const quirks = await listQuirks(deps);
+    return { status: 200, body: { quirks } };
+}
+/** Respond with the health-check issues for the quirk store (confidence, staleness, duplicates). */
+async function handleQuirkLint(deps) {
+    const issues = await lintQuirks(deps);
+    return { status: 200, body: { issues } };
+}
+/** Delete a single quirk by its ID from the store, index, and audit log. */
+async function handleQuirkDelete(deps, id) {
+    await removeQuirk(deps, id);
+    return { status: 200, body: { deleted: true, id } };
+}
 /**
  * Respond with a paginated, optionally filtered list of chunks.
  *

package/dist/web/server.d.ts

@@ -15,6 +15,7 @@ export interface WebUiServer {
  * @param port            - TCP port to listen on.
  * @param cwd             - Optional workspace root used to resolve file paths for the file API.
  * @param vectorDimension - Embedding vector dimension (default 384).
+ * @param cfg             - Active RAG configuration (used by quirk endpoints).
  * @returns A {@link WebUiServer} handle for the running server.
  */
-export declare function startWebUi(storePath: string, port: number, cwd?: string, vectorDimension?: number): Promise<WebUiServer>;
+export declare function startWebUi(storePath: string, port: number, cwd?: string, vectorDimension?: number, cfg?: import("../core/config.js").RagConfig): Promise<WebUiServer>;

package/dist/web/server.js

@@ -53,13 +53,14 @@ function serveUiAsset(res, filePath) {
  * @param port            - TCP port to listen on.
  * @param cwd             - Optional workspace root used to resolve file paths for the file API.
  * @param vectorDimension - Embedding vector dimension (default 384).
+ * @param cfg             - Active RAG configuration (used by quirk endpoints).
  * @returns A {@link WebUiServer} handle for the running server.
  */
-export async function startWebUi(storePath, port, cwd, vectorDimension = 384) {
+export async function startWebUi(storePath, port, cwd, vectorDimension = 384, cfg) {
     const store = new LanceDbStore(storePath, vectorDimension);
     const keywordIndex = await KeywordIndex.load(storePath);
     const html = getStaticHtml();
-    const apiHandler = createApiHandler(store, keywordIndex, storePath, cwd);
+    const apiHandler = createApiHandler(store, keywordIndex, storePath, cwd, cfg);
     const server = createServer(async (req, res) => {
         const url = req.url ?? "/";
         if (url === "/" || url === "/index.html") {