@jmtrin/kevin-core 1.4.0 → 1.5.0

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", "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", "import_host_memory"];
 export declare const ERROR_LESSON_MODE_VALUES: readonly ["all", "triage_only"];
-export declare const KEVIN_VERSION = "1.4.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";
@@ -107,6 +111,10 @@ export const KEVIN_CONFIG_KEYS = [
     "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.4.0";
+export const KEVIN_VERSION = "1.5.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;
 }
 /**

package/dist/kevin_audit.js

@@ -665,6 +665,42 @@ export function buildAudit(store, metrics, capabilities = ALL_FALSE_CAPABILITIES
         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,
@@ -683,6 +719,7 @@ export function buildAudit(store, metrics, capabilities = ALL_FALSE_CAPABILITIES
         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", "mcp_requests_total", "mcp_reads_served", "mcp_writes_accepted", "mcp_writes_refused", "mcp_errors_total"];
+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

@@ -71,6 +71,10 @@ export const METRIC_KEYS = [
     "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[];
+};

package/dist/mif.js

@@ -0,0 +1,112 @@
+// K15-008 — MIF codec (plan §4.4)
+// Envelope {id, content, type, timestamp, source, metadata} + vendor extensions preserved + PII redaction + content-hash dedup (import side)
+import { fingerprint as computeFingerprint } from "./fingerprint.js";
+const SECRET_PATTERNS = [
+    /\b(API_KEY|SECRET|PASSWORD|TOKEN)\b\s*[=:]\s*\S+/gi,
+    /\bBearer\s+\S+/gi,
+    /\b(access_?token|auth_?token|api_?token)\b\s*[=:]\s*\S+/gi,
+    /\btoken\s*[=:]\s*\S+/gi,
+    /\baws_secret_access_key\b\s*[=:]\s*\S+/gi,
+    /\bghp_[A-Za-z0-9_]+/g,
+    /\bsk-[A-Za-z0-9_\-]+/g,
+    /\bgithub_pat_[A-Za-z0-9_]+/g,
+];
+function redactSecrets(text) {
+    let out = text;
+    for (const pat of SECRET_PATTERNS) {
+        out = out.replace(pat, (m) => {
+            const eq = m.indexOf("=");
+            const colon = m.indexOf(":");
+            const sep = eq !== -1 ? "=" : colon !== -1 ? ":" : " ";
+            const prefix = m.slice(0, m.indexOf(sep) + 1);
+            return `${prefix}<redacted>`;
+        });
+    }
+    // fallback: if pattern didn't match sep, replace whole token
+    return out;
+}
+function toIso(ts) {
+    try {
+        const iso = ts.includes("T") ? ts : `${ts.replace(" ", "T")}Z`;
+        return new Date(iso).toISOString();
+    }
+    catch {
+        return new Date().toISOString();
+    }
+}
+export function toMif(rows, opts) {
+    const memories = rows.map((r) => {
+        const originalContent = r.content;
+        let content = originalContent;
+        if (opts.redactPii) {
+            content = redactSecrets(content);
+        }
+        const meta = {
+            scope: String(r.scope ?? "project"),
+            fingerprint: String(r.fingerprint ?? computeFingerprint(originalContent)),
+            confidence: String(r.confidence ?? ""),
+            evidence_count: String(r.evidenceCount ?? 0),
+        };
+        const base = {
+            id: r.id,
+            content,
+            type: r.type,
+            timestamp: toIso(r.createdAt ?? new Date().toISOString()),
+            source: "opencode-kevin",
+            metadata: meta,
+        };
+        // preserve unknown fields from original row that are not part of standard mapping
+        // standard keys: id, content, type, createdAt, scope, fingerprint, confidence, evidenceCount, etc.
+        // unknown vendor extensions stored under `mif_vendor` in metadata if present
+        const mifVendor = r.mif_vendor;
+        if (mifVendor && typeof mifVendor === "object") {
+            for (const [k, v] of Object.entries(mifVendor)) {
+                if (!(k in base))
+                    base[k] = v;
+            }
+        }
+        // also check if row has extra top-level keys beyond Memory standard (for codec-level preservation)
+        const extraKeys = Object.keys(r).filter((k) => !["id", "content", "type", "scope", "createdAt", "updatedAt", "fingerprint", "confidence", "evidenceCount", "recurrenceCount", "projectId", "repoId", "layer", "status", "metadata", "origin", "sourceTool", "sourceSession", "relevanceScore", "truthPenalty"].includes(k));
+        for (const k of extraKeys) {
+            if (k === "mif_vendor")
+                continue;
+            if (!(k in base))
+                base[k] = r[k];
+        }
+        return base;
+    });
+    return { format: "mif", version: 1, memories };
+}
+export function fromMif(env) {
+    if (!env || env.format !== "mif" || env.version !== 1 || !Array.isArray(env.memories)) {
+        throw new Error("invalid MIF envelope: expected {format:'mif', version:1, memories:[]}");
+    }
+    const candidates = [];
+    const preserved = new Set();
+    for (const m of env.memories) {
+        const known = new Set(["id", "content", "type", "timestamp", "source", "metadata", "format", "version"]);
+        const unknown = {};
+        for (const k of Object.keys(m)) {
+            if (!known.has(k)) {
+                unknown[k] = m[k];
+                preserved.add(k);
+            }
+        }
+        // also collect vendorExtensions top-level unknown?
+        candidates.push({
+            id: String(m.id),
+            content: String(m.content),
+            type: String(m.type),
+            timestamp: String(m.timestamp),
+            source: String(m.source ?? "opencode-kevin"),
+            metadata: { ...(m.metadata ?? {}) },
+            unknownFields: unknown,
+        });
+    }
+    // top-level vendorExtensions unknown
+    if (env.vendorExtensions) {
+        for (const k of Object.keys(env.vendorExtensions))
+            preserved.add(k);
+    }
+    return { candidates, unknownFieldsPreserved: [...preserved] };
+}

package/dist/skills-emit.d.ts

@@ -0,0 +1,38 @@
+import { type KevinEnv } from "./env.js";
+export interface TopicBundle {
+    topic: string;
+    content: string;
+    /** optional precomputed summary; derived from content if omitted */
+    summary?: string;
+}
+export interface SkillEmitInput {
+    projectRoot: string;
+    canonicalDir: string;
+    mirrors: Array<"claude" | "cursor">;
+    topics: TopicBundle[];
+    repoId: string;
+    /** injectable for tests; defaults to ~/.opencode-kevin/skills-manifest.json */
+    manifestPath?: string;
+    env?: KevinEnv;
+    metrics?: {
+        incr: (key: string, by?: number) => void;
+    };
+}
+export interface EmitReport {
+    written: string[];
+    skipped_external: string[];
+    noop: string[];
+    removed_orphan_manifest: string[];
+    external_edits: string[];
+}
+declare function sha256Hex(s: string): string;
+declare function escaped(text: string): string;
+declare function buildSkillMd(repoId: string, bundles: TopicBundle[]): string;
+export declare function emitSkillBundle(input: SkillEmitInput): EmitReport;
+export declare function refreshSkillBundle(input: SkillEmitInput): EmitReport;
+export declare const _internal: {
+    buildSkillMd: typeof buildSkillMd;
+    sha256Hex: typeof sha256Hex;
+    escaped: typeof escaped;
+};
+export {};