@jmtrin/opencode-kevin 0.2.0 → 0.4.0

package/dist/plugin/MemoryService.js

@@ -1,19 +1,34 @@
+import { deterministicFixLine } from "./LessonFixer.js";
+import { computeConfidence } from "./confidence.js";
 import { fingerprint as computeFingerprint } from "./fingerprint.js";
+import { toMatchClause, tokenizeQuery } from "./query-tokenizer.js";
 import { uuidv7 } from "./uuid.js";
 const MAX_SNIPPET_CHARS = 200;
-function toSlim(mem) {
-    const rawScore = mem.metadata?.score;
-    return {
+function toSlim(mem, evidence = false) {
+    const base = {
         id: mem.id,
         type: mem.type,
         scope: mem.scope,
-        score: typeof rawScore === "number" ? rawScore : mem.relevanceScore,
+        score: typeof mem.metadata?.score ===
+            "number"
+            ? mem.metadata.score
+            : mem.relevanceScore,
         snippet: mem.content.slice(0, MAX_SNIPPET_CHARS),
     };
+    if (!evidence)
+        return base;
+    return {
+        ...base,
+        confidence: mem.confidence ?? null,
+        evidence_count: mem.evidenceCount ?? null,
+        last_verified_at: mem.lastVerifiedAt ?? null,
+    };
 }
 const TYPE_PRIORITY = {
     error: 0,
     pattern: 1,
+    rule: 1,
+    solution: 1,
     decision: 2,
     context: 3,
 };
@@ -26,6 +41,7 @@ const RELEVANCE_MAX = 1.0;
 // notes, all else equal. No embeddings, no RRF.
 const ORIGIN_BOOST_REFLECTOR = 2;
 const ORIGIN_BOOST_PATTERN = 1.5;
+const ORIGIN_BOOST_CASUAL = 2;
 const ORIGIN_BOOST_AGENT = 1;
 const RECENCY_DECAY_PER_DAY = 0.95; // newer = closer to 1 (less penalty)
 function sqliteUtcToMs(createdAt) {
@@ -45,6 +61,11 @@ function sqliteUtcNowPlusHours(hours) {
     const pad = (n) => String(n).padStart(2, "0");
     return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())} ${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())}`;
 }
+/** Shared column list for row reads (must stay in sync with MemoryRow). */
+const MEMORY_ROW_SELECT = `id, type, content, scope, relevance_score, source_tool, source_session,
+                metadata, created_at, updated_at, expires_at,
+                project_id, fingerprint, origin,
+                evidence_count, recurrence_count, last_verified_at, status, fix_args`;
 function mapRow(row, score) {
     const mem = {
         id: row.id,
@@ -63,6 +84,14 @@ function mapRow(row, score) {
         projectId: row.project_id ?? null,
         fingerprint: row.fingerprint ?? null,
         origin: row.origin ?? null,
+        confidence: typeof row.evidence_count === "number"
+            ? computeConfidence(row.evidence_count ?? 0, row.recurrence_count ?? 0)
+            : null,
+        evidenceCount: row.evidence_count ?? null,
+        lastVerifiedAt: row.last_verified_at ?? null,
+        status: row.status ?? "active",
+        fixArgs: row.fix_args ?? null,
+        recurrenceCount: row.recurrence_count ?? null,
     };
     if (score !== undefined) {
         if (!mem.metadata)
@@ -97,12 +126,30 @@ export class MemoryService {
     // so that Metrics can be added without changing the parameter order callers
     // have been using since v0.1.0.
     store;
+    // v0.4.0 (BUG-008) — cached column probe for pre-005 DBs (which lack
+    // `recurrence_count`); save() must not reference the column there.
+    hasRecurrenceColumn() {
+        if (this._hasRecurrenceColumn === undefined) {
+            try {
+                this.store
+                    .prepare("SELECT recurrence_count FROM memories LIMIT 1")
+                    .get();
+                this._hasRecurrenceColumn = true;
+            }
+            catch {
+                this._hasRecurrenceColumn = false;
+            }
+        }
+        return this._hasRecurrenceColumn;
+    }
+    _hasRecurrenceColumn;
     save(input) {
         const scope = input.scope ?? "project";
         const relevanceScore = input.relevanceScore ?? 0.5;
         const metadata = input.metadata ? JSON.stringify(input.metadata) : null;
         const origin = input.origin ?? "agent";
         const projectId = input.projectId ?? null;
+        const status = input.status ?? "active";
         // Fingerprint is used for dedup (error memories via migration 003
         // partial unique index) AND for pattern idempotency (K2-021 — pattern
         // memories store an explicit fingerprint so PatternMiner's SELECT-before-
@@ -121,14 +168,46 @@ export class MemoryService {
         if (scope === "session" && !input.expiresAt) {
             expiresAt = sqliteUtcNowPlusHours(SESSION_DEFAULT_TTL_HOURS);
         }
-        const id = uuidv7();
-        try {
+        const id = input.id ?? uuidv7();
+        // v0.3.0 (K3-014) — supersede model: when saving a decision/rule with
+        // the same fingerprint as an existing active row, mark the old as
+        // superseded and insert the fresh version as active.
+        // v0.4.0 (K4-011) — `memories_superseded` is only counted here,
+        // where a row is truly replaced; penalization of recurring
+        // reflectors no longer increments it.
+        const supersedableTypes = ["decision", "rule"];
+        if (fp !== null && supersedableTypes.includes(input.type)) {
             this.store
-                .prepare(`INSERT INTO memories
+                .prepare(`UPDATE memories
+					 SET status = 'superseded', updated_at = datetime('now')
+					 WHERE fingerprint = ?
+					   AND type = ?
+					   AND status = 'active'
+					   AND (project_id IS ? OR (project_id IS NULL AND ? IS NULL))`)
+                .run(fp, input.type, projectId, projectId);
+            const after = this.store.prepare("SELECT changes() AS n").get();
+            if (after.n > 0) {
+                this.metrics?.incr("memories_superseded", 1);
+            }
+        }
+        try {
+            // v0.4.0 (BUG-008) — recurrence_count is only persisted when the
+            // column exists (migration 005); pre-005 DBs get the legacy shape.
+            const withRecurrence = this.hasRecurrenceColumn();
+            const insert = withRecurrence
+                ? `INSERT INTO memories
              (id, type, content, scope, relevance_score, source_tool, source_session,
-              metadata, expires_at, project_id, fingerprint, origin)
-           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                .run(id, input.type, input.content, scope, relevanceScore, input.sourceTool ?? null, input.sourceSession ?? null, metadata, expiresAt, projectId, fp, origin);
+              metadata, expires_at, project_id, fingerprint, origin,
+              evidence_count, last_verified_at, status, recurrence_count)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+                : `INSERT INTO memories
+             (id, type, content, scope, relevance_score, source_tool, source_session,
+              metadata, expires_at, project_id, fingerprint, origin,
+              evidence_count, last_verified_at, status)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+            this.store
+                .prepare(insert)
+                .run(id, input.type, input.content, scope, relevanceScore, input.sourceTool ?? null, input.sourceSession ?? null, metadata, expiresAt, projectId, fp, origin, input.evidenceCount ?? 0, input.lastVerifiedAt ?? null, status, ...(withRecurrence ? [input.recurrenceCount ?? 0] : []));
             return id;
         }
         catch (err) {
@@ -160,13 +239,26 @@ export class MemoryService {
     }
     getById(id) {
         const row = this.store
-            .prepare(`SELECT id, type, content, scope, relevance_score, source_tool, source_session,
-                metadata, created_at, updated_at, expires_at,
-                project_id, fingerprint, origin
+            .prepare(`SELECT ${MEMORY_ROW_SELECT}
          FROM memories WHERE id = ?`)
             .get(id);
         return row ? mapRow(row) : null;
     }
+    /**
+     * v0.4.0 (K4-016) — most recent ACTIVE memory for a fingerprint,
+     * optionally filtered by type. Feeds the HITL suggestion lookup
+     * (most-recurred fingerprint → its pattern memory).
+     */
+    getByFingerprint(fingerprint, type) {
+        const row = this.store
+            .prepare(`SELECT ${MEMORY_ROW_SELECT}
+         FROM memories
+        WHERE fingerprint = ? AND status = 'active'
+          ${type ? "AND type = ?" : ""}
+        ORDER BY created_at DESC LIMIT 1`)
+            .get(...(type ? [fingerprint, type] : [fingerprint]));
+        return row ? mapRow(row) : null;
+    }
     update(id, fields) {
         const cols = [];
         const vals = [];
@@ -194,6 +286,25 @@ export class MemoryService {
             cols.push("expires_at = ?");
             vals.push(fields.expiresAt);
         }
+        if (fields.evidenceCount !== undefined) {
+            cols.push("evidence_count = ?");
+            vals.push(fields.evidenceCount);
+        }
+        if (fields.lastVerifiedAt !== undefined) {
+            cols.push("last_verified_at = ?");
+            vals.push(fields.lastVerifiedAt);
+        }
+        if (fields.status !== undefined) {
+            cols.push("status = ?");
+            vals.push(fields.status);
+        }
+        // v0.4.0 (BUG-008) — recurrence_count is writable so okf-import can
+        // restore negative evidence across a round-trip. Guarded by the
+        // caller (pre-005 DBs lack the column; update() throws).
+        if (fields.recurrenceCount !== undefined) {
+            cols.push("recurrence_count = ?");
+            vals.push(fields.recurrenceCount);
+        }
         if (cols.length === 0)
             return;
         cols.push("updated_at = datetime('now')");
@@ -217,12 +328,16 @@ export class MemoryService {
              m.source_tool, m.source_session, m.metadata,
              m.created_at, m.updated_at, m.expires_at,
              m.project_id, m.fingerprint, m.origin,
+             m.evidence_count, m.last_verified_at, m.status,
              bm25(memories_fts) AS score
       FROM memories_fts
       JOIN memories m ON m.rowid = memories_fts.rowid
       WHERE memories_fts MATCH ?
         AND (m.expires_at IS NULL OR m.expires_at > datetime('now'))`;
         const params = [match];
+        if (!input.includeSuperseded) {
+            sql += "\n        AND m.status = 'active'";
+        }
         if (input.type) {
             sql += " AND m.type = ?";
             params.push(input.type);
@@ -234,18 +349,58 @@ export class MemoryService {
         sql += " ORDER BY bm25(memories_fts) LIMIT ?";
         params.push(limit);
         const rows = this.store.prepare(sql).all(...params);
+        // v0.3.0 (K3-019) — cross-project opt-in must also gate kevin_query
+        // (bug #12 fix): when cross_project_enabled is OFF, imported rows
+        // (project_id IS NULL AND origin='imported') are hidden.
+        const crossProjectOn = this.isCrossProjectEnabled();
         const memories = rows
             .map((r) => mapRow(r, r.score))
-            .filter((m) => !isNotSearchable(m));
-        return input.full === true ? memories : memories.map(toSlim);
+            .filter((m) => !isNotSearchable(m))
+            .filter((m) => crossProjectOn || m.projectId !== null || m.origin !== "imported");
+        return input.full === true
+            ? memories
+            : memories.map((m) => toSlim(m, input.evidence === true));
+    }
+    isCrossProjectEnabled() {
+        try {
+            const row = this.store
+                .prepare("SELECT value FROM kevin_settings WHERE key = 'cross_project_enabled'")
+                .get();
+            // BUG-002 — the column stores TEXT ('0'/'1'); the old numeric
+            // comparison `=== 1` could never match '1'.
+            return (row?.value ?? "0") === "1";
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * v0.4.0 (K4-012) — read a kevin_settings flag by key. Falls back to
+     * the caller-provided default when the key is missing or the table is
+     * unavailable (legacy DB without the settings table).
+     */
+    getSetting(key, fallback = "0") {
+        try {
+            const row = this.store
+                .prepare("SELECT value FROM kevin_settings WHERE key = ?")
+                .get(key);
+            return row?.value ?? fallback;
+        }
+        catch {
+            return fallback;
+        }
     }
-    loadAll(scope) {
+    loadAll(scope, includeSuperseded = false) {
         let sql = `
       SELECT id, type, content, scope, relevance_score, source_tool, source_session,
              metadata, created_at, updated_at, expires_at,
-             project_id, fingerprint, origin
+             project_id, fingerprint, origin,
+             evidence_count, last_verified_at, status
       FROM memories
       WHERE (expires_at IS NULL OR expires_at > datetime('now'))`;
+        if (!includeSuperseded) {
+            sql += "\n        AND status = 'active'";
+        }
         const params = [];
         if (scope !== "all") {
             sql += " AND scope = ?";
@@ -254,24 +409,25 @@ export class MemoryService {
         sql += " ORDER BY relevance_score DESC, created_at DESC";
         return this.store.prepare(sql).all(...params);
     }
-    queryRelevant(text, scope) {
-        const tokens = stripUnbalancedQuotes(text.trim())
-            .split(/\s+/)
-            .filter((t) => t.length > 0)
-            .map((t) => `"${t.replace(/"/g, '""')}"`);
+    queryRelevant(text, scope, includeSuperseded = false) {
+        const tokens = tokenizeQuery(stripUnbalancedQuotes(text));
         if (tokens.length === 0)
             return [];
-        const match = tokens.join(" OR ");
+        const match = toMatchClause(tokens, " OR ");
         let sql = `
       SELECT m.id, m.type, m.content, m.scope, m.relevance_score,
              m.source_tool, m.source_session, m.metadata,
              m.created_at, m.updated_at, m.expires_at,
              m.project_id, m.fingerprint, m.origin,
+             m.evidence_count, m.last_verified_at, m.status,
              bm25(memories_fts) AS score
       FROM memories_fts
       JOIN memories m ON m.rowid = memories_fts.rowid
       WHERE memories_fts MATCH ?
         AND (m.expires_at IS NULL OR m.expires_at > datetime('now'))`;
+        if (!includeSuperseded) {
+            sql += "\n        AND m.status = 'active'";
+        }
         const params = [match];
         if (scope !== "all") {
             sql += " AND m.scope = ?";
@@ -287,15 +443,26 @@ export class MemoryService {
         const maxTokens = input.maxTokens ?? 2000;
         const charBudget = maxTokens * 4;
         const scope = input.scope ?? "project";
+        const includeSuperseded = input.includeSuperseded === true;
         let candidates;
         if (input.query && input.query.trim().length > 0) {
-            candidates = this.queryRelevant(input.query, scope);
+            candidates = this.queryRelevant(input.query, scope, includeSuperseded);
         }
         else {
-            candidates = this.loadAll(scope)
+            candidates = this.loadAll(scope, includeSuperseded)
                 .map((r) => mapRow(r))
                 .filter((m) => !isNotSearchable(m));
         }
+        // v0.3.0 (K3-019) — cross-project opt-in.
+        // When cross_project_enabled is OFF (default), exclude imported
+        // cross-project rows (project_id IS NULL AND origin='imported').
+        // OKF import is the cross-project bridge per plan §B12; imported
+        // memories always carry project_id NULL (bug #12 fix — the old
+        // filter only excluded imported RULES, leaking imported
+        // decisions/patterns into recall).
+        if (!this.isCrossProjectEnabled()) {
+            candidates = candidates.filter((m) => m.projectId !== null || m.origin !== "imported");
+        }
         // v0.2.0 (K2-023) origin-aware rank: BM25 × origin-boost × recency-decay.
         // Tie-breakers preserve the v0.1.x spirit (errors/patterns before
         // context; newer before older when nothing else decides).
@@ -309,7 +476,7 @@ export class MemoryService {
             result.push(mem);
             used += len;
         }
-        if (result.length > 0) {
+        if (result.length > 0 && input.bump !== false) {
             const bump = this.store.prepare("UPDATE memories SET relevance_score = MIN(?, relevance_score + ?) WHERE id = ?");
             this.store.transaction(() => {
                 for (const m of result)
@@ -318,6 +485,93 @@ export class MemoryService {
         }
         return result;
     }
+    /**
+     * v0.4.0 (BUG-016) — apply the K2-023 relevance bump to a fixed slice
+     * of ids, exactly once. Lets ContextInjector probe without mutating
+     * and still bump the slice it actually injects.
+     */
+    bumpRelevance(ids) {
+        if (ids.length === 0)
+            return;
+        const bump = this.store.prepare("UPDATE memories SET relevance_score = MIN(?, relevance_score + ?) WHERE id = ?");
+        this.store.transaction(() => {
+            for (const id of ids)
+                bump.run(RELEVANCE_MAX, RELEVANCE_BUMP, id);
+        });
+    }
+    /**
+     * v0.3.0 (K3-004) — Promote an error memory to a causal pattern.
+     *
+     * Creates a new `pattern` memory with `origin = 'causal'`, derived
+     * confidence, and evidence count. The original error memory is NOT
+     * deleted — the audit trail is preserved. Returns the new memory id,
+     * or null when the source error is not eligible (missing fingerprint,
+     * wrong type, or already promoted).
+     */
+    /**
+     * v0.4.0 (K4-009) — returns `{ id, created }` so callers can tell a
+     * newly-created pattern from an idempotent refresh.
+     */
+    promoteToPattern(errorId, evidenceCount, recurrenceCount = 0) {
+        const error = this.getById(errorId);
+        if (!error || error.type !== "error" || !error.fingerprint)
+            return null;
+        // v0.4.0 (K4-010) — two-sided confidence: recurrence demotes the
+        // pattern's confidence.
+        const confidence = computeConfidence(evidenceCount, recurrenceCount);
+        const now = new Date().toISOString();
+        const summary = error.content.split("\n")[0].slice(0, 200);
+        const base = `Causal pattern: ${summary}\n\nEvidence: ${evidenceCount} confirmed fix(es)\nConfidence: ${(confidence * 100).toFixed(0)}%\n\nOriginal: ${error.content.slice(0, 1000)}`;
+        // v0.4.0 (K4-014) — deterministic "Fixed by:" from the linked
+        // success call's args_summary (D4-07). The opt-in LLM phrasing
+        // (K4-015) runs later in CausalChain.onSessionIdle, never here and
+        // never on the failure hot path.
+        const fixLine = deterministicFixLine({
+            content: base,
+            fixArgs: error.fixArgs ?? null,
+        });
+        const content = fixLine ? `${base}\n${fixLine}` : base;
+        // v0.3.0 fix (bug #4) — idempotent promotion: the supersede model
+        // only covers decision/rule, so the old code inserted a duplicate
+        // pattern on every subsequent session.idle with a new fix. When an
+        // active causal pattern already exists for this fingerprint, refresh
+        // it (content, evidence_count, last_verified_at) instead. The FTS
+        // sync trigger (memories_au) keeps searchable content up to date.
+        const existing = this.store
+            .prepare(`SELECT id FROM memories
+				 WHERE fingerprint = ? AND type = 'pattern'
+				   AND origin = 'causal' AND status = 'active'
+				 ORDER BY created_at DESC LIMIT 1`)
+            .get(error.fingerprint);
+        let patternId;
+        if (existing) {
+            this.update(existing.id, { content, evidenceCount, lastVerifiedAt: now });
+            patternId = existing.id;
+        }
+        else {
+            patternId = this.save({
+                type: "pattern",
+                content,
+                scope: "project",
+                origin: "causal",
+                sourceTool: error.sourceTool ?? undefined,
+                sourceSession: error.sourceSession ?? undefined,
+                fingerprint: error.fingerprint,
+                evidenceCount,
+                lastVerifiedAt: now,
+                status: "active",
+                projectId: error.projectId ?? undefined,
+            });
+        }
+        // v0.4.0 (K4-010) — persist the recurrence count on the pattern row
+        // so mapRow (and kevin_why) recompute the SAME demoted confidence.
+        // v0.4.0 (K4-014) — persist fix_args too: the pattern's "Fixed by:"
+        // raw material travels with the row for kevin_why/HITL (K4-016/020).
+        this.store
+            .prepare("UPDATE memories SET recurrence_count = ?, fix_args = ? WHERE id = ?")
+            .run(recurrenceCount, error.fixArgs ?? null, patternId);
+        return { id: patternId, created: !existing };
+    }
     /**
      * v0.2.0 (K2-026) — Feedback loop positive half (plan §B6.10 / D2-10).
      *
@@ -333,25 +587,33 @@ export class MemoryService {
         if (!sessionId)
             return 0;
         const lessons = this.store
-            .prepare(`SELECT id, fingerprint, project_id
+            .prepare(`SELECT id, fingerprint, project_id, metadata
 				 FROM memories
 				 WHERE origin = 'reflector'
 				   AND type = 'error'
 				   AND source_session = ?
-				   AND fingerprint IS NOT NULL`)
+				   AND fingerprint IS NOT NULL
+				   AND status = 'active'`)
             .all(sessionId);
         if (lessons.length === 0)
             return 0;
+        // v0.3.0 fix — recurrence is now matched via `error_fingerprint`
+        // (set by Reflector.onLinkError) OR the legacy `fingerprint` column
+        // (preserved for tests and pre-fix tool_call rows). The original
+        // failing call is excluded when its id is recorded in the memory
+        // metadata as `origin_call_id` (set by Reflector from `callID`).
         const recurrenceCheck = this.store.prepare(`SELECT COUNT(*) AS c
 			 FROM tool_calls
-			 WHERE fingerprint = ?
+			 WHERE (error_fingerprint = ? OR fingerprint = ?)
 			   AND success = 0
-			   AND (project_id IS ? OR (project_id IS NULL AND ? IS NULL))`);
+			   AND (project_id IS ? OR (project_id IS NULL AND ? IS NULL))
+			   AND (? IS NULL OR id <> ?)`);
         const bumpOne = this.store.prepare("UPDATE memories SET relevance_score = MIN(?, relevance_score + ?) WHERE id = ?");
         let boosted = 0;
         this.store.transaction(() => {
             for (const l of lessons) {
-                const row = recurrenceCheck.get(l.fingerprint, l.project_id, l.project_id);
+                const originCallId = readOriginCallId(l.metadata);
+                const row = recurrenceCheck.get(l.fingerprint, l.fingerprint, l.project_id, l.project_id, originCallId, originCallId);
                 const c = row?.c ?? 0;
                 if (c === 0) {
                     bumpOne.run(RELEVANCE_MAX, RELEVANCE_BUMP, l.id);
@@ -361,10 +623,112 @@ export class MemoryService {
         });
         return boosted;
     }
+    /**
+     * v0.3.0 (K3-013) — Feedback loop negative half.
+     *
+     * For each reflector-sourced error memory from this session whose
+     * fingerprint DID recur as a failing tool_call (the lesson didn't
+     * prevent the error), decrement `relevance_score` by `RELEVANCE_PENALTY`
+     * (down to zero) and increment `evidence_count` as a negative signal.
+     * Agent-saved memories are NEVER penalized.
+     *
+     * Returns the number of memories penalized.
+     */
+    /**
+     * v0.3.0 fix — Mirror of the free function `countSupersedeCandidates`
+     * exposed as an instance method so `okf-import` (which holds a
+     * `MemoryService` reference but not the underlying `Store`) can count
+     * rows that `save()` will mark as superseded.
+     */
+    countSupersedeCandidates(type, fingerprint, projectId) {
+        return countSupersedeCandidates(this.store, type, fingerprint, projectId);
+    }
+    penalizeRecurringReflectors(sessionId) {
+        if (!sessionId)
+            return 0;
+        const RELEVANCE_PENALTY = 0.05;
+        // v0.3.0 fix — to support cross-session feedback we drop the
+        // memory-side `source_session` filter: any reflector error whose
+        // fingerprint recurs as a failing tool_call IN THIS session is
+        // eligible for penalization (the lesson didn't prevent the error).
+        // The recurrence check narrows on `tool_calls.session_id = ?` and
+        // excludes the original failing call via `origin_call_id` metadata,
+        // matching both new `error_fingerprint` and legacy `fingerprint`.
+        const lessons = this.store
+            .prepare(`SELECT id, fingerprint, project_id, metadata
+				 FROM memories
+				 WHERE origin = 'reflector'
+				   AND type = 'error'
+				   AND fingerprint IS NOT NULL
+				   AND status = 'active'`)
+            .all();
+        if (lessons.length === 0)
+            return 0;
+        const recurrenceCheck = this.store.prepare(`SELECT COUNT(*) AS c
+			 FROM tool_calls
+			 WHERE session_id = ?
+			   AND success = 0
+			   AND (error_fingerprint = ? OR fingerprint = ?)
+			   AND (project_id IS ? OR (project_id IS NULL AND ? IS NULL))
+			   AND (? IS NULL OR id <> ?)`);
+        const settledCheck = this.store.prepare(`SELECT 1 FROM kevin_injections
+			  WHERE session_id = ? AND memory_id = ? AND outcome = 'ineffective'
+			  LIMIT 1`);
+        const penalizeOne = this.store.prepare(`UPDATE memories
+			 SET relevance_score = MAX(0, relevance_score - ?),
+			     recurrence_count = recurrence_count + 1,
+			     last_verified_at = datetime('now')
+			 WHERE id = ?`);
+        const penalizeRelevanceOnly = this.store.prepare(`UPDATE memories
+			 SET relevance_score = MAX(0, relevance_score - ?),
+			     last_verified_at = datetime('now')
+			 WHERE id = ?`);
+        let penalized = 0;
+        this.store.transaction(() => {
+            for (const l of lessons) {
+                const originCallId = readOriginCallId(l.metadata);
+                const row = recurrenceCheck.get(sessionId, l.fingerprint, l.fingerprint, l.project_id, l.project_id, originCallId, originCallId);
+                const c = row?.c ?? 0;
+                if (c > 0) {
+                    // v0.4.0 (K4-025) — no double-charge: when the
+                    // session's injection of this memory was already
+                    // settled `ineffective`, `InjectionLedger.settle`
+                    // charged recurrence_count (K4-007) and this pass
+                    // only applies the relevance penalty. The +1 charge
+                    // below is the pre-ledger path (K4-011) for memories
+                    // that were never injected this session.
+                    const settled = settledCheck.get(sessionId, l.id);
+                    if (settled) {
+                        penalizeRelevanceOnly.run(RELEVANCE_PENALTY, l.id);
+                    }
+                    else {
+                        // v0.4.0 (K4-011) — recurrence is negative evidence:
+                        // it bumps `recurrence_count`, NOT `evidence_count`
+                        // (the old code counted recurrence as positive
+                        // evidence). No `memories_superseded` increment here —
+                        // supersede is only counted when a decision/rule is
+                        // truly replaced (see save()).
+                        penalizeOne.run(RELEVANCE_PENALTY, l.id);
+                        // v0.4.0 (K4-025 / plan §5.1 rule 4, D4-06) — same
+                        // recurrence-expels rule the settle enforces: at
+                        // `recurrence_count >= 3` the error lesson is demoted
+                        // to `status='stale'`.
+                        this.store
+                            .prepare(`UPDATE memories SET status = 'stale'
+								  WHERE id = ? AND recurrence_count >= 3`)
+                            .run(l.id);
+                    }
+                    penalized += 1;
+                }
+            }
+        });
+        return penalized;
+    }
 }
 function originBoost(mem) {
     switch (mem.origin ?? "agent") {
         case "reflector":
+        case "causal":
             return ORIGIN_BOOST_REFLECTOR;
         case "pattern":
             return ORIGIN_BOOST_PATTERN;
@@ -372,6 +736,50 @@ function originBoost(mem) {
             return ORIGIN_BOOST_AGENT;
     }
 }
+/**
+ * v0.3.0 fix — Extract `origin_call_id` from the memory metadata blob.
+ *
+ * Reflector stores the failing tool_call id in metadata.origin_call_id
+ * (when available) so the feedback loop can exclude the original call
+ * from the recurrence count. Returns null when metadata is absent,
+ * malformed, or lacks the field.
+ */
+function readOriginCallId(metadata) {
+    if (!metadata)
+        return null;
+    try {
+        const parsed = JSON.parse(metadata);
+        const id = parsed?.origin_call_id;
+        return typeof id === "string" && id.length > 0 ? id : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * v0.3.0 fix — Count active memories that would be superseded by a new
+ * row with the given (type, fingerprint, projectId) tuple. Used by
+ * `okf-import` to populate `ImportResult.superseded` accurately.
+ *
+ * Matches the supersede logic in `save()`: only `decision` and `rule`
+ * types supersede prior rows with the same fingerprint. Returns 0 for
+ * any other type.
+ */
+export function countSupersedeCandidates(store, type, fingerprint, projectId) {
+    if (!fingerprint)
+        return 0;
+    if (type !== "decision" && type !== "rule")
+        return 0;
+    const row = store
+        .prepare(`SELECT COUNT(*) AS c
+			 FROM memories
+			 WHERE type IN ('decision', 'rule')
+			   AND fingerprint = ?
+			   AND status = 'active'
+			   AND (project_id IS ? OR (project_id IS NULL AND ? IS NULL))`)
+        .get(fingerprint, projectId, projectId);
+    return row?.c ?? 0;
+}
 function rankScore(mem) {
     // FTS5 bm25 returns a negative score (more negative = better match).
     // For non-FTS rows (loadAll path), fall back to -relevance_score so