@jmtrin/kevin-core 1.3.0 → 1.5.0

package/dist/contract.d.ts

@@ -50,6 +50,14 @@ export declare const CONTRACT_METRIC_ADDITIONS: readonly {
     name: string;
     since: string;
 }[];
+/**
+ * v1.4.0 (K14-006 / plan §4.3) — config keys added after the freeze,
+ * each carrying the `since` the deprecation policy requires (C-04).
+ */
+export declare const CONTRACT_CONFIG_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/contract.js

@@ -97,6 +97,30 @@ export const CONTRACT_METRIC_ADDITIONS = [
     // 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.4.0 (K14-006 / plan §4.3) — MCP bridge metrics (seeded by 013)
+    { name: "mcp_requests_total", since: "1.4.0" },
+    { name: "mcp_reads_served", since: "1.4.0" },
+    { name: "mcp_writes_accepted", since: "1.4.0" },
+    { name: "mcp_writes_refused", since: "1.4.0" },
+    { name: "mcp_errors_total", since: "1.4.0" },
+    // v1.5.0 (K15-001 / plan §4) — Diaspora metrics; lazy-incr.
+    { name: "mif_exports_total", since: "1.5.0" },
+    { name: "mif_imports_total", since: "1.5.0" },
+    { name: "skills_emitted_total", since: "1.5.0" },
+];
+/**
+ * v1.4.0 (K14-006 / plan §4.3) — config keys added after the freeze,
+ * each carrying the `since` the deprecation policy requires (C-04).
+ */
+export const CONTRACT_CONFIG_ADDITIONS = [
+    { name: "mcp_approve_enabled", since: "1.4.0" },
+    { name: "mcp_repo_override", since: "1.4.0" },
+    { name: "mcp_write_enabled", since: "1.4.0" },
+    // v1.5.0 (K15-001 / plan §4) — Diaspora settings; since 1.5.0.
+    { name: "import_host_memory", since: "1.5.0" },
+    { name: "skills_canonical_dir", since: "1.5.0" },
+    { name: "skills_mirror_claude", since: "1.5.0" },
+    { name: "skills_mirror_cursor", since: "1.5.0" },
 ];
 /**
  * v1.0.0 (K10-027 / plan §5.7) — the C-09 boundary addition. Stored is
@@ -137,7 +161,12 @@ export function describeContract(_input) {
     const toolValue = {
         tools: [[...CONTRACT_TOOL_NAMES].sort(), toolAdditions].flat(),
     };
-    const settingValue = { keys: [...KEVIN_CONFIG_KEYS].sort() };
+    // v1.4.0 — config keys added after freeze carry `since` (C-04)
+    const configAdditions = [...CONTRACT_CONFIG_ADDITIONS].sort((a, b) => a.name.localeCompare(b.name));
+    const baseConfigKeys = [...KEVIN_CONFIG_KEYS]
+        .filter((k) => !configAdditions.some((a) => a.name === k))
+        .sort();
+    const settingValue = { keys: [...baseConfigKeys, ...configAdditions].flat() };
     // 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)
@@ -211,7 +240,7 @@ export function describeContract(_input) {
             stability: "forward-only",
             since: "0.1.0",
             value: {
-                schema_version: "012",
+                schema_version: "013",
                 migrations_forward_only: true,
             },
         },

package/dist/import-host.d.ts

@@ -0,0 +1,41 @@
+import { type KevinEnv } from "./env.js";
+import type { MemoryService } from "./MemoryService.js";
+import type { Store } from "./Store.js";
+import type { Metrics } from "./metrics.js";
+export interface HostImportReport {
+    files_scanned: number;
+    candidates: number;
+    saved: number;
+    duplicates: number;
+    skipped_weak: number;
+    error?: string;
+    hint?: string;
+    truncated?: boolean;
+    skipped_files?: number;
+}
+export declare function parseClaudeMemory(dataRoot: string, env?: KevinEnv): {
+    candidates: {
+        content: string;
+        type: string;
+    }[];
+    files_scanned: number;
+    skipped_files: number;
+    truncated: boolean;
+};
+export declare function parseCodexMemories(dataRoot: string, env?: KevinEnv): {
+    candidates: {
+        content: string;
+        type: string;
+    }[];
+    files_scanned: number;
+    skipped_files: number;
+    truncated: boolean;
+};
+export declare function importHostMemories(opts: {
+    store: Store;
+    memoryService: MemoryService;
+    metrics?: Metrics;
+    env?: KevinEnv;
+    dataRoot?: string;
+    source: "claude-memory" | "codex-memories";
+}): HostImportReport;

package/dist/import-host.js

@@ -0,0 +1,286 @@
+// K15-011/012/013 — Host importers (plan §4.5)
+// Defensive markdown parsers, no YAML lib, same naive parser as validator.
+import { existsSync, lstatSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolveEnv } from "./env.js";
+import { fingerprint as computeFingerprint } from "./fingerprint.js";
+import { QualityGate } from "./QualityGate.js";
+const MAX_FILE_BYTES = 1 * 1024 * 1024;
+const MAX_CANDIDATES = 5000;
+const CLAUDE_TYPE_MAP = {
+    user_preference: "context",
+    project_context: "context",
+    correction: "rule",
+    code_pattern: "pattern",
+};
+// naive frontmatter parse for Claude topic files: extract type field
+function parseFrontmatterType(content) {
+    const lines = content.replace(/\r\n/g, "\n").split("\n");
+    if (lines[0]?.trim() !== "---")
+        return null;
+    let type = null;
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i].trim() === "---")
+            break;
+        const m = lines[i].match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (m && m[1].toLowerCase() === "type") {
+            type = m[2].trim().replace(/^["']|["']$/g, "");
+        }
+    }
+    return type;
+}
+function extractBullets(content) {
+    // remove frontmatter block first
+    const withoutFm = content.replace(/^---\n[\s\S]*?\n---\n?/, "");
+    const lines = withoutFm.split("\n");
+    const out = [];
+    for (const line of lines) {
+        const m = line.match(/^\s*[-*]\s+(.*)$/);
+        if (m) {
+            const trimmed = m[1].trim();
+            if (trimmed !== "")
+                out.push(trimmed);
+        }
+        else {
+            // also handle heading/bullet? codex may have headings
+            const hm = line.match(/^\s*#{1,6}\s+(.*)$/);
+            if (hm && hm[1].trim() !== "") {
+                // treat heading text as candidate? For codex, headings+bulles both
+                // but we will extract bullets only for claude; codex extractor handles headings separately
+            }
+        }
+    }
+    return out;
+}
+function safeRead(filePath) {
+    try {
+        const st = lstatSync(filePath);
+        if (st.isSymbolicLink())
+            return null;
+        if (!st.isFile())
+            return null;
+        if (st.size > MAX_FILE_BYTES)
+            return null;
+        return readFileSync(filePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+export function parseClaudeMemory(dataRoot, env) {
+    const root = join(resolveEnv(env).dataRoot ?? dataRoot, "claude", "projects");
+    // but dataRoot is already resolveEnv(...).dataRoot; we accept direct
+    const scanRoot = join(dataRoot, "claude", "projects");
+    const candidates = [];
+    let files_scanned = 0;
+    let skipped_files = 0;
+    if (!existsSync(scanRoot))
+        return { candidates, files_scanned, skipped_files, truncated: false };
+    let projectDirs = [];
+    try {
+        projectDirs = readdirSync(scanRoot);
+    }
+    catch {
+        return { candidates, files_scanned, skipped_files, truncated: false };
+    }
+    for (const proj of projectDirs) {
+        const memDir = join(scanRoot, proj, "memory");
+        if (!existsSync(memDir))
+            continue;
+        let files = [];
+        try {
+            files = readdirSync(memDir);
+        }
+        catch {
+            continue;
+        }
+        for (const f of files) {
+            if (!f.endsWith(".md"))
+                continue;
+            const full = join(memDir, f);
+            files_scanned++;
+            if (f === "MEMORY.md") {
+                // index only, skip harvesting
+                continue;
+            }
+            const content = safeRead(full);
+            if (content === null) {
+                skipped_files++;
+                continue;
+            }
+            // M-04: frontmatter without closing --- should skip
+            if (content.trimStart().startsWith("---")) {
+                const fmLines = content.replace(/\r\n/g, "\n").split("\n");
+                let hasClosing = false;
+                for (let i = 1; i < fmLines.length; i++) {
+                    if (fmLines[i].trim() === "---") {
+                        hasClosing = true;
+                        break;
+                    }
+                }
+                if (!hasClosing) {
+                    skipped_files++;
+                    continue;
+                }
+            }
+            const rawType = parseFrontmatterType(content);
+            if (rawType === null) {
+                // check if frontmatter missing or malformed: count as skipped but continue
+                // if file has no frontmatter, we still skip but not throw
+                // For test: one malformed topic file should be counted as skipped
+                if (!content.trim().startsWith("---")) {
+                    skipped_files++;
+                    continue;
+                }
+                // if frontmatter exists but type missing, map to context
+            }
+            const mapped = rawType ? (CLAUDE_TYPE_MAP[rawType.toLowerCase()] ?? "context") : "context";
+            // bullets
+            const bullets = extractBullets(content);
+            if (bullets.length === 0) {
+                // no bullets -> skip but not error
+                continue;
+            }
+            for (const b of bullets) {
+                if (candidates.length >= MAX_CANDIDATES)
+                    break;
+                candidates.push({ content: b, type: mapped });
+            }
+        }
+    }
+    const truncated = candidates.length >= MAX_CANDIDATES;
+    return { candidates, files_scanned, skipped_files, truncated };
+}
+export function parseCodexMemories(dataRoot, env) {
+    const scanRoot = join(dataRoot, "codex", "memories");
+    const candidates = [];
+    let files_scanned = 0;
+    let skipped_files = 0;
+    if (!existsSync(scanRoot))
+        return { candidates, files_scanned, skipped_files, truncated: false };
+    let files = [];
+    try {
+        files = readdirSync(scanRoot);
+    }
+    catch {
+        return { candidates, files_scanned, skipped_files, truncated: false };
+    }
+    const targets = ["memory_summary.md", "MEMORY.md"];
+    for (const t of targets) {
+        if (!files.includes(t))
+            continue;
+        const full = join(scanRoot, t);
+        files_scanned++;
+        const content = safeRead(full);
+        if (content === null) {
+            skipped_files++;
+            continue;
+        }
+        // extract headings and bullets: both become candidates type context
+        const lines = content.split("\n");
+        for (const line of lines) {
+            const bullet = line.match(/^\s*[-*]\s+(.*)$/);
+            if (bullet && bullet[1].trim() !== "") {
+                if (candidates.length >= MAX_CANDIDATES)
+                    break;
+                candidates.push({ content: bullet[1].trim(), type: "context" });
+                continue;
+            }
+            const heading = line.match(/^\s*#{1,6}\s+(.*)$/);
+            if (heading && heading[1].trim() !== "") {
+                // heading text as candidate (avoid duplicates where heading is also bullet)
+                // we treat heading as candidate as well
+                if (candidates.length >= MAX_CANDIDATES)
+                    break;
+                candidates.push({ content: heading[1].trim(), type: "context" });
+            }
+        }
+    }
+    const truncated2 = candidates.length >= MAX_CANDIDATES;
+    return { candidates, files_scanned, skipped_files, truncated: truncated2 };
+}
+export function importHostMemories(opts) {
+    const dataRoot = opts.dataRoot ?? resolveEnv(opts.env).dataRoot;
+    // gate
+    const gate = opts.memoryService.getSetting("import_host_memory", "0");
+    if (gate !== "1") {
+        return {
+            files_scanned: 0,
+            candidates: 0,
+            saved: 0,
+            duplicates: 0,
+            skipped_weak: 0,
+            error: "disabled",
+            hint: "Enable with kevin_config set import_host_memory 1",
+        };
+    }
+    let parsed;
+    if (opts.source === "claude-memory") {
+        parsed = parseClaudeMemory(dataRoot, opts.env);
+    }
+    else {
+        parsed = parseCodexMemories(dataRoot, opts.env);
+    }
+    let candidates = parsed.candidates;
+    // M-05: propagate truncated correctly from parsers
+    const truncated = (parsed.truncated ?? false) || candidates.length >= MAX_CANDIDATES;
+    if (candidates.length > MAX_CANDIDATES)
+        candidates = candidates.slice(0, MAX_CANDIDATES);
+    // pipeline per candidate: redact -> fingerprint dedup (existing rows) -> quality-gate classification -> save
+    let saved = 0;
+    let duplicates = 0;
+    let skipped_weak = 0;
+    // dedup intra-run via fingerprint set
+    const seenFingerprints = new Set();
+    // existing fingerprints from DB
+    const existingRows = opts.store.prepare("SELECT fingerprint FROM memories WHERE fingerprint IS NOT NULL").all();
+    for (const r of existingRows)
+        seenFingerprints.add(r.fingerprint);
+    for (const c of candidates) {
+        // redact (paths and private)
+        let content = c.content;
+        // simple redact paths: reuse import? For now strip private blocks
+        content = content.replace(/<private\b[^>]*>[\s\S]*?<\/private>/gi, (m) => `<private: redacted ${m.length} chars>`);
+        // fingerprint dedup
+        const fp = computeFingerprint(content);
+        if (seenFingerprints.has(fp)) {
+            duplicates++;
+            continue;
+        }
+        seenFingerprints.add(fp);
+        // quality-gate classification: weak stored-not-injected naturally
+        // We simulate: isActionable and strength via QualityGate.evaluate
+        // For host import, we consider type context is weak if generic? But we will use evaluate to decide
+        const q = QualityGate.evaluate({ errorType: "unknown", suggestion: content }, null, "unknown");
+        // If weak and not actionable, count as skipped_weak but still store? Plan says weak entries stored-but-NOT-injected
+        // So we still save but count as weak
+        const isWeak = q.strength === "weak" && !q.isActionable;
+        if (isWeak)
+            skipped_weak++;
+        // save
+        try {
+            opts.memoryService.save({
+                type: c.type,
+                content,
+                scope: "project",
+                origin: "imported",
+                fingerprint: fp,
+                metadata: { source: opts.source },
+                // evidence_count 0 => confidence low naturally, stored but not injected
+            });
+            saved++;
+        }
+        catch {
+            // skip on error
+        }
+    }
+    return {
+        files_scanned: parsed.files_scanned,
+        candidates: parsed.candidates.length,
+        saved,
+        duplicates,
+        skipped_weak,
+        truncated: truncated || undefined,
+        skipped_files: parsed.skipped_files || undefined,
+    };
+}

package/dist/index.d.ts

@@ -66,7 +66,11 @@ export * from "./kevin_propose.js";
 export { kevinPublish } from "./kevin_publish.js";
 export type { PublishResult } from "./kevin_publish.js";
 export * from "./kevin_why.js";
+export * from "./skills-validate.js";
+export * from "./skills-emit.js";
+export * from "./mif.js";
+export * from "./import-host.js";
 export * from "./env.js";
-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 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", "mcp_write_enabled", "mcp_approve_enabled", "mcp_repo_override", "skills_canonical_dir", "skills_mirror_claude", "skills_mirror_cursor", "import_host_memory"];
 export declare const ERROR_LESSON_MODE_VALUES: readonly ["all", "triage_only"];
-export declare const KEVIN_VERSION = "1.3.0";
+export declare const KEVIN_VERSION = "1.5.0";

package/dist/index.js

@@ -68,6 +68,10 @@ export { handleNative } from "./kevin_native.js";
 export * from "./kevin_propose.js";
 export { kevinPublish } from "./kevin_publish.js";
 export * from "./kevin_why.js";
+export * from "./skills-validate.js";
+export * from "./skills-emit.js";
+export * from "./mif.js";
+export * from "./import-host.js";
 // KEVIN_CONFIG_KEYS and related constants — moved from adapter index so core owns the source of truth (C-04).
 // Duplicated here to allow adapter to import from core; adapter will re-export them.
 export * from "./env.js";
@@ -104,6 +108,13 @@ export const KEVIN_CONFIG_KEYS = [
     "perf_flush_on_idle",
     "contract_report_enabled",
     "tui_snapshots_enabled",
+    "mcp_write_enabled",
+    "mcp_approve_enabled",
+    "mcp_repo_override",
+    "skills_canonical_dir",
+    "skills_mirror_claude",
+    "skills_mirror_cursor",
+    "import_host_memory",
 ];
 export const ERROR_LESSON_MODE_VALUES = ["all", "triage_only"];
-export const KEVIN_VERSION = "1.3.0";
+export const KEVIN_VERSION = "1.5.0";

package/dist/kevin_audit.d.ts

@@ -170,6 +170,37 @@ export interface AuditReport {
         dashboard_last_write_age_s: number | null;
         bridge_interceptions: number;
     };
+    /**
+     * v1.4.0 (K14-016) — MCP bridge block. Reads the five MCP counters and
+     * channel split. Omitted on pre-013 DBs (partial:true).
+     */
+    mcp?: {
+        requests: number;
+        reads: number;
+        writes_accepted: number;
+        writes_refused: number;
+        errors: number;
+        channel_split: {
+            plugin: number;
+            mcp: number;
+        };
+    };
+    channels_v2?: {
+        push: {
+            injections_total: number;
+            precision_rate: number;
+            coverage_rate: number;
+        };
+        mcp: {
+            injections_total: number;
+            precision_rate?: number;
+            coverage_rate?: number;
+        };
+        pull: {
+            registered_surfaces: number;
+            note: string;
+        };
+    };
     partial: boolean;
 }
 /**

package/dist/kevin_audit.js

@@ -609,6 +609,98 @@ export function buildAudit(store, metrics, capabilities = ALL_FALSE_CAPABILITIES
     catch {
         tui = undefined;
     }
+    // v1.4.0 (K14-016) — MCP block, gated on channel column
+    let mcp;
+    try {
+        const hasChannel = (() => {
+            try {
+                store.prepare("SELECT channel FROM kevin_injections LIMIT 1").get();
+                return true;
+            }
+            catch {
+                return false;
+            }
+        })();
+        if (!hasChannel) {
+            partial = true;
+            mcp = undefined;
+        }
+        else {
+            const getMetric = (k) => {
+                try {
+                    const row = store.prepare("SELECT value FROM kevin_metrics WHERE key = ?").get(k);
+                    return row?.value ?? metrics.get(k) ?? 0;
+                }
+                catch {
+                    return metrics.get(k) ?? 0;
+                }
+            };
+            const plugin = (() => {
+                try {
+                    return store.prepare("SELECT COUNT(*) as c FROM kevin_injections WHERE channel = 'plugin'").get().c;
+                }
+                catch {
+                    return 0;
+                }
+            })();
+            const mcpCount = (() => {
+                try {
+                    return store.prepare("SELECT COUNT(*) as c FROM kevin_injections WHERE channel = 'mcp'").get().c;
+                }
+                catch {
+                    return 0;
+                }
+            })();
+            mcp = {
+                requests: getMetric("mcp_requests_total"),
+                reads: getMetric("mcp_reads_served"),
+                writes_accepted: getMetric("mcp_writes_accepted"),
+                writes_refused: getMetric("mcp_writes_refused"),
+                errors: getMetric("mcp_errors_total"),
+                channel_split: { plugin, mcp: mcpCount },
+            };
+        }
+    }
+    catch {
+        partial = true;
+        mcp = undefined;
+    }
+    // v1.5.0 (K15-015) — channels_v2 honest scope (D15-06)
+    let channels_v2;
+    try {
+        const push_total = scalar(store, "SELECT COUNT(*) AS n FROM kevin_injections WHERE channel = 'plugin' OR channel IS NULL");
+        const mcp_total = (() => { try {
+            return scalar(store, "SELECT COUNT(*) AS n FROM kevin_injections WHERE channel = 'mcp'");
+        }
+        catch {
+            return 0;
+        } })();
+        const hasChannel = (() => { try {
+            store.prepare("SELECT channel FROM kevin_injections LIMIT 1").get();
+            return true;
+        }
+        catch {
+            return false;
+        } })();
+        const registered_surfaces = (() => {
+            try {
+                const r1 = store.prepare("SELECT value FROM kevin_metrics WHERE key = 'skills_registered'").get();
+                const r2 = store.prepare("SELECT value FROM kevin_metrics WHERE key = 'references_registered'").get();
+                return (r1?.value ?? 0) + (r2?.value ?? 0);
+            }
+            catch {
+                return 0;
+            }
+        })();
+        channels_v2 = {
+            push: { injections_total: push_total, precision_rate: metrics.precisionRate(), coverage_rate: metrics.coverageRate() },
+            mcp: { injections_total: hasChannel ? mcp_total : 0 },
+            pull: { registered_surfaces, note: "pull-effectiveness telemetry unavailable pre-contract-v2 — qualitative" },
+        };
+    }
+    catch {
+        channels_v2 = undefined;
+    }
     return {
         memories,
         injections,
@@ -626,6 +718,8 @@ export function buildAudit(store, metrics, capabilities = ALL_FALSE_CAPABILITIES
         perf,
         contract,
         tui,
+        mcp,
+        channels_v2,
         partial,
     };
 }

package/dist/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", "bench_regression_failures", "forget_requests_total", "forget_tombstones_published", "tui_snapshots_flushed", "tui_actions_invoked"];
+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", "mcp_requests_total", "mcp_reads_served", "mcp_writes_accepted", "mcp_writes_refused", "mcp_errors_total", "skills_emitted_total", "mif_exports_total", "mif_imports_total"];
 export type MetricKey = (typeof METRIC_KEYS)[number];
 /**
  * Cheap token estimate used when bumping the `tokens_injected_*` counters.

package/dist/metrics.js

@@ -65,6 +65,16 @@ export const METRIC_KEYS = [
     // release — rows are created on first incr via upsert (K12-001).
     "tui_snapshots_flushed",
     "tui_actions_invoked",
+    // v1.4.0 (K14-003 / plan §4.3, D14-??) — MCP bridge metrics; seeds via 013.
+    "mcp_requests_total",
+    "mcp_reads_served",
+    "mcp_writes_accepted",
+    "mcp_writes_refused",
+    "mcp_errors_total",
+    // v1.5.0 (K15-001 / plan §4) — Diaspora metrics; lazy-incr, no migration.
+    "skills_emitted_total",
+    "mif_exports_total",
+    "mif_imports_total",
 ];
 const DEFAULT_FLUSH_MS = 1000;
 function zeroCache() {

package/dist/mif.d.ts

@@ -0,0 +1,32 @@
+import type { Memory } from "./MemoryService.js";
+export interface MifEnvelope {
+    format: "mif";
+    version: 1;
+    memories: MifMemory[];
+    vendorExtensions?: Record<string, unknown>;
+}
+export interface MifMemory {
+    id: string;
+    content: string;
+    type: string;
+    timestamp: string;
+    source: string;
+    metadata: Record<string, string>;
+    [k: string]: unknown;
+}
+export declare function toMif(rows: Memory[], opts: {
+    redactPii: boolean;
+}): MifEnvelope;
+export interface ImportCandidate {
+    id: string;
+    content: string;
+    type: string;
+    timestamp: string;
+    source: string;
+    metadata: Record<string, string>;
+    unknownFields: Record<string, unknown>;
+}
+export declare function fromMif(env: MifEnvelope): {
+    candidates: ImportCandidate[];
+    unknownFieldsPreserved: string[];
+};