@jmtrin/opencode-kevin 1.0.0 → 1.1.0

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 {};

package/dist/plugin/MemoryService.js

@@ -1,4 +1,5 @@
 import { deterministicFixLine } from "./LessonFixer.js";
+import { hasCuratedColumn as columnsHasCurated, hasIgnoredColumn as columnsHasIgnored, hasLayerColumn as columnsHasLayer, hasRecurrenceColumn as columnsHasRecurrence, hasRepoIdColumn as columnsHasRepoId, hasTruthColumns as columnsHasTruth, } from "./columns.js";
 import { computeConfidence } from "./confidence.js";
 import { fingerprint as computeFingerprint } from "./fingerprint.js";
 import { classify } from "./inferability.js";
@@ -82,106 +83,21 @@ const MEMORY_ROW_SELECT = `id, type, content, scope, relevance_score, source_too
                 metadata, created_at, updated_at, expires_at,
                 project_id, fingerprint, origin,
                 evidence_count, recurrence_count, last_verified_at, status, fix_args`;
-/**
- * v0.5.0 (K5-008/009 / plan §5.6) — cached per-store probe for the 006-only
- * `ignored` column (pre-006 DBs must not reference it). Shared by the
- * retrieval filter, the row SELECT, and the save() ignored stamp.
- * 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 ignoredColumnCache = new WeakMap();
+// v1.1.0 (K11-011 / plan §5.5, D11-06) — probes delegate to columns registry
 function hasIgnoredColumn(store) {
-    const cached = ignoredColumnCache.get(store);
-    if (cached === true)
-        return true;
-    try {
-        store.prepare("SELECT ignored FROM memories LIMIT 1").get();
-        ignoredColumnCache.set(store, true);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return columnsHasIgnored(store);
 }
-/**
- * v0.6.0 (K6-011 / plan §5.4) — cached per-store probe for the 007-only
- * `curated` column (pre-007 DBs must not reference it). Same positive-only
- * caching discipline as `ignored` (K6-001a): a successful probe is cached,
- * a failed probe is NOT.
- */
-const curatedColumnCache = new WeakMap();
 function hasCuratedColumn(store) {
-    const cached = curatedColumnCache.get(store);
-    if (cached === true)
-        return true;
-    try {
-        store.prepare("SELECT curated FROM memories LIMIT 1").get();
-        curatedColumnCache.set(store, true);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return columnsHasCurated(store);
 }
-/**
- * v0.7.0 (K7-008 / migration 008) — cached per-store probe for the 008-only
- * `truth_penalty` column (pre-008 DBs must not reference it). Same
- * positive-only caching discipline as `curated` (K6-001a).
- */
-const truthColumnsCache = new WeakMap();
 function hasTruthColumns(store) {
-    const cached = truthColumnsCache.get(store);
-    if (cached === true)
-        return true;
-    try {
-        store.prepare("SELECT truth_penalty FROM memories LIMIT 1").get();
-        truthColumnsCache.set(store, true);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return columnsHasTruth(store);
 }
-/**
- * v0.8.0 (K8-007 / plan §5.7) — cached per-store probe for the 009-only
- * `repo_id` column (pre-009 DBs must not reference it). Same positive-only
- * caching discipline as `ignored` (K6-001a): a successful probe is cached,
- * a failed probe is NOT. Exported so `kevin_audit`'s rollups scope on the
- * same column.
- */
-const repoIdColumnCache = new WeakMap();
 export function hasRepoIdColumn(store) {
-    const cached = repoIdColumnCache.get(store);
-    if (cached === true)
-        return true;
-    try {
-        store.prepare("SELECT repo_id FROM memories LIMIT 1").get();
-        repoIdColumnCache.set(store, true);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return columnsHasRepoId(store);
 }
-/**
- * v0.8.0 (K8-018 / plan §5.2) — cached per-store probe for the 009-only
- * `layer` column (pre-009 DBs must not reference it). Same positive-only
- * caching discipline: pre-009 databases have no shared layer, so the
- * immutability refusal in `update()` is skipped there entirely.
- */
-const layerColumnCache = new WeakMap();
 function hasLayerColumn(store) {
-    const cached = layerColumnCache.get(store);
-    if (cached === true)
-        return true;
-    try {
-        store.prepare("SELECT layer FROM memories LIMIT 1").get();
-        layerColumnCache.set(store, true);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return columnsHasLayer(store);
 }
 /**
  * v0.5.0 (K5-009 / plan §5.3) — the 006-only columns are appended when the
@@ -204,7 +120,7 @@ function rowSelect(store) {
         : withCurated;
     return hasLayerColumn(store) ? `${withTruth}, layer` : withTruth;
 }
-function mapRow(row, score) {
+export function mapRow(row, score) {
     const mem = {
         id: row.id,
         type: row.type,
@@ -320,21 +236,10 @@ export class MemoryService {
     }
     // v0.4.0 (BUG-008) — cached column probe for pre-005 DBs (which lack
     // `recurrence_count`); save() must not reference the column there.
+    // v1.1.0 (K11-011) — delegates to columns registry
     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;
+        return columnsHasRecurrence(this.store);
     }
-    _hasRecurrenceColumn;
     // v0.5.0 (K5-008 / plan §5.6) — cached column probe for pre-006 DBs
     // (which lack `ignored`); the retrieval filter must not reference the
     // column there.
@@ -1246,8 +1151,10 @@ function originBoost(mem) {
  * (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).
  */
-function readOriginCallId(metadata) {
+export function readOriginCallId(metadata) {
     if (!metadata)
         return null;
     try {

package/dist/plugin/Migrate.js

@@ -247,6 +247,11 @@ export class Migrate {
             applied: pending.map((m) => m.version),
         };
     }
+    // v1.1.0 (K11-015) — lexicographic ordering is valid through "999" because
+    // versions are zero-padded 3-digit strings ("001" … "999"). Any future
+    // migration beyond 999 must use a 4-digit prefix and this comparison must
+    // become numeric (parseInt). Until then, string > works and keeps the
+    // migration idempotency simple (plan §5.5, D11-??).
     listPending(current) {
         let files = [];
         try {

package/dist/plugin/Retrospective.js

@@ -74,6 +74,10 @@ export const METRIC_KEY_LABELS = {
     dispose_misses_total: "Misses de dispose",
     contract_digest_changes: "Cambios de digest de contrato",
     bench_runs_total: "Ejecuciones de benchmark (totales)",
+    // v1.1.0 (K11-001 / plan §4) — drift metrics; labels required by BUG-014 regression.
+    bench_regression_failures: "Fallos de regresion de benchmark",
+    forget_requests_total: "Solicitudes de olvido totales",
+    forget_tombstones_published: "Tombstones publicados por olvido",
 };
 function originLabel(origin) {
     if (origin === "reflector")

package/dist/plugin/ToolCallObserver.js

@@ -1,3 +1,4 @@
+import { hasColumn } from "./columns.js";
 import { fingerprint as computeFingerprint } from "./fingerprint.js";
 import { redactPaths, stripPrivate } from "./redact.js";
 import { uuidv7 } from "./uuid.js";
@@ -54,11 +55,23 @@ export class ToolCallObserver {
                 return;
             }
         }
-        this.store
-            .prepare(`INSERT INTO tool_calls
-				 (id, session_id, ts, tool, args_summary, success, duration_ms, agent, error_type, metadata, project_id, fingerprint)
-				 VALUES (?, ?, datetime('now'), ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-            .run(input.callID ?? uuidv7(), sessionId, input.tool, argsSummary, success, durationMs, agent, errorType, metadata, projectId, fp);
+        // v1.1.0 (K11-002 / plan §5.2, D11-01/D11-07) — dual-write: legacy `ts`
+        // stays (`datetime('now')`), new `ts_ms` holds Date.now() when the
+        // column exists. Probe is cached via columns registry (K11-011).
+        if (hasColumn(this.store, "tool_calls", "ts_ms")) {
+            this.store
+                .prepare(`INSERT INTO tool_calls
+					 (id, session_id, ts, ts_ms, tool, args_summary, success, duration_ms, agent, error_type, metadata, project_id, fingerprint)
+					 VALUES (?, ?, datetime('now'), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(input.callID ?? uuidv7(), sessionId, Date.now(), input.tool, argsSummary, success, durationMs, agent, errorType, metadata, projectId, fp);
+        }
+        else {
+            this.store
+                .prepare(`INSERT INTO tool_calls
+					 (id, session_id, ts, tool, args_summary, success, duration_ms, agent, error_type, metadata, project_id, fingerprint)
+					 VALUES (?, ?, datetime('now'), ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(input.callID ?? uuidv7(), sessionId, input.tool, argsSummary, success, durationMs, agent, errorType, metadata, projectId, fp);
+        }
     }
     isDedupEnabled() {
         try {

package/dist/plugin/columns.d.ts

@@ -0,0 +1,11 @@
+import type { Store } from "./Store.js";
+export declare function hasColumn(store: Store, table: string, column: string): boolean;
+export declare function hasIgnoredColumn(store: Store): boolean;
+export declare function hasCuratedColumn(store: Store): boolean;
+export declare function hasTruthColumns(store: Store): boolean;
+export declare function hasRepoIdColumn(store: Store): boolean;
+export declare function hasLayerColumn(store: Store): boolean;
+export declare function hasRecurrenceColumn(store: Store): boolean;
+export declare function hasArchivedColumn(store: Store): boolean;
+export declare function hasFeedbackColumns(store: Store): boolean;
+export declare function hasFeedbackTable(store: Store): boolean;