@jmtrin/opencode-kevin 1.1.0 → 1.3.0

package/dist/plugin/index.js

@@ -1,50 +1,56 @@
 import { existsSync, mkdirSync } from "node:fs";
+import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { tool } from "@opencode-ai/plugin";
-import { Archiver } from "./Archiver.js";
-import { ArtifactWriter } from "./ArtifactWriter.js";
-import { CausalChain } from "./CausalChain.js";
-import { ConflictDetector } from "./ConflictDetector.js";
-import { ContextInjector } from "./ContextInjector.js";
-import { ConventionMiner } from "./ConventionMiner.js";
-import { Curator } from "./Curator.js";
-import { Feedback } from "./Feedback.js";
-import { HookLiveness } from "./HookLiveness.js";
-import { InjectionLedger } from "./InjectionLedger.js";
-import { Materializer, SKILL_TOPIC } from "./Materializer.js";
-import { MemoryService, hasRepoIdColumn, } from "./MemoryService.js";
-import { Migrate } from "./Migrate.js";
-import { PatternMiner } from "./PatternMiner.js";
-import { ERROR_LINE_RE, Reflector, STRONG_ERROR_RE } from "./Reflector.js";
-import * as RepoIdentity from "./RepoIdentity.js";
-import { RepoTruth } from "./RepoTruth.js";
-import { Retrospective } from "./Retrospective.js";
-import { SharedLayer } from "./SharedLayer.js";
-import { Store } from "./Store.js";
-import { ToolCallObserver } from "./ToolCallObserver.js";
+import { Archiver } from "@jmtrin/kevin-core";
+import { ArtifactWriter } from "@jmtrin/kevin-core";
+import { CausalChain } from "@jmtrin/kevin-core";
+import { handleBridgeCommand } from "@jmtrin/kevin-core";
+import { ConflictDetector } from "@jmtrin/kevin-core";
+import { ContextInjector } from "@jmtrin/kevin-core";
+import { ConventionMiner } from "@jmtrin/kevin-core";
+import { Curator } from "@jmtrin/kevin-core";
+import { writeDashboard } from "@jmtrin/kevin-core";
+import { Feedback } from "@jmtrin/kevin-core";
+import { HookLiveness } from "@jmtrin/kevin-core";
+import { InjectionLedger } from "@jmtrin/kevin-core";
+import { Materializer, SKILL_TOPIC } from "@jmtrin/kevin-core";
+import { MemoryService, hasRepoIdColumn, } from "@jmtrin/kevin-core";
+import { Migrate } from "@jmtrin/kevin-core";
+import { PatternMiner } from "@jmtrin/kevin-core";
+import { ERROR_LINE_RE, Reflector, STRONG_ERROR_RE } from "@jmtrin/kevin-core";
+import * as RepoIdentity from "@jmtrin/kevin-core";
+import { RepoTruth } from "@jmtrin/kevin-core";
+import { Retrospective } from "@jmtrin/kevin-core";
+import { SharedLayer } from "@jmtrin/kevin-core";
+import { Store } from "@jmtrin/kevin-core";
+import { ToolCallObserver } from "@jmtrin/kevin-core";
+import { deleteMailbox, processActions, readMailbox, writeResults, } from "@jmtrin/kevin-core";
+import { flushSnapshots } from "@jmtrin/kevin-core";
 import { probe } from "./capabilities.js";
-import { computeConfidence } from "./confidence.js";
+import { computeConfidence, exportMigrationsDir, composeIdlePipeline, KEVIN_VERSION } from "@jmtrin/kevin-core";
+import { contractDigest, describeContract } from "@jmtrin/kevin-core";
 import { probeHost, summarize } from "./host.js";
-import { kevinApprove } from "./kevin_approve.js";
-import { buildAudit } from "./kevin_audit.js";
-import { buildKevinBench } from "./kevin_bench.js";
-import { executeKevinConflicts } from "./kevin_conflicts.js";
-import { buildKevinContract } from "./kevin_contract.js";
-import { buildDoctor } from "./kevin_doctor.js";
-import { buildKevinFacts } from "./kevin_facts.js";
-import { handleForget } from "./kevin_forget.js";
-import { handleNative } from "./kevin_native.js";
-import { kevinPropose } from "./kevin_propose.js";
-import { kevinPublish } from "./kevin_publish.js";
-import { kevinWhy } from "./kevin_why.js";
-import { Metrics } from "./metrics.js";
+import { kevinApprove } from "@jmtrin/kevin-core";
+import { buildAudit } from "@jmtrin/kevin-core";
+import { buildKevinBench } from "@jmtrin/kevin-core";
+import { executeKevinConflicts } from "@jmtrin/kevin-core";
+import { buildKevinContract } from "@jmtrin/kevin-core";
+import { buildDoctor } from "@jmtrin/kevin-core";
+import { buildKevinFacts } from "@jmtrin/kevin-core";
+import { handleForget } from "@jmtrin/kevin-core";
+import { handleNative } from "@jmtrin/kevin-core";
+import { kevinPropose } from "@jmtrin/kevin-core";
+import { kevinPublish } from "@jmtrin/kevin-core";
+import { kevinWhy } from "@jmtrin/kevin-core";
+import { Metrics } from "@jmtrin/kevin-core";
 import { attachNative } from "./native.js";
-import { exportMarkdown, exportOkf } from "./okf-export.js";
-import { importOkf } from "./okf-import.js";
-import { Perf } from "./perf.js";
-import { uuidv7 } from "./uuid.js";
+import { exportMarkdown, exportOkf } from "@jmtrin/kevin-core";
+import { importOkf } from "@jmtrin/kevin-core";
+import { Perf } from "@jmtrin/kevin-core";
+import { uuidv7 } from "@jmtrin/kevin-core";
 // v0.6.0 (K6-019) — process-global set of reference topics already
 // registered with the host this process. Keeps re-registration idempotent
 // across sessions within one process: a topic registered once is never
@@ -112,6 +118,11 @@ export const KEVIN_CONFIG_KEYS = [
     "perf_ring_capacity",
     "perf_flush_on_idle",
     "contract_report_enabled",
+    // v1.2.0 (K12-001 / plan §4) — the single setting seeded by runtime
+    // (no migration this release). Omitting makes `kevin_config set`
+    // return { error: "unknown_key" } while `kevin_config list` still
+    // shows it.
+    "tui_snapshots_enabled",
 ];
 // v1.1.0 (K11-007 / D11-08) — no new settings in 1.1.0; thresholds are constants (D11-03)
 // v0.7.0 (K7-003 / plan §5.6, D7-12) — the explicit VALUE domain for
@@ -121,11 +132,41 @@ export const KEVIN_CONFIG_KEYS = [
 // at the surface rather than silently changing every installation's
 // behaviour on the next reflection.
 export const ERROR_LESSON_MODE_VALUES = ["all", "triage_only"];
-/** Plugin release version — stamped into generated files (K8-021/027). */
-export const KEVIN_VERSION = "1.1.0";
+/** Plugin release version — single source is @jmtrin/kevin-core (B-003 drift fix). */
+export { KEVIN_VERSION };
 function resolveMigrationsDir() {
+    // K13-008 (D13-04): migrations now owned by @jmtrin/kevin-core.
+    // Explicit option is handled at call site (opts.migrationsDir ?? resolve...),
+    // so this helper only resolves the core location.
+    // 1. Installed layout: walk-up via require.resolve (reuses host.ts strategy)
+    try {
+        const pkgJson = createRequire(import.meta.url).resolve("@jmtrin/kevin-core/package.json");
+        const cand = join(dirname(pkgJson), "dist", "migrations");
+        if (existsSync(cand))
+            return cand;
+    }
+    catch { }
+    // 2. Workspace sources: delegate to core's own resolver (handles both
+    //    src via tsx and dist after build).
+    try {
+        const dir = exportMigrationsDir();
+        if (existsSync(dir))
+            return dir;
+    }
+    catch { }
+    // 3. Monorepo fallback probes (dev without build)
     const here = dirname(fileURLToPath(import.meta.url));
-    return join(here, "..", "migrations");
+    const candidates = [
+        join(here, "..", "..", "core", "dist", "migrations"),
+        join(here, "..", "..", "core", "migrations"),
+        join(here, "..", "migrations"),
+        join(here, "..", "..", "migrations"),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    return join(here, "..", "..", "core", "migrations");
 }
 const REKEY_TABLES = ["memories", "shared_entries", "okf_imports"];
 export function performRekey(store, toRepoId, opts) {
@@ -258,6 +299,17 @@ export const KevinPlugin = async (input, options) => {
     const store = new Store({ path: dbPath });
     const migrationsDir = opts.migrationsDir ?? resolveMigrationsDir();
     await new Migrate(store, migrationsDir).run();
+    // v1.2.0 (K12-001 / D12-??) — no migration this release: ensure the
+    // new setting exists with its default so `kevin_config list` shows it
+    // on a database that was already at 012.
+    try {
+        store
+            .prepare("INSERT OR IGNORE INTO kevin_settings (key, value) VALUES (?, ?)")
+            .run("tui_snapshots_enabled", "1");
+    }
+    catch {
+        // pre-003 DB without kevin_settings — nothing to seed
+    }
     const metrics = new Metrics(store);
     // v0.4.0 (K4-019): the plugin hooks expose no project field, so the
     // project id is derived once from the plugin host's working directory
@@ -316,6 +368,8 @@ export const KevinPlugin = async (input, options) => {
     // v0.7.0 (K7-009 / plan §5.1, D7-13) — the repository truth scanner reads
     // the JSON project files. Runs once at init, gated by repo_truth_enabled.
     const projectRoot = opts.projectRoot ?? process.cwd();
+    const materializerRoot = opts.materializerRoot ?? join(homedir(), ".opencode-kevin");
+    const kevinEnv = { projectRoot, dataRoot: materializerRoot };
     const repoTruth = new RepoTruth(store, projectId, projectRoot, metrics);
     if (memoryService.getSetting("repo_truth_enabled", "0") === "1") {
         try {
@@ -355,7 +409,7 @@ export const KevinPlugin = async (input, options) => {
     const archiver = new Archiver(store, memoryService, metrics);
     const retrospective = new Retrospective(store, memoryService, {
         dir: opts.retrospectivesDir,
-    }, metrics);
+    }, metrics, kevinEnv);
     const patternMiner = new PatternMiner(store, memoryService, metrics);
     const conventionMiner = new ConventionMiner(store, memoryService, projectId, metrics);
     const conflictDetector = new ConflictDetector(store, projectId, metrics, repoTruth, memoryService);
@@ -387,17 +441,20 @@ export const KevinPlugin = async (input, options) => {
         metrics.incr("shared_entries_imported", report.imported);
         return report;
     }
-    let curator = new Curator(store, memoryService, projectId, metrics, repoId);
+    let curator = new Curator(store, memoryService, projectId, metrics, repoId, kevinEnv);
     // v0.6.0 (K6-017/018 / plan §5.6-5.7, D6-13) — pull-channel bundles and
     // the v2 domain probe. `probe()` runs ONCE at init and the result is
     // held; probing per-event is a hot-path cost for a value that cannot
     // change within a process (K6-016). The Materializer writes next to its
     // targets, so the bundle directories are created here at init.
-    const materializerRoot = opts.materializerRoot ?? join(homedir(), ".opencode-kevin");
     mkdirSync(join(materializerRoot, "skills"), { recursive: true });
     mkdirSync(join(materializerRoot, "refs"), { recursive: true });
     const capabilities = probe(input);
-    const materializer = new Materializer(store, { root: materializerRoot });
+    // v1.2.0 (K12-012 / D12-03) — permission.ask probe (best-effort, additive).
+    // When the host exposes permission.ask, the presence is noted; absence is silent no-op.
+    // No new setting — bounded to tui_snapshots_enabled host-support check per spec.
+    void capabilities.permissionAsk;
+    const materializer = new Materializer(store, { root: materializerRoot }, kevinEnv);
     // v0.9.0 (K9-016 / plan §5.4, D9-10) — native registration replaces
     // file emission. When attachNative returns a registration for a
     // surface, the corresponding *_emission_enabled path is skipped for
@@ -977,7 +1034,7 @@ export const KevinPlugin = async (input, options) => {
                                 version: KEVIN_VERSION,
                                 writer,
                             });
-                            curator = new Curator(store, memoryService, projectId, metrics, live.repoId);
+                            curator = new Curator(store, memoryService, projectId, metrics, live.repoId, kevinEnv);
                             // v0.8.0 (BUG-003) — heal the OKF file header.
                             // Rekey changes the scope the file is written
                             // under; a stale `#repo` first line would make
@@ -1052,7 +1109,7 @@ export const KevinPlugin = async (input, options) => {
                     // block; on a pre-008 DB the block is omitted, partial:true.
                     // v0.8.0 (K8-007 / plan §5.7) — the penalized-memory rollup
                     // scopes on repoId once the 009 column exists.
-                    const report = buildAudit(store, metrics, capabilities, projectId, sessionIdentity.repoId);
+                    const report = buildAudit(store, metrics, capabilities, projectId, sessionIdentity.repoId, undefined, kevinEnv);
                     const payload = args.verbose
                         ? report
                         : { ...report, settings: undefined };
@@ -1071,7 +1128,7 @@ export const KevinPlugin = async (input, options) => {
                 description: "Doctor de Kevin (v0.9.0): salud del host, hooks, dependencias y registros nativos. Solo lectura, sin LLM ni writes, invocable en cualquier momento. Devuelve host (version, flavour, shell, v2), hooks ordenados dead primero, dependencies (zod_copies), native (enabled, registered/verified por surface), verdict (healthy|degraded|unknown) y reason. Output pensado para pegar en un issue: sin filesystem paths ni session ids.",
                 args: {},
                 async execute() {
-                    const report = buildDoctor(store, host, memoryService);
+                    const report = buildDoctor(store, host, memoryService, {}, kevinEnv);
                     return {
                         title: "Doctor de Kevin",
                         output: JSON.stringify(report),
@@ -1140,7 +1197,7 @@ export const KevinPlugin = async (input, options) => {
                         .describe("status | last"),
                 },
                 async execute(args) {
-                    const result = buildKevinBench({ store }, args);
+                    const result = buildKevinBench({ store }, args, kevinEnv);
                     return {
                         title: "Benchmark de Kevin",
                         output: JSON.stringify(result),
@@ -1675,15 +1732,80 @@ export const KevinPlugin = async (input, options) => {
             });
         },
         "chat.message": async (hookInput, output) => {
+            const rawText = output.parts
+                .map((p) => p)
+                .filter((p) => p.type === "text")
+                .map((p) => p.text ?? "")
+                .join(" ");
+            const trimmed = rawText.trim();
+            // v1.2.0 (K12-018 / D12-09) — chat-command bridge BEFORE deriveQuery.
+            // Valid commands are SWALLOWED (parts cleared) and never reach the model.
+            // Must run outside perf.measure so early return actually exits the hook.
+            if (trimmed.length > 0) {
+                try {
+                    const bridgeDeps = {
+                        getPending: () => {
+                            try {
+                                const maybe = curator.pending;
+                                if (typeof maybe === "function") {
+                                    const rows = maybe.call(curator);
+                                    return rows.map((p) => ({
+                                        id: p.id,
+                                        proposedText: String(p.proposed_text ?? p.proposedText ?? ""),
+                                    }));
+                                }
+                            }
+                            catch { }
+                            try {
+                                const rows = store
+                                    .prepare("SELECT id, proposed_text FROM curation_proposals WHERE status = 'pending'")
+                                    .all();
+                                return rows.map((r) => ({
+                                    id: r.id,
+                                    proposedText: r.proposed_text,
+                                }));
+                            }
+                            catch {
+                                return [];
+                            }
+                        },
+                        approve: (id) => kevinApprove(store, memoryService, curator, writer, metrics, {
+                            proposalId: id,
+                            decision: "approve",
+                        }),
+                        reject: (id, note) => kevinApprove(store, memoryService, curator, writer, metrics, {
+                            proposalId: id,
+                            decision: "reject",
+                        }) && void note,
+                        acknowledge: (conflictId) => {
+                            try {
+                                const cd = conflictDetector;
+                                if (typeof cd.acknowledge === "function")
+                                    cd.acknowledge(conflictId);
+                                else if (typeof cd.resolve === "function")
+                                    cd.resolve(conflictId, "a");
+                            }
+                            catch { }
+                        },
+                        metrics,
+                    };
+                    const br = handleBridgeCommand(trimmed, bridgeDeps);
+                    if (br.handled) {
+                        try {
+                            output.parts = [];
+                        }
+                        catch { }
+                        return;
+                    }
+                }
+                catch {
+                    // best-effort — bridge failure must not break chat flow
+                }
+            }
             perf.measure("chat.message", () => {
-                const text = output.parts
-                    .map((p) => p)
-                    .filter((p) => p.type === "text")
-                    .map((p) => p.text ?? "")
-                    .join(" ");
-                if (text.trim()) {
+                if (trimmed.length > 0) {
                     const derived = injector.deriveQuery([
-                        { role: "user", content: text },
+                        { role: "user", content: rawText },
                     ]);
                     lastUserQuery = derived.length > 0 ? derived : null;
                     if (hookInput.sessionID && lastUserQuery) {
@@ -1753,62 +1875,94 @@ export const KevinPlugin = async (input, options) => {
                         // BUG-011 — the session is done: drop the global query
                         // so the next session cannot reuse it.
                         lastUserQuery = null;
-                        // v0.4.0 (K4-024) — plan §5.2: settle the session's
-                        // unmeasured injections (effective/ineffective +
-                        // recurrence_count charges) at idle. Best-effort: a
-                        // legacy DB without migration 005 has no ledger table.
-                        try {
-                            ledger.settle(sid);
-                        }
-                        catch {
-                            // best-effort: a legacy DB without the ledger
-                            // table must not break the idle path
-                        }
-                        // v0.5.0 (K5-012 / plan §5.4) — retire stale lessons at
-                        // idle; pre-006 DBs degrade to a no-op.
-                        try {
-                            archiver.run();
-                        }
-                        catch {
-                            // best-effort, same pattern as ledger.settle
-                        }
-                        fireAndForget(retrospective.generate(sid));
-                        memoryService.boostPositiveReflectors(sid);
-                        const recurred = memoryService.penalizeRecurringReflectors(sid);
-                        injector.setRecurrences(recurred, sid);
-                        patternMiner.mine(projectId);
-                        // v0.7.0 (K7-012 / plan §5.4, D7-10) — convention mining is
-                        // session.idle-only, default-off, and isolated from the rest of
-                        // the idle chain. Mined rules still enter the ordinary Curator
-                        // approval path; this step never writes to the repository.
-                        try {
-                            if (memoryService.getSetting("convention_mining_enabled", "0") ===
-                                "1") {
-                                const conventions = conventionMiner.mine();
-                                conventionMiner.emit(conventions);
-                            }
-                        }
-                        catch {
-                            // A throwing miner must not reject or truncate the idle chain.
-                        }
-                        // v0.7.0 (K7-016 / plan §5.5, D7-06) — conflict detection is
-                        // surfacing-only on idle. It may create/open conflict rows, but
-                        // no idle path can acknowledge or resolve one.
+                        // K13-010 (D13-07) — single ORDER via composeIdlePipeline.
+                        // Ledger/archiver/reflectors/pattern are the hand-synced core;
+                        // adapter and replay both consume IDLE_STEP_ORDER so re-order is visible in both.
+                        await composeIdlePipeline({
+                            "ledger.settle": () => { ledger.settle(sid); },
+                            "archiver.run": () => { archiver.run(); },
+                            retrospective: () => {
+                                fireAndForget(retrospective.generate(sid));
+                            },
+                            "reflectors.boost": () => { memoryService.boostPositiveReflectors(sid); },
+                            "reflectors.penalize": () => {
+                                const recurred = memoryService.penalizeRecurringReflectors(sid);
+                                injector.setRecurrences(recurred, sid);
+                            },
+                            "patternMiner.mine": () => { patternMiner.mine(projectId); },
+                        });
+                        // v0.7.0 (K7-012/K7-016) + causalChain — folded into the single ORDER via composeIdlePipeline (K13-010)
+                        await composeIdlePipeline({
+                            "conventionMiner.mine": () => {
+                                if (memoryService.getSetting("convention_mining_enabled", "0") === "1") {
+                                    const conventions = conventionMiner.mine();
+                                    conventionMiner.emit(conventions);
+                                }
+                            },
+                            "conflictDetector.detect": () => {
+                                if (memoryService.getSetting("conflict_detection_enabled", "0") === "1") {
+                                    conflictDetector.detect();
+                                }
+                            },
+                            "causalChain.onSessionIdle": () => {
+                                fireAndForget(Promise.resolve().then(() => causalChain.onSessionIdle(sid)).catch(() => { }));
+                            },
+                        });
+                        // v1.2.0 (K12-007/K12-011 / D12-05) — TUI mailbox: actions→curate ordering.
+                        // Process mailbox BEFORE curator.propose so a fresh proposal created this idle
+                        // is NOT visible to a stale token (D12-04). Best-effort, never breaks idle.
                         try {
-                            if (memoryService.getSetting("conflict_detection_enabled", "0") ===
-                                "1") {
-                                conflictDetector.detect();
+                            const mb = readMailbox(materializerRoot);
+                            if (mb.actions.length) {
+                                const tuiDeps = {
+                                    getPending: () => {
+                                        try {
+                                            const maybe = curator.pending;
+                                            if (typeof maybe === "function") {
+                                                const rows = maybe.call(curator);
+                                                return rows.map((p) => ({
+                                                    id: p.id,
+                                                    proposedText: String(p.proposed_text ?? p.proposedText ?? ""),
+                                                }));
+                                            }
+                                        }
+                                        catch { }
+                                        try {
+                                            const rows = store
+                                                .prepare("SELECT id, proposed_text FROM curation_proposals WHERE status = 'pending'")
+                                                .all();
+                                            return rows.map((r) => ({
+                                                id: r.id,
+                                                proposedText: r.proposed_text,
+                                            }));
+                                        }
+                                        catch {
+                                            return [];
+                                        }
+                                    },
+                                    approve: (id) => kevinApprove(store, memoryService, curator, writer, metrics, {
+                                        proposalId: id,
+                                        decision: "approve",
+                                    }),
+                                    reject: (id, _note) => kevinApprove(store, memoryService, curator, writer, metrics, {
+                                        proposalId: id,
+                                        decision: "reject",
+                                    }),
+                                    acknowledge: (conflictId) => {
+                                        const cd = conflictDetector;
+                                        if (typeof cd.acknowledge === "function")
+                                            cd.acknowledge(conflictId);
+                                    },
+                                    metrics,
+                                };
+                                const tuiResults = processActions(mb.actions, tuiDeps);
+                                writeResults(materializerRoot, tuiResults);
+                                deleteMailbox(materializerRoot);
                             }
                         }
                         catch {
-                            // Conflict surfacing is best-effort and must not reject idle.
+                            // best-effort
                         }
-                        fireAndForget(Promise.resolve()
-                            .then(() => causalChain.onSessionIdle(sid))
-                            // non-blocking — promote is a best-effort pass
-                            // (legacy DBs pre-005 lack the recurrence_count
-                            // column)
-                            .catch(() => { }));
                         // v0.6.0 (K6-015 / plan §8.14) — session-idle curation
                         // generation. Dry-run only: `propose()` calls `plan()`
                         // and never `apply()`, so nothing here can touch disk
@@ -1850,6 +2004,145 @@ export const KevinPlugin = async (input, options) => {
                             // best-effort, same pattern as ledger.settle — a
                             // sync failure must not break the idle path
                         }
+                        // v1.2.0 (K12-003/K12-011/K12-017 / D12-05) — snapshot flush gated by tui_snapshots_enabled.
+                        // Order: actions→curate→syncSharedLayer→snapshots (D12-05) — snapshots reflect post-action truth.
+                        try {
+                            if (memoryService.getSetting("tui_snapshots_enabled", "1") === "1") {
+                                // Proposals
+                                let proposals = [];
+                                try {
+                                    const rawPending = (() => {
+                                        try {
+                                            const maybe = curator.pending;
+                                            if (typeof maybe === "function")
+                                                return maybe.call(curator);
+                                        }
+                                        catch { }
+                                        return store
+                                            .prepare("SELECT id, kind, target_path, proposed_text, diff, memory_id, created_at FROM curation_proposals WHERE status = 'pending' ORDER BY created_at")
+                                            .all();
+                                    })();
+                                    const { proposalToken } = await import("@jmtrin/kevin-core");
+                                    proposals = rawPending.map((r) => {
+                                        const row = r;
+                                        const id = String(row.id ?? "");
+                                        const proposed = String(row.proposed_text ?? row.proposedText ?? "");
+                                        return {
+                                            id,
+                                            kind: String(row.kind ?? "agents_md"),
+                                            target_path: String(row.target_path ?? row.targetPath ?? "AGENTS.md"),
+                                            diff: String(row.diff ?? ""),
+                                            memory_ids: String(row.memory_id ?? row.memoryIds ?? "")
+                                                .split(",")
+                                                .filter((s) => s.length > 0),
+                                            created_at: String(row.created_at ??
+                                                row.createdAt ??
+                                                new Date().toISOString()),
+                                            token: proposalToken(id, proposed),
+                                        };
+                                    });
+                                }
+                                catch { }
+                                // Conflicts
+                                let conflicts = [];
+                                try {
+                                    const maybe = conflictDetector.openConflicts;
+                                    if (typeof maybe === "function") {
+                                        const raw = maybe.call(conflictDetector);
+                                        conflicts = raw.map((c) => {
+                                            const row = c;
+                                            return {
+                                                id: String(row.id ?? ""),
+                                                kind: String(row.kind ?? ""),
+                                                a_summary: String(row.a_summary ?? row.aSummary ?? ""),
+                                                b_summary: String(row.b_summary ?? row.bSummary ?? ""),
+                                                opened_at: String(row.opened_at ??
+                                                    row.openedAt ??
+                                                    new Date().toISOString()),
+                                            };
+                                        });
+                                    }
+                                }
+                                catch {
+                                    conflicts = [];
+                                }
+                                // Health
+                                let health;
+                                try {
+                                    const doc = buildDoctor(store, host, memoryService, {}, kevinEnv);
+                                    let perfRows = [];
+                                    try {
+                                        const stats = perf.stats?.();
+                                        if (Array.isArray(stats)) {
+                                            perfRows = stats.map((p) => {
+                                                const row = p;
+                                                const budget = row.budget;
+                                                return {
+                                                    scope: String(row.scope ?? ""),
+                                                    p95: Number(row.p95 ?? 0),
+                                                    budget_p95: Number(budget?.p95Ms ??
+                                                        row.budget_p95 ??
+                                                        row.budgetP95 ??
+                                                        0),
+                                                    within_budget: Boolean(row.withinBudget ?? row.within_budget ?? true),
+                                                };
+                                            });
+                                        }
+                                    }
+                                    catch {
+                                        perfRows = [];
+                                    }
+                                    let digest = "unknown";
+                                    try {
+                                        digest = contractDigest(describeContract());
+                                    }
+                                    catch { }
+                                    health = {
+                                        verdict: doc.verdict,
+                                        reason: doc.reason,
+                                        hooks: doc.hooks.map((h) => ({
+                                            hook: h.hook,
+                                            state: h.state,
+                                            fire_count: h.fire_count,
+                                            expected_count: h.expected_count,
+                                        })),
+                                        perf: perfRows,
+                                        contract_digest: digest,
+                                        counters: metrics.snapshot(),
+                                    };
+                                }
+                                catch {
+                                    health = {
+                                        verdict: "unknown",
+                                        reason: "health unavailable",
+                                        hooks: [],
+                                        perf: [],
+                                        contract_digest: "unknown",
+                                        counters: {},
+                                    };
+                                }
+                                flushSnapshots({
+                                    root: materializerRoot,
+                                    proposals,
+                                    conflicts,
+                                    health,
+                                    metrics,
+                                    version: KEVIN_VERSION,
+                                });
+                                try {
+                                    writeDashboard(materializerRoot, {
+                                        generatedAt: new Date().toISOString(),
+                                        proposals,
+                                        conflicts,
+                                        health,
+                                    });
+                                }
+                                catch { }
+                            }
+                        }
+                        catch {
+                            // best-effort — snapshot failure must not break idle
+                        }
                         // v1.0.0 (K10-013 / D10-08) — the session recorded work:
                         // arm the deferred dispose settlement. The ISO timestamp
                         // lets the next session.start compare it against

package/dist/plugin/native.d.ts

@@ -1,5 +1,5 @@
-import { type Materializer } from "./Materializer.js";
-import type { Store } from "./Store.js";
+import { type Materializer } from "@jmtrin/kevin-core";
+import type { Store } from "@jmtrin/kevin-core";
 import type { HostSurface } from "./host.js";
 /** The surface `attachNative()` returned. `verified` is filled by the
  * read-back checks (K9-014/015) once the host ran `setup()`. */