@jmtrin/kevin-core 1.4.0 → 2.0.0

package/dist/contract.js

@@ -45,7 +45,115 @@ export function resolveScanRoots(env) {
     // Fallback to monorepo relative (even if not yet built)
     return [monorepoPlugin, monorepoCore];
 }
-export const CONTRACT_VERSION = 1;
+export const CONTRACT_VERSION = 2;
+// v2.0.0 (K16-001 / plan §4.1) — C-10 core exports (names + kinds, since 1.3.0)
+// Explicit export list at packages/core/src/index.ts — keep minimal.
+export const CONTRACT_CORE_EXPORTS = [
+    { name: "Archiver", kind: "class" },
+    { name: "ArtifactWriter", kind: "class" },
+    { name: "CausalChain", kind: "class" },
+    { name: "ChatBridge", kind: "module" },
+    { name: "ConflictDetector", kind: "class" },
+    { name: "ContextInjector", kind: "class" },
+    { name: "ConventionMiner", kind: "class" },
+    { name: "Curator", kind: "class" },
+    { name: "DashboardHtml", kind: "module" },
+    { name: "Feedback", kind: "class" },
+    { name: "HookLiveness", kind: "class" },
+    { name: "InjectionLedger", kind: "class" },
+    { name: "LessonFixer", kind: "module" },
+    { name: "Materializer", kind: "class" },
+    { name: "MemoryService", kind: "class" },
+    { name: "Migrate", kind: "class" },
+    { name: "PatternMiner", kind: "class" },
+    { name: "QualityGate", kind: "class" },
+    { name: "Reflector", kind: "class" },
+    { name: "RepoIdentity", kind: "module" },
+    { name: "RepoTruth", kind: "class" },
+    { name: "Retrospective", kind: "class" },
+    { name: "SharedLayer", kind: "class" },
+    { name: "Store", kind: "class" },
+    { name: "ToolCallObserver", kind: "class" },
+    { name: "TuiSnapshots", kind: "module" },
+    { name: "buildAudit", kind: "function" },
+    { name: "buildDoctor", kind: "function" },
+    { name: "buildKevinContract", kind: "function" },
+    { name: "computeConfidence", kind: "function" },
+    { name: "describeContract", kind: "function" },
+    { name: "escapeForFence", kind: "function" },
+    { name: "escapeForMarkerBlock", kind: "function" },
+    { name: "fingerprint", kind: "function" },
+    { name: "fnv1a64", kind: "function" },
+    { name: "kevin_approve", kind: "function" },
+    { name: "kevin_bench", kind: "function" },
+    { name: "kevin_forget", kind: "function" },
+    { name: "kevin_why", kind: "function" },
+    { name: "resolveEnv", kind: "function" },
+    { name: "uuidv7", kind: "function" },
+];
+// v2.0.0 (K16-001) — C-11 MCP tool names/shapes + refusal vocabulary, since 1.4.0
+export const CONTRACT_MCP_TOOLS = [
+    "approve",
+    "feedback",
+    "get",
+    "ping",
+    "query",
+    "recall",
+    "save",
+    "share",
+    "status",
+    "trace",
+    "why",
+];
+export const CONTRACT_MCP_REFUSALS = [
+    "disabled",
+    "repo_mismatch",
+    "not_okf",
+    "version_ahead",
+    "unknown_entry",
+    "parse_damaged",
+    "line_too_long",
+    "below_floor",
+    "not_curated",
+    "too_many_entries",
+];
+// v2.0.0 (K16-001) — C-12 emitted skills layout, since 1.5.0
+export const CONTRACT_SKILLS_LAYOUT = {
+    canonical_dir: ".agents/skills",
+    skill_dir: "kevin-knowledge",
+    files: ["SKILL.md", "references/*.md"],
+    frontmatter_fields: ["name", "description", "metadata.generator", "metadata.repo_id"],
+    mirror_policy: "copy (not symlink) to .claude/skills and .cursor/skills when enabled",
+};
+// v2.0.0 (K16-001) — C-13 MIF profile, since 1.5.0
+export const CONTRACT_MIF_PROFILE = {
+    envelope_version: 1,
+    format: "mif",
+    field_mapping: {
+        entry_id: "id",
+        statement: "content",
+        type: "type",
+        scope: "metadata.scope",
+        fingerprint: "metadata.fingerprint",
+        confidence: "metadata.confidence",
+        created_at: "timestamp",
+    },
+    redaction: "SECRET_PATTERNS (PII)",
+    dedup: "content-hash (fingerprint)",
+    vendor_extensions_preserved: true,
+};
+// v2.0.0 (K16-001) — C-14 MemorySources, since 2.0.0
+export const CONTRACT_MEMORY_SOURCES = {
+    sources: [
+        { name: "opencode-plugin", precedence: 10 },
+        { name: "claude-memory", precedence: 20 },
+        { name: "codex-memories", precedence: 30 },
+        { name: "opencode-native", precedence: 40 },
+    ],
+    dedup_rule: "lower precedence wins attribution; losers counted in source_dedup_skips_total",
+    conflict_kind: "source_pair",
+    precedence_order: [10, 20, 30, 40],
+};
 // Tool names — the live source of truth for C-03. Any rename here must
 // flow to the contract (K10-006 AC: renaming a tool changes C-03).
 // Keep this array adjacent to the actual tool registrations in index.ts
@@ -85,6 +193,7 @@ export const CONTRACT_TOOL_ADDITIONS = [
     { name: "kevin_bench", since: "1.0.0" },
     { name: "kevin_contract", since: "1.0.0" },
     { name: "kevin_forget", since: "1.1.0" },
+    { name: "kevin_sources", since: "2.0.0" },
 ];
 /**
  * v1.1.0 (K11-007 / plan §5.1, D11-01) — metric keys added after the freeze,
@@ -103,6 +212,14 @@ export const CONTRACT_METRIC_ADDITIONS = [
     { 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" },
+    // v2.0.0 (K16-012 / plan §4.4) — Commonwealth metrics
+    { name: "source_syncs_total", since: "2.0.0" },
+    { name: "source_dedup_skips_total", since: "2.0.0" },
+    { name: "okf_v3_files_written", since: "2.0.0" },
 ];
 /**
  * v1.4.0 (K14-006 / plan §4.3) — config keys added after the freeze,
@@ -112,6 +229,29 @@ 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" },
+    // v2.0.0 (K16-013 / plan §4.4) — Commonwealth settings (retirement of import_host_memory handled via removals)
+    { name: "okf_write_version", since: "2.0.0" },
+    { name: "source_claude_memory", since: "2.0.0" },
+    { name: "source_codex_memories", since: "2.0.0" },
+    { name: "source_opencode_native", since: "2.0.0" },
+    { name: "sources_enabled", since: "2.0.0" },
+];
+/**
+ * v2.0.0 (K16-004 / plan §5.1) — removed settings (retirements)
+ * Each entry carries `since` 2.0.0 and optional replacement pointer.
+ * Succession test treats these as LEGITIMATE removals via `removed` annotation.
+ */
+export const CONTRACT_REMOVED_CONFIG_KEYS = [
+    {
+        name: "import_host_memory",
+        since: "2.0.0",
+        replacement: "sources_enabled + source_claude_memory/source_codex_memories",
+    },
 ];
 /**
  * v1.0.0 (K10-027 / plan §5.7) — the C-09 boundary addition. Stored is
@@ -157,7 +297,14 @@ export function describeContract(_input) {
     const baseConfigKeys = [...KEVIN_CONFIG_KEYS]
         .filter((k) => !configAdditions.some((a) => a.name === k))
         .sort();
-    const settingValue = { keys: [...baseConfigKeys, ...configAdditions].flat() };
+    // v2.0.0 (K16-004/005) — removed keys are filtered from `keys` and surfaced via `removed` annotation with since 2.0.0
+    const removedConfig = [...CONTRACT_REMOVED_CONFIG_KEYS].sort((a, b) => a.name.localeCompare(b.name));
+    const filteredConfigAdditions = configAdditions.filter((a) => !removedConfig.some((r) => r.name === a.name));
+    const settingValue = {
+        keys: [...baseConfigKeys, ...filteredConfigAdditions].flat(),
+    };
+    if (removedConfig.length > 0)
+        settingValue.removed = removedConfig;
     // 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)
@@ -231,7 +378,7 @@ export function describeContract(_input) {
             stability: "forward-only",
             since: "0.1.0",
             value: {
-                schema_version: "013",
+                schema_version: "014",
                 migrations_forward_only: true,
             },
         },
@@ -265,6 +412,44 @@ export function describeContract(_input) {
                 boundary: [{ name: BOUNDARY_INVARIANT, since: "1.0.0" }],
             },
         },
+        {
+            id: "C-10",
+            title: "Core public exports",
+            stability: "frozen",
+            since: "1.3.0",
+            value: { exports: [...CONTRACT_CORE_EXPORTS].sort((a, b) => a.name.localeCompare(b.name)) },
+        },
+        {
+            id: "C-11",
+            title: "MCP tool names and refusal vocabulary",
+            stability: "frozen",
+            since: "1.4.0",
+            value: {
+                tools: [...CONTRACT_MCP_TOOLS].sort(),
+                refusals: [...CONTRACT_MCP_REFUSALS].sort(),
+            },
+        },
+        {
+            id: "C-12",
+            title: "Emitted skills layout",
+            stability: "frozen",
+            since: "1.5.0",
+            value: CONTRACT_SKILLS_LAYOUT,
+        },
+        {
+            id: "C-13",
+            title: "MIF profile",
+            stability: "frozen",
+            since: "1.5.0",
+            value: CONTRACT_MIF_PROFILE,
+        },
+        {
+            id: "C-14",
+            title: "MemorySources",
+            stability: "frozen",
+            since: "2.0.0",
+            value: CONTRACT_MEMORY_SOURCES,
+        },
     ];
     return { contractVersion: CONTRACT_VERSION, clauses };
 }
@@ -368,6 +553,33 @@ export function diffContract(golden, live) {
         // Normalize members: for arrays we care about set equality
         for (const [mem, _gv] of gMembers) {
             if (!lMembers.has(mem)) {
+                // v2.0.0 (K16-005) — allow removals that are annotated via `removed` array with since (e.g. import_host_memory)
+                const liveVal = l.value;
+                if (Array.isArray(liveVal.removed)) {
+                    const entry = liveVal.removed.find((e) => {
+                        if (typeof e === "string")
+                            return e === mem;
+                        if (e !== null &&
+                            typeof e === "object" &&
+                            "name" in e)
+                            return e.name === mem;
+                        return false;
+                    });
+                    const hasSince = entry !== null &&
+                        typeof entry === "object" &&
+                        typeof entry.since === "string" &&
+                        entry.since !== "";
+                    if (entry !== undefined && hasSince) {
+                        // Annotated removal — treat as allowed (like added_ok). Do not flag as confusing.
+                        diffs.push({
+                            clauseId: g.id,
+                            path: `${g.id}.${mem}`,
+                            kind: "added_ok",
+                            remedy: `Member ${mem} in ${g.id} was removed with since. Allowed in 2.0.0.`,
+                        });
+                        continue;
+                    }
+                }
                 diffs.push({
                     clauseId: g.id,
                     path: `${g.id}.${mem}`,

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,14 @@ 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 "./okf-shards.js";
+export * from "./sources/MemorySource.js";
+export * from "./sources/IdleSync.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", "mcp_write_enabled", "mcp_approve_enabled", "mcp_repo_override"];
+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", "sources_enabled", "source_claude_memory", "source_codex_memories", "source_opencode_native", "okf_write_version"];
 export declare const ERROR_LESSON_MODE_VALUES: readonly ["all", "triage_only"];
-export declare const KEVIN_VERSION = "1.4.0";
+export declare const KEVIN_VERSION = "2.0.0";

package/dist/index.js

@@ -68,6 +68,13 @@ 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";
+export * from "./okf-shards.js";
+export * from "./sources/MemorySource.js";
+export * from "./sources/IdleSync.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";
@@ -107,6 +114,14 @@ export const KEVIN_CONFIG_KEYS = [
     "mcp_write_enabled",
     "mcp_approve_enabled",
     "mcp_repo_override",
+    "skills_canonical_dir",
+    "skills_mirror_claude",
+    "skills_mirror_cursor",
+    "sources_enabled",
+    "source_claude_memory",
+    "source_codex_memories",
+    "source_opencode_native",
+    "okf_write_version",
 ];
 export const ERROR_LESSON_MODE_VALUES = ["all", "triage_only"];
-export const KEVIN_VERSION = "1.4.0";
+export const KEVIN_VERSION = "2.0.0";

package/dist/kevin_audit.d.ts

@@ -185,6 +185,22 @@ export interface AuditReport {
             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;
 }
 /**