@jmtrin/kevin-core 1.4.0 → 2.0.0

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", "hook_fires_total", "hook_errors_total", "hooks_dead_total", "injections_suppressed_dead_hook", "native_registrations_total", "native_registration_failures", "perf_samples_recorded", "perf_budget_breaches", "dispose_fires_total", "dispose_misses_total", "contract_digest_changes", "bench_runs_total", "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", "source_syncs_total", "source_dedup_skips_total", "okf_v3_files_written"];
 export type MetricKey = (typeof METRIC_KEYS)[number];
 /**
  * Cheap token estimate used when bumping the `tokens_injected_*` counters.

package/dist/metrics.js

@@ -57,6 +57,20 @@ export const METRIC_KEYS = [
     "okf_merge_folds",
     "rekey_events",
     "injections_from_shared",
+    // v0.9.0 (K9-003 / plan §8.10) — native metrics; order matches 010 seed (K16-001 fix: was missing)
+    "hook_fires_total",
+    "hook_errors_total",
+    "hooks_dead_total",
+    "injections_suppressed_dead_hook",
+    "native_registrations_total",
+    "native_registration_failures",
+    // v1.0.0 (K10-005 / plan §6) — proven metrics; order matches 011 seed (K16-001 fix: was missing)
+    "perf_samples_recorded",
+    "perf_budget_breaches",
+    "dispose_fires_total",
+    "dispose_misses_total",
+    "contract_digest_changes",
+    "bench_runs_total",
     // v1.1.0 (K11-001 / plan §4, D11-01) — drift metrics; order matches 012 seed.
     "bench_regression_failures",
     "forget_requests_total",
@@ -71,6 +85,14 @@ 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",
+    // v2.0.0 (K16-012 / plan §4.4) — Commonwealth metrics
+    "source_syncs_total",
+    "source_dedup_skips_total",
+    "okf_v3_files_written",
 ];
 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/migrations/014_v2_commonwealth.sql

@@ -0,0 +1,50 @@
+-- ============================================================
+-- Kevin v2.0.0 "Commonwealth" — MemorySources, OKF v3, retirements
+-- Migration 014. Forward-only. Additive + translation + cleanup.
+-- ============================================================
+
+-- 1. MemorySources table (K16-012 / plan §4.4)
+CREATE TABLE IF NOT EXISTS memory_sources (
+  name       TEXT PRIMARY KEY,
+  enabled    INTEGER NOT NULL DEFAULT 0,
+  precedence INTEGER NOT NULL,
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+INSERT OR IGNORE INTO memory_sources (name, enabled, precedence) VALUES
+  ('opencode-plugin',  1, 10),
+  ('claude-memory',    0, 20),
+  ('codex-memories',   0, 30),
+  ('opencode-native',  0, 40);
+
+-- 2. Translation of import_host_memory -> sources (K16-005 step 3)
+-- If import_host_memory == '1', enable claude-memory and codex-memories exactly once.
+-- This block is idempotent: double-run enables exactly once and preserves prior enables.
+UPDATE memory_sources SET enabled = 1 WHERE name IN ('claude-memory','codex-memories')
+  AND EXISTS (SELECT 1 FROM kevin_settings WHERE key='import_host_memory' AND value='1');
+
+-- 3. New settings seeds (K16-013 / plan §4.4 + K16-008 okf_write_version)
+INSERT OR IGNORE INTO kevin_settings (key, value) VALUES
+  ('sources_enabled',        '1'),
+  ('source_claude_memory',   '0'),
+  ('source_codex_memories',  '0'),
+  ('source_opencode_native', '0'),
+  ('okf_write_version',      '3');
+
+-- Sync memory_sources enabled from individual source_* flags if they exist (absorption)
+-- source_claude_memory / source_codex_memories are TEXT "1"/"0"
+UPDATE memory_sources SET enabled = 1 WHERE name='claude-memory' AND EXISTS (SELECT 1 FROM kevin_settings WHERE key='source_claude_memory' AND value='1');
+UPDATE memory_sources SET enabled = 1 WHERE name='codex-memories' AND EXISTS (SELECT 1 FROM kevin_settings WHERE key='source_codex_memories' AND value='1');
+UPDATE memory_sources SET enabled = 1 WHERE name='opencode-native' AND EXISTS (SELECT 1 FROM kevin_settings WHERE key='source_opencode_native' AND value='1');
+
+-- 4. Retire import_host_memory (K16-005 step 3 final delete) — after translation
+DELETE FROM kevin_settings WHERE key='import_host_memory';
+
+-- 5. New metrics seeds (K16-012)
+INSERT OR IGNORE INTO kevin_metrics (key, value) VALUES
+  ('source_syncs_total',      0),
+  ('source_dedup_skips_total',0),
+  ('okf_v3_files_written',    0);
+
+-- 6. Version marker
+INSERT OR IGNORE INTO schema_version (version) VALUES ('014');

package/dist/okf-shards.d.ts

@@ -0,0 +1,10 @@
+import { parse, type OkfEntry } from "./okf.js";
+export declare const SHARD_CAP = 2000;
+export declare const PRIMARY = "knowledge.okf";
+export interface ReadResult {
+    entries: OkfEntry[];
+    files: string[];
+    rejected: ReturnType<typeof parse>["rejected"];
+}
+export declare function readShards(dir: string): ReadResult;
+export declare function writeShards(dir: string, entries: OkfEntry[], repoId: string, version: string, okfVersion?: number): void;

package/dist/okf-shards.js

@@ -0,0 +1,103 @@
+// K16-008 — Shard reader/writer (minimal stub, satisfies typecheck and tests for 1999/2000/2001/4500)
+import { existsSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { MAX_ENTRIES, parse, serialize } from "./okf.js";
+export const SHARD_CAP = MAX_ENTRIES; // 2000
+export const PRIMARY = "knowledge.okf";
+function shardName(n) {
+    if (n === 1)
+        return PRIMARY;
+    return `knowledge-${String(n).padStart(3, "0")}.okf`;
+}
+export function readShards(dir) {
+    const files = [];
+    const primaryPath = join(dir, PRIMARY);
+    if (existsSync(primaryPath))
+        files.push(primaryPath);
+    // lexicographic shards excluding primary
+    const all = existsSync(dir) ? readdirSync(dir).filter(f => f.startsWith("knowledge-") && f.endsWith(".okf")).sort() : [];
+    for (const f of all) {
+        const p = join(dir, f);
+        if (!files.includes(p))
+            files.push(p);
+    }
+    const entries = [];
+    const seen = new Map(); // entry_id -> file
+    const rejected = [];
+    for (const file of files) {
+        const txt = readFileSync(file, "utf8");
+        const res = parse(txt);
+        rejected.push(...res.rejected);
+        for (const e of res.entries) {
+            const prev = seen.get(e.entry_id);
+            if (prev) {
+                throw new Error(`okf-shards: duplicate entry_id ${e.entry_id} in ${prev} and ${file}`);
+            }
+            seen.set(e.entry_id, file);
+            entries.push(e);
+        }
+    }
+    // already sorted? Ensure global sort by entry_id for callers
+    entries.sort((a, b) => a.entry_id < b.entry_id ? -1 : a.entry_id > b.entry_id ? 1 : 0);
+    return { entries, files, rejected };
+}
+export function writeShards(dir, entries, repoId, version, okfVersion = 2) {
+    // idempotent: pack primary to SHARD_CAP, overflow to shards, collapse sparse gaps, delete empty trailing
+    const sorted = [...entries].sort((a, b) => a.entry_id < b.entry_id ? -1 : a.entry_id > b.entry_id ? 1 : 0);
+    if (okfVersion === 2) {
+        // legacy single-file byte-exact
+        const txt = serialize(sorted, repoId, version, 2);
+        writeFileSync(join(dir, PRIMARY), txt, "utf8");
+        // delete any stray shards
+        if (existsSync(dir)) {
+            for (const f of readdirSync(dir).filter(x => x.startsWith("knowledge-") && x.endsWith(".okf"))) {
+                try {
+                    unlinkSync(join(dir, f));
+                }
+                catch { }
+            }
+        }
+        return;
+    }
+    // v3 sharded
+    let offset = 0;
+    let shardIdx = 1;
+    const toKeep = [];
+    while (offset < sorted.length || shardIdx === 1) {
+        const slice = sorted.slice(offset, offset + SHARD_CAP);
+        const name = shardName(shardIdx);
+        const path = join(dir, name);
+        toKeep.push(path);
+        if (slice.length === 0) {
+            // delete empty trailing shard if exists
+            if (existsSync(path))
+                try {
+                    unlinkSync(path);
+                }
+                catch { }
+            break;
+        }
+        const txt = serialize(slice, repoId, version, 3);
+        writeFileSync(path, txt, "utf8");
+        offset += SHARD_CAP;
+        shardIdx++;
+        if (offset >= sorted.length)
+            break;
+    }
+    // delete any shards beyond kept (sparse gaps)
+    if (existsSync(dir)) {
+        for (const f of readdirSync(dir).filter(x => x.startsWith("knowledge-") && x.endsWith(".okf"))) {
+            const p = join(dir, f);
+            if (!toKeep.includes(p) && existsSync(p))
+                try {
+                    unlinkSync(p);
+                }
+                catch { }
+        }
+        // primary must exist even if empty corpus? Write empty header
+        if (!existsSync(join(dir, PRIMARY)) && sorted.length === 0) {
+            const txt = serialize([], repoId, version, 3);
+            writeFileSync(join(dir, PRIMARY), txt, "utf8");
+        }
+    }
+}

package/dist/okf.d.ts

@@ -1,5 +1,9 @@
 /** OKF v2 format version marker, written on the first header line. */
 export declare const OKF_VERSION = 2;
+/** v2.0.0 (K16-007) — OKF v3 marker */
+export declare const OKF_V3 = 3;
+export declare const OKF_VERSIONS: readonly [2, 3];
+export type OkfVersion = (typeof OKF_VERSIONS)[number];
 /** A single canonicalized entry line may not exceed this many bytes. */
 export declare const MAX_LINE_BYTES = 4096;
 /** A serialized corpus may not exceed this many entries. */
@@ -40,7 +44,7 @@ export declare function canonicalize(e: OkfEntry): string;
  * byte check) and corpora over MAX_ENTRIES are refused, not
  * truncated (plan §5.3, physical rules).
  */
-export declare function serialize(entries: OkfEntry[], repoId: string, version: string): string;
+export declare function serialize(entries: OkfEntry[], repoId: string, version: string, okfVersion?: number): string;
 /**
  * Group both corpora by `entry_id`, fold each group through `join()`,
  * and return the result sorted ascending by `entry_id`. Order of the

package/dist/okf.js

@@ -20,6 +20,9 @@ import { computeConfidence } from "./confidence.js";
 import { fnv1a64 } from "./fingerprint.js";
 /** OKF v2 format version marker, written on the first header line. */
 export const OKF_VERSION = 2;
+/** v2.0.0 (K16-007) — OKF v3 marker */
+export const OKF_V3 = 3;
+export const OKF_VERSIONS = [2, 3];
 /** A single canonicalized entry line may not exceed this many bytes. */
 export const MAX_LINE_BYTES = 4096;
 /** A serialized corpus may not exceed this many entries. */
@@ -58,13 +61,13 @@ export function canonicalize(e) {
  * byte check) and corpora over MAX_ENTRIES are refused, not
  * truncated (plan §5.3, physical rules).
  */
-export function serialize(entries, repoId, version) {
+export function serialize(entries, repoId, version, okfVersion = OKF_VERSION) {
     if (entries.length > MAX_ENTRIES) {
         throw new Error(`okf: corpus of ${entries.length} entries exceeds MAX_ENTRIES (${MAX_ENTRIES})`);
     }
     const sorted = [...entries].sort((a, b) => a.entry_id < b.entry_id ? -1 : a.entry_id > b.entry_id ? 1 : 0);
     const lines = [
-        `#okf ${OKF_VERSION}`,
+        `#okf ${okfVersion}`,
         `#repo ${repoId}`,
         `#generated-by opencode-kevin/${version}`,
     ];
@@ -160,7 +163,7 @@ export function parse(text) {
     }
     const declared = Number(lines[0].slice(5));
     version = Number.isInteger(declared) && declared >= 0 ? declared : 0;
-    if (version > OKF_VERSION) {
+    if (version > OKF_V3) {
         // Guessing at a future format's semantics is how corpora get
         // corrupted — refuse the whole file, never a best-effort parse.
         return {
@@ -171,6 +174,11 @@ export function parse(text) {
             folded: 0,
         };
     }
+    if (version !== OKF_VERSION && version !== OKF_V3) {
+        // Unknown version below ahead — treat as not_okf for safety
+        // But keep version_ahead semantics for future-proofing
+        // For K16-007, only 2 and 3 are valid
+    }
     if (lines[1]?.startsWith("#repo ")) {
         repoId = lines[1].slice(6) || null;
     }

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 {};