@jmtrin/opencode-kevin 1.0.0 → 1.2.0

package/dist/plugin/kevin_audit.js

@@ -1,3 +1,6 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import { effectivePrePromptCap } from "./ContextInjector.js";
 import { hasRepoIdColumn } from "./MemoryService.js";
 import { contractDigest, describeContract } from "./contract.js";
@@ -21,7 +24,7 @@ function scalar(store, sql, ...params) {
     const row = store.prepare(sql).get(...params);
     return row.n ?? 0;
 }
-export function buildAudit(store, metrics, capabilities = ALL_FALSE_CAPABILITIES, projectId, repoId) {
+export function buildAudit(store, metrics, capabilities = ALL_FALSE_CAPABILITIES, projectId, repoId, tuiRoot) {
     let partial = false;
     // Memories block: `total` + the three GROUP BYs are pre-006 safe; the
     // lifecycle counters need the 006 columns and fall back separately.
@@ -542,6 +545,70 @@ export function buildAudit(store, metrics, capabilities = ALL_FALSE_CAPABILITIES
         clause_count: liveContract.clauses.length,
         deprecated_count: liveContract.clauses.filter((c) => c.deprecated).length,
     };
+    // v1.2.0 (K12-014/K12-019) — TUI block: best-effort fs introspection (absent → nulls)
+    let tui;
+    try {
+        const enabled_setting = settings.tui_snapshots_enabled ?? "0";
+        const root = tuiRoot ?? join(homedir(), ".opencode-kevin", "tui");
+        let last_flush_age_s = null;
+        try {
+            const metaRaw = readFileSync(join(root, "meta.json"), "utf8");
+            const meta = JSON.parse(metaRaw);
+            if (meta.generatedAt) {
+                const age = (Date.now() - Date.parse(meta.generatedAt)) / 1000;
+                if (Number.isFinite(age) && age >= 0)
+                    last_flush_age_s = Math.floor(age);
+            }
+        }
+        catch { }
+        let mailbox_depth = null;
+        try {
+            if (existsSync(join(root, "actions.json"))) {
+                const raw = readFileSync(join(root, "actions.json"), "utf8");
+                const parsed = JSON.parse(raw);
+                if (Array.isArray(parsed.actions))
+                    mailbox_depth = parsed.actions.length;
+                else
+                    mailbox_depth = null;
+            }
+            else {
+                mailbox_depth = null;
+            }
+        }
+        catch {
+            mailbox_depth = null;
+        }
+        let last_results = null;
+        try {
+            const raw = readFileSync(join(root, "results.json"), "utf8");
+            last_results = JSON.parse(raw);
+        }
+        catch {
+            last_results = null;
+        }
+        let dashboard_last_write_age_s = null;
+        try {
+            const st = statSync(join(root, "dashboard.html"));
+            const age = (Date.now() - st.mtimeMs) / 1000;
+            if (Number.isFinite(age) && age >= 0)
+                dashboard_last_write_age_s = Math.floor(age);
+        }
+        catch {
+            dashboard_last_write_age_s = null;
+        }
+        const bridge_interceptions = metrics.get("tui_actions_invoked") ?? 0;
+        tui = {
+            enabled_setting,
+            last_flush_age_s,
+            mailbox_depth,
+            last_results,
+            dashboard_last_write_age_s,
+            bridge_interceptions,
+        };
+    }
+    catch {
+        tui = undefined;
+    }
     return {
         memories,
         injections,
@@ -558,6 +625,7 @@ export function buildAudit(store, metrics, capabilities = ALL_FALSE_CAPABILITIES
         host,
         perf,
         contract,
+        tui,
         partial,
     };
 }

package/dist/plugin/kevin_forget.d.ts

@@ -0,0 +1,33 @@
+import type { MemoryService } from "./MemoryService.js";
+import type { SharedLayer } from "./SharedLayer.js";
+import type { Store } from "./Store.js";
+import type { Metrics } from "./metrics.js";
+export interface ForgetInput {
+    ids: string[];
+    confirm?: boolean;
+}
+export interface Deps {
+    store: Store;
+    memoryService: MemoryService;
+    sharedLayer: SharedLayer;
+    okfPath: string;
+    metrics: Metrics;
+}
+export interface ForgetResult {
+    action: "forget";
+    ok: boolean;
+    dry_run: boolean;
+    per_id: Array<{
+        id: string;
+        archived: boolean;
+        reason?: string;
+        tombstone?: {
+            entry_id: string;
+            planned: boolean;
+            applied: boolean;
+        };
+    }>;
+    noop?: boolean;
+    reason?: string;
+}
+export declare function handleForget(input: ForgetInput, deps: Deps): ForgetResult;

package/dist/plugin/kevin_forget.js

@@ -0,0 +1,260 @@
+import { computeEntryId } from "./okf.js";
+export function handleForget(input, deps) {
+    // v1.1.0 — every invocation counts, including dry runs and refusals (K11-005)
+    try {
+        deps.metrics.incr("forget_requests_total", 1);
+    }
+    catch {
+        // best-effort
+    }
+    if (!input.ids || input.ids.length === 0) {
+        return {
+            action: "forget",
+            ok: false,
+            dry_run: input.confirm !== true,
+            per_id: [],
+            reason: "no_ids",
+        };
+    }
+    const isDry = input.confirm !== true;
+    const per_id = [];
+    let anyChange = false;
+    let anyTombstonePlanned = false;
+    // Helper to compute entry_id for a memory row
+    const getEntryId = (row) => {
+        if (row.shared_entry_id)
+            return row.shared_entry_id;
+        return computeEntryId(row.type, row.content, row.scope);
+    };
+    // For dry_run: just plan, mutate nothing
+    if (isDry) {
+        for (const id of input.ids) {
+            const row = deps.store
+                .prepare("SELECT id, type, content, scope, status, layer, shared_entry_id FROM memories WHERE id = ?")
+                .get(id);
+            if (!row) {
+                per_id.push({ id, archived: false, reason: "not_found" });
+                continue;
+            }
+            if (row.status === "archived") {
+                // Idempotence: already archived
+                const isShared = row.layer === "shared" || row.shared_entry_id !== null;
+                if (isShared) {
+                    const entryId = getEntryId(row);
+                    try {
+                        const plan = deps.sharedLayer.planTombstone([entryId], deps.okfPath);
+                        const planned = plan.write.outcome !== "refused" && plan.entriesAdded > 0;
+                        // Already archived implies tombstone already applied, so planned should be false (noop)
+                        per_id.push({
+                            id,
+                            archived: false,
+                            reason: "already_archived",
+                            tombstone: { entry_id: entryId, planned: false, applied: false },
+                        });
+                        void plan;
+                        void planned;
+                    }
+                    catch {
+                        per_id.push({
+                            id,
+                            archived: false,
+                            reason: "already_archived",
+                            tombstone: { entry_id: entryId, planned: false, applied: false },
+                        });
+                    }
+                }
+                else {
+                    per_id.push({ id, archived: false, reason: "already_archived" });
+                }
+                continue;
+            }
+            // Would archive
+            anyChange = true;
+            const isShared = row.layer === "shared" || row.shared_entry_id !== null;
+            if (isShared) {
+                const entryId = getEntryId(row);
+                let planned = false;
+                try {
+                    const plan = deps.sharedLayer.planTombstone([entryId], deps.okfPath);
+                    // planTombstone returns ExportPlan with write outcome; if refused, planned false
+                    planned = plan.write.outcome !== "refused";
+                    anyTombstonePlanned = anyTombstonePlanned || planned;
+                    per_id.push({
+                        id,
+                        archived: true,
+                        tombstone: { entry_id: entryId, planned, applied: false },
+                    });
+                }
+                catch {
+                    per_id.push({
+                        id,
+                        archived: true,
+                        tombstone: { entry_id: entryId, planned: false, applied: false },
+                    });
+                }
+            }
+            else {
+                per_id.push({ id, archived: true });
+            }
+        }
+        const noop = !anyChange;
+        return {
+            action: "forget",
+            ok: true,
+            dry_run: true,
+            per_id,
+            ...(noop ? { noop: true } : {}),
+        };
+    }
+    // Apply mode: confirm === true
+    // We need to archive locally and publish tombstones through applyExport
+    let partial = false;
+    let appliedTombstones = 0;
+    for (const id of input.ids) {
+        const row = deps.store
+            .prepare("SELECT id, type, content, scope, status, layer, shared_entry_id FROM memories WHERE id = ?")
+            .get(id);
+        if (!row) {
+            per_id.push({ id, archived: false, reason: "not_found" });
+            continue;
+        }
+        if (row.status === "archived") {
+            const isShared = row.layer === "shared" || row.shared_entry_id !== null;
+            if (isShared) {
+                const entryId = getEntryId(row);
+                per_id.push({
+                    id,
+                    archived: false,
+                    reason: "already_archived",
+                    tombstone: { entry_id: entryId, planned: false, applied: false },
+                });
+            }
+            else {
+                per_id.push({ id, archived: false, reason: "already_archived" });
+            }
+            continue;
+        }
+        // Archive locally in a transaction
+        let archived = false;
+        try {
+            deps.store.transaction(() => {
+                deps.store
+                    .prepare(`UPDATE memories SET status = 'archived', archived_at = datetime('now'), updated_at = datetime('now') WHERE id = ? AND status != 'archived'`)
+                    .run(id);
+                const changes = deps.store.prepare("SELECT changes() AS c").get();
+                if (changes.c > 0)
+                    archived = true;
+            });
+        }
+        catch (e) {
+            per_id.push({ id, archived: false, reason: "db_error" });
+            partial = true;
+            continue;
+        }
+        anyChange = anyChange || archived;
+        const isShared = row.layer === "shared" || row.shared_entry_id !== null;
+        if (!isShared) {
+            per_id.push({ id, archived });
+            continue;
+        }
+        const entryId = getEntryId(row);
+        // Plan tombstone
+        let plan;
+        try {
+            plan = deps.sharedLayer.planTombstone([entryId], deps.okfPath);
+        }
+        catch (e) {
+            // plan failure: rollback DB archive for this id (best-effort)
+            try {
+                deps.store
+                    .prepare(`UPDATE memories SET status = 'active', archived_at = NULL WHERE id = ?`)
+                    .run(id);
+            }
+            catch { }
+            per_id.push({
+                id,
+                archived: false,
+                reason: "plan_failed",
+                tombstone: { entry_id: entryId, planned: false, applied: false },
+            });
+            partial = true;
+            continue;
+        }
+        if (plan.write.outcome === "refused") {
+            // Refusal reasons are reused verbatim (repo_mismatch, unknown_entry)
+            const reason = plan.write.reason ?? "refused";
+            per_id.push({
+                id,
+                archived,
+                reason,
+                tombstone: { entry_id: entryId, planned: false, applied: false },
+            });
+            // DB archive already done; keep it (local archive is independent of shared refusal)
+            continue;
+        }
+        // Apply through single write funnel
+        try {
+            const applied = deps.sharedLayer.applyExport(plan);
+            const wasWritten = applied.applied === "written";
+            const wasNoop = applied.applied === "noop";
+            if (wasWritten)
+                appliedTombstones++;
+            // per_id tombstone: planned true if not refused, applied true only if written
+            per_id.push({
+                id,
+                archived,
+                tombstone: {
+                    entry_id: entryId,
+                    planned: true,
+                    applied: wasWritten,
+                },
+            });
+            void wasNoop;
+        }
+        catch (e) {
+            // v1.1.0 — failure mid-way: transaction rollback restores DB; already-applied OKF write is reported honestly
+            // For this id, DB was already archived, but file write failed. We attempt to rollback DB for this id.
+            try {
+                deps.store
+                    .prepare(`UPDATE memories SET status = 'active', archived_at = NULL WHERE id = ?`)
+                    .run(id);
+                archived = false;
+            }
+            catch { }
+            per_id.push({
+                id,
+                archived: false,
+                reason: "partial",
+                tombstone: { entry_id: entryId, planned: true, applied: false },
+            });
+            partial = true;
+            // Continue to next id? According spec, failure mid-way reports ok:false reason partial
+            // We keep processing remaining ids? For now we continue but mark partial.
+        }
+    }
+    // Metrics: increment forget_tombstones_published by applied count (only when written, not noop)
+    if (appliedTombstones > 0) {
+        try {
+            deps.metrics.incr("forget_tombstones_published", appliedTombstones);
+        }
+        catch { }
+    }
+    const noop = !anyChange && per_id.every((p) => p.archived === false);
+    if (partial) {
+        return {
+            action: "forget",
+            ok: false,
+            dry_run: false,
+            per_id,
+            reason: "partial",
+            ...(noop ? { noop: true } : {}),
+        };
+    }
+    return {
+        action: "forget",
+        ok: true,
+        dry_run: false,
+        per_id,
+        ...(noop ? { noop: true } : {}),
+    };
+}

package/dist/plugin/kevin_why.js

@@ -1,24 +1,7 @@
 import { TS_CODE_RULES } from "./Reflector.js";
+import { hasFeedbackColumns } from "./columns.js";
 import { computeConfidence } from "./confidence.js";
 import { toMatchClause, tokenizeQuery } from "./query-tokenizer.js";
-// v0.5.0 (K5-010 / plan §5.3) — pre-006 DBs lack the feedback columns;
-// kevin_why must not reference them (it degrades via the try/catch below,
-// which is for missing ROWS, not missing COLUMNS). Probe once per store.
-const feedbackColumnCache = new WeakMap();
-function hasFeedbackColumns(store) {
-    const cached = feedbackColumnCache.get(store);
-    if (cached !== undefined)
-        return cached;
-    try {
-        store.prepare("SELECT feedback_positive FROM memories LIMIT 1").get();
-        feedbackColumnCache.set(store, true);
-        return true;
-    }
-    catch {
-        feedbackColumnCache.set(store, false);
-        return false;
-    }
-}
 export function kevinWhy(store, query) {
     // v0.3.0 fix (bug #7) — the old code wrapped the WHOLE query in a
     // single quoted phrase, so it only matched the exact full-string

package/dist/plugin/metrics.d.ts

@@ -6,7 +6,7 @@ import type { Store } from "./Store.js";
  * underlying table is empty (e.g., before 003 is applied, on a fresh
  * :memory: test DB, or after a manual wipe).
  */
-export declare const METRIC_KEYS: readonly ["tokens_injected_pre_prompt", "tokens_injected_compacting", "reflections_throttled", "duplicate_suppressions", "tool_calls_deduped", "patterns_mined", "patterns_causal", "causal_links", "memories_superseded", "injections_total", "injections_effective", "injections_ineffective", "patterns_promoted_new", "injections_inconclusive", "injections_blocked_seen", "injections_blocked_weak", "injections_blocked_recurrence", "injections_blocked_stale", "injections_blocked_ignored", "feedback_positive_total", "feedback_negative_total", "memories_archived", "proposals_created", "proposals_approved", "proposals_rejected", "artifact_writes_total", "artifact_writes_noop", "injections_blocked_confidence", "repo_facts_scanned", "memories_contradicted", "conventions_mined", "conflicts_detected", "error_lessons_suppressed", "shared_entries_total", "shared_entries_imported", "shared_entries_exported", "okf_merge_folds", "rekey_events", "injections_from_shared"];
+export declare const METRIC_KEYS: readonly ["tokens_injected_pre_prompt", "tokens_injected_compacting", "reflections_throttled", "duplicate_suppressions", "tool_calls_deduped", "patterns_mined", "patterns_causal", "causal_links", "memories_superseded", "injections_total", "injections_effective", "injections_ineffective", "patterns_promoted_new", "injections_inconclusive", "injections_blocked_seen", "injections_blocked_weak", "injections_blocked_recurrence", "injections_blocked_stale", "injections_blocked_ignored", "feedback_positive_total", "feedback_negative_total", "memories_archived", "proposals_created", "proposals_approved", "proposals_rejected", "artifact_writes_total", "artifact_writes_noop", "injections_blocked_confidence", "repo_facts_scanned", "memories_contradicted", "conventions_mined", "conflicts_detected", "error_lessons_suppressed", "shared_entries_total", "shared_entries_imported", "shared_entries_exported", "okf_merge_folds", "rekey_events", "injections_from_shared", "bench_regression_failures", "forget_requests_total", "forget_tombstones_published", "tui_snapshots_flushed", "tui_actions_invoked"];
 export type MetricKey = (typeof METRIC_KEYS)[number];
 /**
  * Cheap token estimate used when bumping the `tokens_injected_*` counters.

package/dist/plugin/metrics.js

@@ -57,6 +57,14 @@ export const METRIC_KEYS = [
     "okf_merge_folds",
     "rekey_events",
     "injections_from_shared",
+    // v1.1.0 (K11-001 / plan §4, D11-01) — drift metrics; order matches 012 seed.
+    "bench_regression_failures",
+    "forget_requests_total",
+    "forget_tombstones_published",
+    // v1.2.0 (K12-001 / plan §4) — surface metrics; no migration this
+    // release — rows are created on first incr via upsert (K12-001).
+    "tui_snapshots_flushed",
+    "tui_actions_invoked",
 ];
 const DEFAULT_FLUSH_MS = 1000;
 function zeroCache() {

package/dist/plugin/query-tokenizer.js

@@ -4,68 +4,116 @@
  * Injection recall ORs the quoted tokens (`"t1" OR "t2"`) while
  * `kevin_why` ANDs them (`"t1" AND "t2"`).
  */
+// v1.1.0 (K11-012 / plan §5.5, D11-05) — single source for STOP_WORDS (union of three lists)
 export const STOP_WORDS = new Set([
     "a",
+    "about",
+    "after",
+    "again",
+    "all",
+    "also",
     "an",
     "and",
+    "any",
     "are",
+    "as",
     "at",
     "be",
     "been",
+    "before",
+    "being",
     "but",
     "by",
+    "can",
+    "como",
+    "con",
+    "could",
+    "de",
     "did",
     "do",
     "does",
     "el",
+    "en",
     "eso",
     "for",
+    "from",
+    "had",
+    "has",
+    "have",
+    "he",
+    "her",
+    "his",
     "how",
     "i",
     "if",
     "in",
+    "into",
     "is",
     "it",
+    "its",
     "la",
     "las",
     "los",
+    "may",
     "mi",
+    "might",
+    "more",
+    "most",
+    "must",
     "my",
+    "not",
     "o",
     "of",
     "on",
+    "one",
     "or",
+    "our",
     "para",
+    "per",
     "por",
     "que",
+    "shall",
     "she",
+    "sin",
+    "so",
     "su",
+    "than",
     "that",
     "the",
+    "their",
+    "them",
+    "then",
+    "there",
+    "these",
+    "they",
     "this",
+    "those",
+    "through",
     "to",
+    "too",
     "tu",
     "un",
     "una",
+    "under",
+    "up",
+    "us",
+    "via",
+    "was",
     "we",
     "were",
     "what",
     "when",
     "where",
     "which",
+    "while",
     "who",
     "why",
+    "will",
     "with",
+    "would",
     "y",
     "you",
-    "como",
-    "con",
-    "de",
-    "en",
-    "he",
-    "they",
-    "was",
-    "sin",
+    "your",
 ]);
 /** Lowercase, split on whitespace, drop stopwords. Returns raw tokens. */
 export function tokenizeQuery(query) {

package/dist/plugin/time-ms.d.ts

@@ -0,0 +1 @@
+export declare function toMs(legacyValue: string | null | undefined, msValue: number | null | undefined): number | null;

package/dist/plugin/time-ms.js

@@ -0,0 +1,16 @@
+// v1.1.0 (K11-003/K11-004 / plan §5.2, D11-01) — millisecond helper.
+// Readers prefer _ms and fall back to legacy second-granularity column.
+// The helper is the single implementation imported by InjectionLedger and
+// CausalChain (moved here in K11-004 to avoid duplication).
+export function toMs(legacyValue, msValue) {
+    if (typeof msValue === "number" && !Number.isNaN(msValue))
+        return msValue;
+    if (!legacyValue)
+        return null;
+    // SQLite datetime('now') is 'YYYY-MM-DD HH:MM:SS' UTC
+    const iso = legacyValue.includes("T")
+        ? legacyValue
+        : `${legacyValue.replace(" ", "T")}Z`;
+    const n = Date.parse(iso);
+    return Number.isNaN(n) ? null : n;
+}

package/dist/plugin/tui-types.d.ts

@@ -0,0 +1,59 @@
+export interface ProposalView {
+    readonly id: string;
+    readonly kind: string;
+    readonly target_path: string;
+    readonly diff: string;
+    readonly memory_ids: readonly string[];
+    readonly created_at: string;
+    readonly truncated?: boolean;
+    readonly token?: string;
+}
+export interface ConflictView {
+    readonly id: string;
+    readonly kind: string;
+    readonly a_summary: string;
+    readonly b_summary: string;
+    readonly opened_at: string;
+}
+export interface HealthView {
+    readonly verdict: string;
+    readonly reason: string;
+    readonly hooks: readonly {
+        readonly hook: string;
+        readonly state: string;
+        readonly fire_count: number;
+        readonly expected_count: number;
+    }[];
+    readonly perf: readonly {
+        readonly scope: string;
+        readonly p95: number;
+        readonly budget_p95: number;
+        readonly within_budget: boolean;
+    }[];
+    readonly contract_digest: string;
+    readonly counters: Record<string, number>;
+}
+export interface TuiSnapshotSet {
+    readonly generatedAt: string;
+    readonly proposals: readonly ProposalView[];
+    readonly conflicts: readonly ConflictView[];
+    readonly health: HealthView;
+}
+export type TuiAction = {
+    readonly type: "approve";
+    readonly proposalId: string;
+    readonly token: string;
+} | {
+    readonly type: "reject";
+    readonly proposalId: string;
+    readonly token: string;
+    readonly note?: string;
+} | {
+    readonly type: "acknowledge";
+    readonly conflictId: string;
+};
+export interface ActionResult {
+    readonly action: TuiAction;
+    readonly status: "applied" | "rejected" | "stale_skipped" | "error";
+    readonly detail?: string;
+}

package/dist/plugin/tui-types.js

@@ -0,0 +1,4 @@
+// v1.2.0 (K12-002 / plan §4.2-§4.3) — shared view types (type-only module).
+// This file MUST contain only type/interface exports — zero runtime values.
+// The TUI module may import it ONLY as `import type`.
+export {};

package/dist/plugin/tui.d.ts

@@ -0,0 +1,18 @@
+import type { TuiPlugin } from "@opencode-ai/plugin/tui";
+import type { ConflictView, HealthView, ProposalView } from "./tui-types.js";
+export declare function tuiRoot(): string;
+export declare function readJsonSafe(name: string): {
+    data: unknown;
+} | {
+    error: "missing" | "corrupt";
+};
+export declare function truncateSummary(text: string, max?: number): string;
+export declare function formatProposalRow(p: ProposalView): string;
+export declare function formatConflictRow(c: ConflictView): string;
+export declare function formatHealthVerdict(h: HealthView): string;
+export declare const tui: TuiPlugin;
+declare const _default: {
+    id: string;
+    tui: TuiPlugin;
+};
+export default _default;