@jmtrin/opencode-kevin 1.0.0 → 1.2.0

package/dist/plugin/columns.js

@@ -0,0 +1,54 @@
+const cache = new WeakMap();
+export function hasColumn(store, table, column) {
+    const byStore = cache.get(store);
+    const key = `${table}.${column}`;
+    if (byStore?.get(key) === true)
+        return true;
+    try {
+        store.prepare(`SELECT ${column} FROM ${table} LIMIT 0`).get();
+        let m = byStore;
+        if (!m) {
+            m = new Map();
+            cache.set(store, m);
+        }
+        m.set(key, true);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// v1.1.0 (K11-011 / plan §5.5, D11-06) — named helpers delegating to the registry
+export function hasIgnoredColumn(store) {
+    return hasColumn(store, "memories", "ignored");
+}
+export function hasCuratedColumn(store) {
+    return hasColumn(store, "memories", "curated");
+}
+export function hasTruthColumns(store) {
+    return hasColumn(store, "memories", "truth_penalty");
+}
+export function hasRepoIdColumn(store) {
+    return hasColumn(store, "memories", "repo_id");
+}
+export function hasLayerColumn(store) {
+    return hasColumn(store, "memories", "layer");
+}
+export function hasRecurrenceColumn(store) {
+    return hasColumn(store, "memories", "recurrence_count");
+}
+export function hasArchivedColumn(store) {
+    return hasColumn(store, "memories", "archived_at");
+}
+export function hasFeedbackColumns(store) {
+    return hasColumn(store, "memories", "feedback_positive");
+}
+export function hasFeedbackTable(store) {
+    try {
+        store.prepare("SELECT COUNT(*) FROM memory_feedback LIMIT 0").get();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plugin/contract.d.ts

@@ -28,6 +28,14 @@ export declare const CONTRACT_TOOL_ADDITIONS: readonly {
     name: string;
     since: string;
 }[];
+/**
+ * v1.1.0 (K11-007 / plan §5.1, D11-01) — metric keys added after the freeze,
+ * each carrying the `since` the deprecation policy requires (C-05).
+ */
+export declare const CONTRACT_METRIC_ADDITIONS: readonly {
+    name: string;
+    since: string;
+}[];
 /**
  * v1.0.0 (K10-027 / plan §5.7) — the C-09 boundary addition. Stored is
  * not trusted: anything reaching an artifact or a prompt is escaped at

package/dist/plugin/contract.js

@@ -41,8 +41,21 @@ export const CONTRACT_TOOL_NAMES = [
  * added_bare.
  */
 export const CONTRACT_TOOL_ADDITIONS = [
-    { name: "kevin_contract", since: "1.0.0" },
     { name: "kevin_bench", since: "1.0.0" },
+    { name: "kevin_contract", since: "1.0.0" },
+    { name: "kevin_forget", since: "1.1.0" },
+];
+/**
+ * v1.1.0 (K11-007 / plan §5.1, D11-01) — metric keys added after the freeze,
+ * each carrying the `since` the deprecation policy requires (C-05).
+ */
+export const CONTRACT_METRIC_ADDITIONS = [
+    { name: "bench_regression_failures", since: "1.1.0" },
+    { name: "forget_requests_total", since: "1.1.0" },
+    { name: "forget_tombstones_published", since: "1.1.0" },
+    // v1.2.0 (K12-001 / plan §4, D12-??) — surface metrics (no migration this release)
+    { name: "tui_snapshots_flushed", since: "1.2.0" },
+    { name: "tui_actions_invoked", since: "1.2.0" },
 ];
 /**
  * v1.0.0 (K10-027 / plan §5.7) — the C-09 boundary addition. Stored is
@@ -76,12 +89,17 @@ export function describeContract(_input) {
     // Derive clause values from live source wherever possible (plan §5.1).
     // C-03 members added after the freeze carry their `since` as objects;
     // the original frozen set stays plain strings.
-    const additions = [...CONTRACT_TOOL_ADDITIONS].sort((a, b) => a.name.localeCompare(b.name));
+    const toolAdditions = [...CONTRACT_TOOL_ADDITIONS].sort((a, b) => a.name.localeCompare(b.name));
     const toolValue = {
-        tools: [[...CONTRACT_TOOL_NAMES].sort(), additions].flat(),
+        tools: [[...CONTRACT_TOOL_NAMES].sort(), toolAdditions].flat(),
     };
     const settingValue = { keys: [...KEVIN_CONFIG_KEYS].sort() };
-    const metricValue = { keys: Object.keys(METRIC_KEY_LABELS).sort() };
+    // v1.1.0 — metric keys added after freeze carry `since` (C-05)
+    const metricAdditions = [...CONTRACT_METRIC_ADDITIONS].sort((a, b) => a.name.localeCompare(b.name));
+    const baseMetricKeys = Object.keys(METRIC_KEY_LABELS)
+        .filter((k) => !metricAdditions.some((a) => a.name === k))
+        .sort();
+    const metricValue = { keys: [...baseMetricKeys, ...metricAdditions].flat() };
     const clauses = [
         {
             id: "C-01",
@@ -149,7 +167,7 @@ export function describeContract(_input) {
             stability: "forward-only",
             since: "0.1.0",
             value: {
-                schema_version: "011",
+                schema_version: "012",
                 migrations_forward_only: true,
             },
         },

package/dist/plugin/index.d.ts

@@ -16,10 +16,10 @@ export interface KevinPluginOptions {
  * v0.4.0 (K4-021) — settings surfaced by `kevin_config` (plan §8.8).
  * Unknown keys are rejected on `set` unless `strict: false`.
  */
-export declare const KEVIN_CONFIG_KEYS: readonly ["quality_gate_enabled", "lesson_snippet_injection", "patternminer_enabled", "cross_project_enabled", "llm_reflection_enabled", "tool_calls_dedup_enabled", "deterministic_retrieval", "pre_prompt_budget_tokens", "archive_after_days", "curation_enabled", "agents_md_path", "skill_emission_enabled", "reference_emission_enabled", "injection_confidence_floor", "repo_truth_enabled", "convention_mining_enabled", "conflict_detection_enabled", "error_lesson_mode", "shared_layer_enabled", "okf_path", "share_requires_approval", "author_identity_mode", "shared_confidence_floor", "hook_liveness_enabled", "native_registration_enabled", "host_probe_history_enabled", "dead_hook_report_threshold", "perf_enabled", "perf_ring_capacity", "perf_flush_on_idle", "contract_report_enabled"];
+export declare const KEVIN_CONFIG_KEYS: readonly ["quality_gate_enabled", "lesson_snippet_injection", "patternminer_enabled", "cross_project_enabled", "llm_reflection_enabled", "tool_calls_dedup_enabled", "deterministic_retrieval", "pre_prompt_budget_tokens", "archive_after_days", "curation_enabled", "agents_md_path", "skill_emission_enabled", "reference_emission_enabled", "injection_confidence_floor", "repo_truth_enabled", "convention_mining_enabled", "conflict_detection_enabled", "error_lesson_mode", "shared_layer_enabled", "okf_path", "share_requires_approval", "author_identity_mode", "shared_confidence_floor", "hook_liveness_enabled", "native_registration_enabled", "host_probe_history_enabled", "dead_hook_report_threshold", "perf_enabled", "perf_ring_capacity", "perf_flush_on_idle", "contract_report_enabled", "tui_snapshots_enabled"];
 export declare const ERROR_LESSON_MODE_VALUES: readonly ["all", "triage_only"];
 /** Plugin release version — stamped into generated files (K8-021/027). */
-export declare const KEVIN_VERSION = "1.0.0";
+export declare const KEVIN_VERSION = "1.2.0";
 export interface RekeyCounts {
     memories: number;
     shared_entries: number;

package/dist/plugin/index.js

@@ -6,10 +6,12 @@ import { tool } from "@opencode-ai/plugin";
 import { Archiver } from "./Archiver.js";
 import { ArtifactWriter } from "./ArtifactWriter.js";
 import { CausalChain } from "./CausalChain.js";
+import { handleBridgeCommand } from "./ChatBridge.js";
 import { ConflictDetector } from "./ConflictDetector.js";
 import { ContextInjector } from "./ContextInjector.js";
 import { ConventionMiner } from "./ConventionMiner.js";
 import { Curator } from "./Curator.js";
+import { writeDashboard } from "./DashboardHtml.js";
 import { Feedback } from "./Feedback.js";
 import { HookLiveness } from "./HookLiveness.js";
 import { InjectionLedger } from "./InjectionLedger.js";
@@ -24,8 +26,11 @@ import { Retrospective } from "./Retrospective.js";
 import { SharedLayer } from "./SharedLayer.js";
 import { Store } from "./Store.js";
 import { ToolCallObserver } from "./ToolCallObserver.js";
+import { deleteMailbox, processActions, readMailbox, writeResults, } from "./TuiActions.js";
+import { flushSnapshots } from "./TuiSnapshots.js";
 import { probe } from "./capabilities.js";
 import { computeConfidence } from "./confidence.js";
+import { contractDigest, describeContract } from "./contract.js";
 import { probeHost, summarize } from "./host.js";
 import { kevinApprove } from "./kevin_approve.js";
 import { buildAudit } from "./kevin_audit.js";
@@ -34,6 +39,7 @@ 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";
@@ -111,7 +117,13 @@ 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
 // `error_lesson_mode`. The setting is TEXT and must be compared with
 // `=== "triage_only"`, never by truthiness; the domain here is enforced by
@@ -120,7 +132,7 @@ export const KEVIN_CONFIG_KEYS = [
 // 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.0.0";
+export const KEVIN_VERSION = "1.2.0";
 function resolveMigrationsDir() {
     const here = dirname(fileURLToPath(import.meta.url));
     return join(here, "..", "migrations");
@@ -256,6 +268,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
@@ -395,6 +418,10 @@ export const KevinPlugin = async (input, options) => {
     mkdirSync(join(materializerRoot, "skills"), { recursive: true });
     mkdirSync(join(materializerRoot, "refs"), { recursive: true });
     const capabilities = probe(input);
+    // 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 });
     // v0.9.0 (K9-016 / plan §5.4, D9-10) — native registration replaces
     // file emission. When attachNative returns a registration for a
@@ -870,8 +897,9 @@ export const KevinPlugin = async (input, options) => {
                             // monotone across releases; K6-024 extends this
                             // block with the remaining v0.6 fields. v0.8.0
                             // (K8-025) — 18 v0.7 + kevin_project +
-                            // kevin_native = 23.
-                            tool_count: 23,
+                            // kevin_native = 23. v1.0.0 (K10-018) — +kevin_contract +kevin_bench = 25.
+                            // v1.1.0 (K11-007) — +kevin_forget = 26.
+                            tool_count: 26,
                             v07,
                             memories_reflector: memoriesReflector,
                             memories_agent: memoriesAgent,
@@ -1461,6 +1489,24 @@ export const KevinPlugin = async (input, options) => {
                     };
                 },
             }),
+            // v1.1.0 (K11-007 / plan §5.1, D11-02) — kevin_forget: closes the sharing lifecycle.
+            kevin_forget: tool({
+                description: "Olvida memorias y publica tombstones en la capa compartida (v1.1.0, K11-005/006 / plan §5.1): dry-run por defecto — sin confirm no muta nada y devuelve el plan (archived, tombstone planned); con confirm:true archiva localmente (status='archived') y, cuando la memoria proyecta a la capa compartida (layer='shared' o shared_entry_id), publica un tombstone via el unico write path (SharedLayer.applyExport, D8-08). Segunda invocacion identica reporta noop.",
+                args: {
+                    ids: tool.schema.array(tool.schema.string()).min(1),
+                    confirm: tool.schema.boolean().optional(),
+                },
+                async execute(args) {
+                    const okfPath = join(projectRoot, memoryService.getSetting("okf_path", ".kevin/knowledge.okf"));
+                    const result = handleForget({ ids: args.ids, confirm: args.confirm }, { store, memoryService, sharedLayer, okfPath, metrics });
+                    return {
+                        title: result.dry_run
+                            ? "Plan de olvido (dry-run)"
+                            : "Olvido aplicado",
+                        output: JSON.stringify(result),
+                    };
+                },
+            }),
             kevin_approve: tool({
                 description: "Aprueba o rechaza una propuesta de curacion (v0.6.0). reject: marca rejected, nada toca disco. approve: aplica el diff (unico call site de ArtifactWriter.apply, D6-01), marca applied y cura las memorias contribuyentes. Solo acepta propuestas pending.",
                 args: {
@@ -1654,15 +1700,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) {
@@ -1788,6 +1899,61 @@ export const KevinPlugin = async (input, options) => {
                             // (legacy DBs pre-005 lack the recurrence_count
                             // column)
                             .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 {
+                            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 {
+                            // best-effort
+                        }
                         // 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
@@ -1829,6 +1995,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("./TuiActions.js");
+                                    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);
+                                    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/kevin_audit.d.ts

@@ -153,6 +153,22 @@ export interface AuditReport {
         clause_count: number;
         deprecated_count: number;
     };
+    /**
+     * v1.2.0 (K12-014 / D12-??) — TUI surface block. Read-only introspection:
+     * enabled_setting is the kevin_settings value, last_flush_age_s is seconds
+     * since meta.json generatedAt (null when absent/corrupt), mailbox_depth is
+     * queue length (null when file missing), last_results is the parsed
+     * results.json array (null when absent). Dashboard age and bridge counters
+     * added in K12-019.
+     */
+    tui?: {
+        enabled_setting: string;
+        last_flush_age_s: number | null;
+        mailbox_depth: number | null;
+        last_results: unknown | null;
+        dashboard_last_write_age_s: number | null;
+        bridge_interceptions: number;
+    };
     partial: boolean;
 }
 /**
@@ -210,4 +226,4 @@ export interface TruthReport {
         is_truncated: false;
     };
 }
-export declare function buildAudit(store: Store, metrics: Metrics, capabilities?: Capabilities, projectId?: string, repoId?: string | null): AuditReport;
+export declare function buildAudit(store: Store, metrics: Metrics, capabilities?: Capabilities, projectId?: string, repoId?: string | null, tuiRoot?: string): AuditReport;