@jmtrin/opencode-kevin 1.0.0 → 1.2.0

package/dist/plugin/DashboardHtml.js

@@ -0,0 +1,180 @@
+// v1.2.0 (K12-017 / plan §4.4 R2, D12-10) — static dashboard generator.
+// Single self-contained file: inline CSS/JS, snapshot data embedded as const DATA.
+// Zero network: no fetch, no XHR, no WebSocket, no external asset.
+import { createHash } from "node:crypto";
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const CAP_BYTES = 512 * 1024;
+function byteLen(s) {
+    return Buffer.byteLength(s, "utf8");
+}
+// HTML escaping — mirrors escapeInjectedText discipline (C-09 family).
+export function escapeHtml(text) {
+    return text
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+export function proposalToken(proposalId, proposedText) {
+    return createHash("sha256")
+        .update(`${proposalId}\0${proposedText}`, "utf8")
+        .digest("hex")
+        .slice(0, 16);
+}
+function truncateForHtml(views, cap) {
+    // Estimate html size; if over cap, truncate diffs progressively.
+    let html = renderDashboardInner(views, false);
+    if (byteLen(html) <= cap)
+        return views;
+    // First pass: cap diffs to 2000 chars
+    let truncated = {
+        ...views,
+        proposals: views.proposals.map((p) => {
+            if (p.diff.length <= 2000)
+                return p;
+            return {
+                ...p,
+                diff: `${p.diff.slice(0, 2000)}\n…[truncated]`,
+                truncated: true,
+            };
+        }),
+    };
+    html = renderDashboardInner(truncated, false);
+    if (byteLen(html) <= cap)
+        return truncated;
+    // Second: 800 chars
+    truncated = {
+        ...views,
+        proposals: views.proposals.map((p) => ({
+            ...p,
+            diff: p.diff.length > 800 ? `${p.diff.slice(0, 800)}\n…[truncated]` : p.diff,
+            truncated: p.diff.length > 800 ? true : p.truncated,
+        })),
+        conflicts: views.conflicts.map((c) => ({
+            ...c,
+            a_summary: c.a_summary.slice(0, 200),
+            b_summary: c.b_summary.slice(0, 200),
+        })),
+    };
+    html = renderDashboardInner(truncated, false);
+    if (byteLen(html) <= cap)
+        return truncated;
+    // Third: drop diffs to 400 chars
+    truncated = {
+        ...views,
+        proposals: views.proposals.map((p) => ({
+            ...p,
+            diff: `${p.diff.slice(0, 400)}\n…[truncated]`,
+            truncated: true,
+        })),
+    };
+    return truncated;
+}
+function renderDashboardInner(views, _withTruncation) {
+    const css = "*{box-sizing:border-box}body{font-family:ui-monospace,monospace;margin:0;padding:16px;background:#0f1115;color:#e6e6e6}a{color:#8ab4ff}header{border-bottom:1px solid #2a2e39;padding-bottom:12px;margin-bottom:16px}h1{margin:0;font-size:20px}h2{font-size:16px;margin:24px 0 8px;border-bottom:1px solid #222;padding-bottom:4px}.card{border:1px solid #2a2e39;border-radius:8px;padding:12px;margin:8px 0;background:#151821}.muted{color:#9aa0b2;font-size:12px}.badge{display:inline-block;padding:2px 6px;border-radius:999px;font-size:11px;border:1px solid #2a2e39}.badge-healthy{background:#12331a;color:#8ef0a0}.badge-degraded{background:#331a1a;color:#f0a0a0}.badge-unknown{background:#2a2a33;color:#c0c0d0}pre{white-space:pre-wrap;word-break:break-word;background:#0b0d12;padding:8px;border-radius:6px;overflow:auto;max-height:320px;font-size:12px}table{width:100%;border-collapse:collapse;font-size:12px}th,td{border:1px solid #2a2e39;padding:4px 6px;text-align:left}button{cursor:pointer;background:#1f2330;color:#e6e6e6;border:1px solid #2a2e39;border-radius:6px;padding:4px 8px;font-size:12px}button:hover{background:#2a3045}.grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:8px}.cols{display:grid;grid-template-columns:1fr 1fr;gap:12px}.count{font-size:11px;color:#9aa0b2}";
+    // Build proposals HTML server-side
+    const proposalsHtml = views.proposals.length === 0
+        ? `<div class="muted">No pending proposals.</div>`
+        : views.proposals
+            .map((p) => {
+            const token = p.token ?? proposalToken(p.id, p.diff);
+            const approveCmd = `/kevin-approve ${p.id} ${token}`;
+            const rejectCmd = `/kevin-reject ${p.id} ${token}`;
+            return `<div class="card">
+<div><strong>${escapeHtml(p.kind)}</strong> <span class="muted">${escapeHtml(p.id)}</span> <span class="badge">${escapeHtml(p.target_path)}</span> <span class="muted">${escapeHtml(p.created_at)}</span>${p.truncated ? ` <span class="badge">truncated</span>` : ""}</div>
+<div class="muted">memories: ${escapeHtml(p.memory_ids.join(", "))}</div>
+<pre>${escapeHtml(p.diff)}</pre>
+<div style="display:flex;gap:8px;margin-top:8px">
+<button data-copy="${escapeHtml(approveCmd)}" onclick="copyCmd(this)">Copy approve</button>
+<button data-copy="${escapeHtml(rejectCmd)}" onclick="copyCmd(this)">Copy reject</button>
+</div>
+<div class="muted copy-hint"></div>
+</div>`;
+        })
+            .join("\n");
+    const conflictsHtml = views.conflicts.length === 0
+        ? `<div class="muted">No open conflicts.</div>`
+        : views.conflicts
+            .map((c) => {
+            const ackCmd = `/kevin-ack ${c.id}`;
+            return `<div class="card">
+<div><strong>${escapeHtml(c.kind)}</strong> <span class="muted">${escapeHtml(c.id)}</span> <span class="muted">${escapeHtml(c.opened_at)}</span></div>
+<div class="cols"><div><div class="muted">A</div><pre>${escapeHtml(c.a_summary)}</pre></div><div><div class="muted">B</div><pre>${escapeHtml(c.b_summary)}</pre></div></div>
+<div style="margin-top:8px"><button data-copy="${escapeHtml(ackCmd)}" onclick="copyCmd(this)">Copy ack</button> <span class="muted copy-hint"></span></div>
+</div>`;
+        })
+            .join("\n");
+    const verdictClass = views.health.verdict === "healthy"
+        ? "badge-healthy"
+        : views.health.verdict === "degraded"
+            ? "badge-degraded"
+            : "badge-unknown";
+    const hooksRows = views.health.hooks.length === 0
+        ? `<tr><td colspan="4" class="muted">No hooks</td></tr>`
+        : views.health.hooks
+            .map((h) => `<tr><td>${escapeHtml(h.hook)}</td><td>${escapeHtml(h.state)}</td><td>${h.fire_count}</td><td>${h.expected_count}</td></tr>`)
+            .join("\n");
+    const perfRows = views.health.perf.length === 0
+        ? `<tr><td colspan="4" class="muted">No perf data</td></tr>`
+        : views.health.perf
+            .map((p) => `<tr><td>${escapeHtml(p.scope)}</td><td>${p.p95}</td><td>${p.budget_p95}</td><td>${p.within_budget ? "yes" : "no"}</td></tr>`)
+            .join("\n");
+    const countersHtml = Object.keys(views.health.counters).length === 0
+        ? `<div class="muted">No counters</div>`
+        : `<div class="grid">${Object.entries(views.health.counters)
+            .map(([k, v]) => `<div class="card"><div class="muted">${escapeHtml(k)}</div><div><strong>${v}</strong></div></div>`)
+            .join("\n")}</div>`;
+    // Embedded DATA — escape every "<" to \u003c so hostile "<script>" can never appear verbatim inside the <script> block.
+    const dataJson = JSON.stringify(views).replace(/</g, "\\u003c");
+    const js = `function copyCmd(btn){var cmd=btn.getAttribute('data-copy');var hint=btn.parentElement.nextElementSibling;function done(t){if(hint)hint.textContent=t;setTimeout(function(){if(hint)hint.textContent='';},2500);}if(navigator.clipboard&&navigator.clipboard.writeText){navigator.clipboard.writeText(cmd).then(function(){done('Copied: '+cmd+' — paste into your opencode session');},function(){fallback(cmd,done);});}else{fallback(cmd,done);}}function fallback(cmd,done){var ta=document.createElement('textarea');ta.value=cmd;ta.style.position='fixed';ta.style.opacity='0';document.body.appendChild(ta);ta.select();try{document.execCommand('copy');done('Copied: '+cmd+' — paste into your opencode session');}catch(e){done('Copy failed — manually copy: '+cmd);}document.body.removeChild(ta);}`;
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Kevin — Dashboard</title>
+<style>${css}</style>
+</head>
+<body>
+<header>
+<h1>Kevin — Surface Dashboard</h1>
+<div class="muted">Generated at ${escapeHtml(views.generatedAt)} · <span class="badge ${verdictClass}">${escapeHtml(views.health.verdict)}</span> ${escapeHtml(views.health.reason)} · contract ${escapeHtml(views.health.contract_digest)}</div>
+<div class="muted">Proposals ${views.proposals.length} · Conflicts ${views.conflicts.length} · Paste copied <code>/kevin-*</code> commands into your opencode session (Desktop or CLI).</div>
+</header>
+
+<section>
+<h2>Proposals</h2>
+${proposalsHtml}
+</section>
+
+<section>
+<h2>Conflicts</h2>
+${conflictsHtml}
+</section>
+
+<section>
+<h2>Health</h2>
+<table><thead><tr><th>hook</th><th>state</th><th>fires</th><th>expected</th></tr></thead><tbody>${hooksRows}</tbody></table>
+<table style="margin-top:12px"><thead><tr><th>scope</th><th>p95 ms</th><th>budget p95</th><th>within</th></tr></thead><tbody>${perfRows}</tbody></table>
+<div style="margin-top:12px">${countersHtml}</div>
+</section>
+
+<script>const DATA=${dataJson};${js}</script>
+</body>
+</html>`;
+}
+export function renderDashboard(views) {
+    const capped = truncateForHtml(views, CAP_BYTES);
+    return renderDashboardInner(capped, true);
+}
+export function writeDashboard(root, views) {
+    const dir = join(root, "tui");
+    mkdirSync(dir, { recursive: true });
+    const html = renderDashboard(views);
+    const target = join(dir, "dashboard.html");
+    const tmp = `${target}.tmp`;
+    writeFileSync(tmp, html, "utf8");
+    renameSync(tmp, target);
+    return target;
+}

package/dist/plugin/Feedback.js

@@ -1,3 +1,4 @@
+import { hasFeedbackTable } from "./columns.js";
 import { uuidv7 } from "./uuid.js";
 const POSITIVE_VERDICTS = ["useful"];
 const NEGATIVE_VERDICTS = [
@@ -5,25 +6,7 @@ const NEGATIVE_VERDICTS = [
     "outdated",
     "ignore",
 ];
-// v0.5.0 — pre-006 DBs lack `memory_feedback`; record() fails loudly with a
-// descriptive error instead of a bare "no such table" (the tool layer turns
-// it into a graceful message).
-// v0.6.0 (K6-001a) — positive-only caching: a successful probe is cached,
-// a failed probe is NOT. A Store migrated in place heals on the next call.
-const feedbackTableCache = new WeakMap();
-function hasFeedbackTable(store) {
-    const cached = feedbackTableCache.get(store);
-    if (cached === true)
-        return true;
-    try {
-        store.prepare("SELECT COUNT(*) FROM memory_feedback").get();
-        feedbackTableCache.set(store, true);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
+// v1.1.0 (K11-011) — table probe delegates to columns registry
 export class Feedback {
     store;
     metrics;

package/dist/plugin/HookLiveness.d.ts

@@ -37,6 +37,7 @@ interface HookLivenessOptions {
 export declare class HookLiveness {
     private readonly store;
     private readonly options;
+    excessArityCount: number;
     private readonly counters;
     private readonly seenSessions;
     private readonly suppressedSessions;

package/dist/plugin/HookLiveness.js

@@ -25,6 +25,8 @@ export function parseThreshold(text) {
 export class HookLiveness {
     store;
     options;
+    // v1.1.0 (K11-015) — debug counter for excess arity; never logged on hot path
+    excessArityCount = 0;
     counters;
     seenSessions;
     suppressedSessions = new Set();
@@ -228,34 +230,16 @@ export class HookLiveness {
             }
             throw e;
         };
-        const n = delegate.length;
-        if (n === 0) {
-            return async () => {
-                try {
-                    const result = await delegate();
-                    record();
-                    return result;
-                }
-                catch (e) {
-                    return recordError(e);
-                }
-            };
-        }
-        if (n === 1) {
-            return async (a) => {
-                try {
-                    const result = await delegate(a);
-                    record();
-                    return result;
-                }
-                catch (e) {
-                    return recordError(e);
-                }
-            };
-        }
-        return async (a, b) => {
+        // v1.1.0 (K11-015) — arity guard: maximum supported arity is 2 (plan §5.5).
+        // Excess args are sliced and counted via excessArityCount; never logged.
+        return async (...args) => {
+            let callArgs = args;
+            if (args.length > 2) {
+                this.excessArityCount++;
+                callArgs = args.slice(0, 2);
+            }
             try {
-                const result = await delegate(a, b);
+                const result = await delegate(...callArgs);
                 record();
                 return result;
             }

package/dist/plugin/InjectionLedger.js

@@ -1,3 +1,6 @@
+import { readOriginCallId } from "./MemoryService.js";
+import { hasColumn } from "./columns.js";
+import { toMs } from "./time-ms.js";
 import { uuidv7 } from "./uuid.js";
 export class InjectionLedger {
     store;
@@ -11,11 +14,21 @@ export class InjectionLedger {
      * duplicates are expected only via the caller's per-session seen-set.
      */
     record(input) {
-        this.store
-            .prepare(`INSERT INTO kevin_injections
-				   (id, memory_id, fingerprint, session_id, hook, tokens, outcome)
-				 VALUES (?, ?, ?, ?, ?, ?, 'unmeasured')`)
-            .run(uuidv7(), input.memoryId, input.fingerprint, input.sessionId, input.hook, input.tokens);
+        // v1.1.0 (K11-003 / plan §5.2, D11-01) — dual-write injected_at_ms when column exists
+        if (hasColumn(this.store, "kevin_injections", "injected_at_ms")) {
+            this.store
+                .prepare(`INSERT INTO kevin_injections
+					   (id, memory_id, fingerprint, session_id, hook, tokens, outcome, injected_at_ms)
+					 VALUES (?, ?, ?, ?, ?, ?, 'unmeasured', ?)`)
+                .run(uuidv7(), input.memoryId, input.fingerprint, input.sessionId, input.hook, input.tokens, Date.now());
+        }
+        else {
+            this.store
+                .prepare(`INSERT INTO kevin_injections
+					   (id, memory_id, fingerprint, session_id, hook, tokens, outcome)
+					 VALUES (?, ?, ?, ?, ?, ?, 'unmeasured')`)
+                .run(uuidv7(), input.memoryId, input.fingerprint, input.sessionId, input.hook, input.tokens);
+        }
         this.metrics?.incr("injections_total", 1);
         // v0.8.0 (K8-024 / plan §5.7) — shared-layer consumption is counted
         // separately so the audit can tell how much of the push channel
@@ -40,20 +53,24 @@ export class InjectionLedger {
      * recent injection").
      */
     settle(sessionId) {
-        const injections = this.store
-            .prepare(`SELECT id, memory_id, fingerprint, injected_at, outcome
-				   FROM kevin_injections
-				  WHERE session_id = ?
-				  ORDER BY injected_at ASC, id ASC`)
-            .all(sessionId);
+        // v1.1.0 (K11-003 / plan §5.2, D11-01/D11-07) — ms-aware settle: readers
+        // prefer _ms and fall back to legacy string. Column probes are cached.
+        const hasInjMs = hasColumn(this.store, "kevin_injections", "injected_at_ms");
+        const hasToolMs = hasColumn(this.store, "tool_calls", "ts_ms");
+        const injections = (hasInjMs
+            ? this.store.prepare(`SELECT id, memory_id, fingerprint, injected_at, injected_at_ms, outcome
+						   FROM kevin_injections
+						  WHERE session_id = ?
+						  ORDER BY injected_at ASC, id ASC`)
+            : this.store.prepare(`SELECT id, memory_id, fingerprint, injected_at, outcome
+						   FROM kevin_injections
+						  WHERE session_id = ?
+						  ORDER BY injected_at ASC, id ASC`)).all(sessionId);
         for (const inj of injections) {
             // Same identity dimension CausalChain uses: the failing call's
             // `error_fingerprint` (stamped by Reflector) or the legacy
-            // `fingerprint` hash. `ts` and `injected_at` are both
-            // `datetime('now')` text → lexicographic comparison is valid.
-            // COUNT (not LIMIT 1): every failing call after the injection
-            // is a recurrence — the charge must reach 3 so D4-06 expels
-            // the lesson.
+            // `fingerprint` hash.
+            // v1.1.0 — time comparison uses toMs helper (prefers _ms).
             //
             // BUG-003 — the exemption is now bounded to the lesson's OWN
             // creating call (memories.metadata.origin_call_id, stamped by
@@ -65,17 +82,50 @@ export class InjectionLedger {
             // precision. Memories without a tracked creating call (agent-
             // saved, test fixtures) get no exemption: only the `ts >=
             // injected_at` bound applies.
-            const originCallId = readOriginCallId(this.store, inj.memory_id);
-            const countRow = this.store
-                .prepare(`SELECT COUNT(*) AS n FROM tool_calls
-					  WHERE session_id = ?
-					    AND success = 0
-					    AND COALESCE(error_fingerprint, fingerprint) = ?
-					    AND ts >= ?
-					    AND (? IS NULL OR id != ?)
-					 LIMIT 1`)
-                .get(sessionId, inj.fingerprint, inj.injected_at, originCallId, originCallId);
-            const n = countRow.n;
+            const metaRow = this.store
+                .prepare("SELECT metadata FROM memories WHERE id = ?")
+                .get(inj.memory_id);
+            const originCallId = readOriginCallId(metaRow?.metadata ?? null);
+            // v1.1.0 — heuristic: when legacy string and _ms diverge by >2s
+            // (manual UPDATE of injected_at in tests), trust the string
+            // because the ms reflects wall time at record, not the pinned
+            // fixture time. Real rows differ by <1s (second truncation).
+            const rawInjMs = inj.injected_at_ms ?? null;
+            const stringMs = inj.injected_at
+                ? Date.parse(`${inj.injected_at.replace(" ", "T")}Z`)
+                : null;
+            const injectedMs = rawInjMs !== null &&
+                stringMs !== null &&
+                !Number.isNaN(stringMs) &&
+                Math.abs(rawInjMs - stringMs) > 2000
+                ? stringMs
+                : toMs(inj.injected_at, rawInjMs);
+            // Fetch candidate failing calls for this fingerprint and filter by ms
+            const failRows = (hasToolMs
+                ? this.store.prepare(`SELECT id, ts, ts_ms FROM tool_calls
+							  WHERE session_id = ?
+							    AND success = 0
+							    AND COALESCE(error_fingerprint, fingerprint) = ?`)
+                : this.store.prepare(`SELECT id, ts FROM tool_calls
+							  WHERE session_id = ?
+							    AND success = 0
+							    AND COALESCE(error_fingerprint, fingerprint) = ?`)).all(sessionId, inj.fingerprint);
+            let n = 0;
+            for (const r of failRows) {
+                if (originCallId !== null && r.id === originCallId)
+                    continue;
+                const tsMs = toMs(r.ts, r.ts_ms ?? null);
+                if (injectedMs !== null && tsMs !== null) {
+                    if (tsMs < injectedMs)
+                        continue;
+                }
+                else {
+                    // fallback to string comparison when either side missing (legacy)
+                    if (r.ts < inj.injected_at)
+                        continue;
+                }
+                n++;
+            }
             // v0.5.0 (K5-005 / plan §5.1, D5-01) — three-way settlement:
             //   recurrences >= 1 → ineffective  (existing side effects unchanged)
             //   else fixes >= 1  → effective    (a linked fix was OBSERVED)
@@ -97,7 +147,7 @@ export class InjectionLedger {
 						            OR ? > last_injected_at
 						            THEN ? ELSE last_injected_at END
 						  WHERE fingerprint = ? AND id = ?`)
-                    .run(countRow.n, inj.injected_at, inj.injected_at, inj.fingerprint, inj.memory_id);
+                    .run(n, inj.injected_at, inj.injected_at, inj.fingerprint, inj.memory_id);
                 // v0.4.0 (K4-025 / plan §5.1 rule 4, D4-06) — recurrence
                 // expels: a fingerprint at `recurrence_count >= 3` is
                 // demoted to `status='stale'` and never injected again
@@ -116,15 +166,31 @@ export class InjectionLedger {
                 // `ts >= injected_at` bound and `session_id = ?` filter are
                 // kept; there is no `origin_call_id` exemption for fixes —
                 // a fix is not the creating call.
-                const fixRow = this.store
-                    .prepare(`SELECT COUNT(*) AS m FROM tool_calls
-						  WHERE session_id = ?
-						    AND success = 1
-						    AND fix_for_fingerprint = ?
-						    AND ts >= ?
-						 LIMIT 1`)
-                    .get(sessionId, inj.fingerprint, inj.injected_at);
-                if (fixRow.m >= 1) {
+                // v1.1.0 — ms-aware: fetch and filter via toMs.
+                const fixCandidates = (hasToolMs
+                    ? this.store.prepare(`SELECT ts, ts_ms FROM tool_calls
+								  WHERE session_id = ?
+								    AND success = 1
+								    AND fix_for_fingerprint = ?`)
+                    : this.store.prepare(`SELECT ts FROM tool_calls
+								  WHERE session_id = ?
+								    AND success = 1
+								    AND fix_for_fingerprint = ?`)).all(sessionId, inj.fingerprint);
+                let hasFix = false;
+                for (const fr of fixCandidates) {
+                    const tsMs = toMs(fr.ts, fr.ts_ms ?? null);
+                    if (injectedMs !== null && tsMs !== null) {
+                        if (tsMs >= injectedMs) {
+                            hasFix = true;
+                            break;
+                        }
+                    }
+                    else if (fr.ts >= inj.injected_at) {
+                        hasFix = true;
+                        break;
+                    }
+                }
+                if (hasFix) {
                     this.store
                         .prepare(`UPDATE kevin_injections SET outcome = 'effective'
 							  WHERE id = ?`)
@@ -226,23 +292,4 @@ export class InjectionLedger {
         return out;
     }
 }
-/**
- * BUG-003 — read `origin_call_id` (the failing tool_call that CREATED the
- * memory) from memories.metadata, mirroring the feedback loop's
- * `readOriginCallId` in MemoryService. Returns null when absent/malformed.
- */
-function readOriginCallId(store, memoryId) {
-    const row = store
-        .prepare("SELECT metadata FROM memories WHERE id = ?")
-        .get(memoryId);
-    if (!row?.metadata)
-        return null;
-    try {
-        const parsed = JSON.parse(row.metadata);
-        const id = parsed?.origin_call_id;
-        return typeof id === "string" && id.length > 0 ? id : null;
-    }
-    catch {
-        return null;
-    }
-}
+// v1.1.0 — readOriginCallId deduplicated: imported from MemoryService (K11-003/K11-013)

package/dist/plugin/Materializer.js

@@ -2,100 +2,13 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { firstSentence } from "./Curator.js";
 import { normalize } from "./fingerprint.js";
+import { STOP_WORDS } from "./query-tokenizer.js";
 export const SKILL_TOPIC = "project-knowledge";
 /** Hash-like noise: FNV-1a output is 16 lowercase hex chars; an 8+ hex
  * token is indistinguishable from a fingerprint prefix and must never
  * become a topic (D6-14). */
 const HEX_LIKE_RE = /^[0-9a-f]{8,}$/;
 const TOKEN_RE = /[^a-z0-9]+/;
-/** Conservative English function words; code-adjacent meaning-bearing
- * words (npm, ts2304, cargo...) are deliberately NOT stop-words. */
-const STOP_WORDS = new Set([
-    "a",
-    "about",
-    "after",
-    "again",
-    "all",
-    "also",
-    "an",
-    "and",
-    "any",
-    "are",
-    "as",
-    "at",
-    "be",
-    "been",
-    "before",
-    "being",
-    "but",
-    "by",
-    "can",
-    "could",
-    "did",
-    "do",
-    "does",
-    "for",
-    "from",
-    "had",
-    "has",
-    "have",
-    "he",
-    "her",
-    "his",
-    "if",
-    "in",
-    "into",
-    "is",
-    "it",
-    "its",
-    "may",
-    "might",
-    "more",
-    "most",
-    "must",
-    "not",
-    "of",
-    "on",
-    "one",
-    "or",
-    "our",
-    "per",
-    "shall",
-    "she",
-    "so",
-    "than",
-    "that",
-    "the",
-    "their",
-    "them",
-    "then",
-    "there",
-    "these",
-    "they",
-    "this",
-    "those",
-    "through",
-    "to",
-    "too",
-    "under",
-    "up",
-    "us",
-    "via",
-    "was",
-    "we",
-    "were",
-    "what",
-    "when",
-    "where",
-    "which",
-    "while",
-    "who",
-    "will",
-    "with",
-    "would",
-    "you",
-    "your",
-]);
 /** Sanitize a memory type into a filesystem-safe topic prefix. */
 function sanitizeType(type) {
     const cleaned = type

package/dist/plugin/MemoryService.d.ts

@@ -160,8 +160,55 @@ export interface GetRelevantInput {
      */
     now?: Date;
 }
+interface MemoryRow {
+    id: string;
+    type: MemoryType;
+    content: string;
+    scope: MemoryScope;
+    relevance_score: number;
+    source_tool: string | null;
+    source_session: string | null;
+    metadata: string | null;
+    created_at: string;
+    updated_at: string;
+    expires_at: string | null;
+    /** v0.2.0 columns — nullable for rows from pre-003 DBs. */
+    project_id?: string | null;
+    fingerprint?: string | null;
+    origin?: MemoryOrigin | null;
+    /** v0.3.0 */
+    evidence_count?: number;
+    last_verified_at?: string | null;
+    status?: string;
+    /** v0.4.0 */
+    recurrence_count?: number;
+    /** v0.4.0 */
+    fix_args?: string | null;
+    /** v0.5.0 (K5-009) */
+    ignored?: number;
+    /** v0.5.0 (K5-009) */
+    superseded_by?: string | null;
+    /** v0.5.0 (K5-010) */
+    feedback_positive?: number;
+    /** v0.5.0 (K5-010) */
+    feedback_negative?: number;
+    /** v0.6.0 (K6-011 / migration 007) */
+    curated?: number;
+    /** v0.6.0 (K6-011 / migration 007) */
+    curated_at?: string | null;
+    /** v0.6.0 (K6-011 / migration 007) — 1 = inferable, 0 = non_inferable,
+     * NULL = unknown. */
+    inferable?: number | null;
+    /** v0.7.0 (K7-008 / migration 008) — de-ranking penalty in [0, 0.5]. */
+    truth_penalty?: number | null;
+    /** v0.7.0 (K7-008 / migration 008) — first contradiction timestamp. */
+    contradicted_at?: string | null;
+    /** v0.8.0 (K8-018 / migration 009) — layer marker on the row. */
+    layer?: string | null;
+}
 export declare const DATE_NOW = "2099-01-01T00:00:00.000Z";
 export declare function hasRepoIdColumn(store: Store): boolean;
+export declare function mapRow(row: MemoryRow, score?: number): Memory;
 export declare class MemoryService {
     private readonly metrics;
     constructor(store: Store, metrics?: Metrics | null, repoId?: string | null);
@@ -169,7 +216,6 @@ export declare class MemoryService {
     private repoId;
     setRepoId(repoId: string | null): void;
     private hasRecurrenceColumn;
-    private _hasRecurrenceColumn;
     private hasIgnoredColumn;
     private hasCuratedColumn;
     private hasTruthColumns;
@@ -290,6 +336,17 @@ export declare class MemoryService {
     countSupersedeCandidates(type: MemoryType, fingerprint: string | null | undefined, projectId: string | null): number;
     penalizeRecurringReflectors(sessionId: string): number;
 }
+/**
+ * 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.
+ * // v1.1.0 (K11-003 / plan §5.5, D11-05) — single source for origin lookup;
+ * // InjectionLedger reuses this implementation (K11-013).
+ */
+export declare function readOriginCallId(metadata: string | null): string | 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
@@ -300,3 +357,4 @@ export declare class MemoryService {
  * any other type.
  */
 export declare function countSupersedeCandidates(store: Store, type: MemoryType, fingerprint: string | null | undefined, projectId: string | null): number;
+export {};