@jmtrin/kevin-core 1.3.0

package/dist/diff.js

@@ -0,0 +1,182 @@
+// v0.6.0 (K6-006 / plan §5.2, D6-05) — a minimal deterministic unified-diff
+// generator. Pure, dependency-free, byte-for-byte compatible with
+// `git diff -U3 --no-index` for the fixtures the tests compare.
+//
+// It exists for exactly one reason: approval prompts must show a diff, never
+// prose (D6-05). Determinism is a hard requirement: the output is persisted
+// into `curation_proposals.diff` and compared across runs. No timestamps, no
+// `Object.keys` iteration, no `Set` iteration — arrays only.
+const CONTEXT = 3;
+/**
+ * Split text into logical lines. A trailing newline is not part of the line
+ * model, so a file that merely gains or loses its final newline produces no
+ * spurious final-line hunk.
+ */
+function linesOf(text) {
+    if (text === "")
+        return [];
+    const parts = text.split("\n");
+    if (parts[parts.length - 1] === "")
+        parts.pop();
+    return parts;
+}
+/**
+ * LCS over lines via dynamic programming, then a deterministic walk emitting
+ * context / deletion / addition ops. Within each change region deletions are
+ * emitted before additions, matching git's block ordering exactly.
+ */
+function computeOps(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const w = n + 1;
+    const dp = new Int32Array((m + 1) * w);
+    for (let i = m - 1; i >= 0; i--) {
+        for (let j = n - 1; j >= 0; j--) {
+            dp[i * w + j] =
+                a[i] === b[j]
+                    ? dp[(i + 1) * w + j + 1] + 1
+                    : Math.max(dp[(i + 1) * w + j], dp[i * w + j + 1]);
+        }
+    }
+    const ops = [];
+    const pendingDel = [];
+    const pendingAdd = [];
+    const flush = () => {
+        for (const line of pendingDel)
+            ops.push({ type: "del", line });
+        for (const line of pendingAdd)
+            ops.push({ type: "add", line });
+        pendingDel.length = 0;
+        pendingAdd.length = 0;
+    };
+    let i = 0;
+    let j = 0;
+    while (i < m && j < n) {
+        if (a[i] === b[j]) {
+            flush();
+            ops.push({ type: "ctx", line: a[i] });
+            i++;
+            j++;
+        }
+        else if (dp[(i + 1) * w + j] >= dp[i * w + j + 1]) {
+            pendingDel.push(a[i]);
+            i++;
+        }
+        else {
+            pendingAdd.push(b[j]);
+            j++;
+        }
+    }
+    flush();
+    while (i < m) {
+        pendingDel.push(a[i]);
+        i++;
+    }
+    flush();
+    while (j < n) {
+        pendingAdd.push(b[j]);
+        j++;
+    }
+    flush();
+    return ops;
+}
+function buildHunks(ops) {
+    // Maximal change regions: runs of ops containing at least one del/add.
+    const regions = [];
+    let regionStart = -1;
+    for (let k = 0; k < ops.length; k++) {
+        if (ops[k].type !== "ctx") {
+            if (regionStart === -1)
+                regionStart = k;
+        }
+        else if (regionStart !== -1) {
+            regions.push([regionStart, k]);
+            regionStart = -1;
+        }
+    }
+    if (regionStart !== -1)
+        regions.push([regionStart, ops.length]);
+    // Extend each region by CONTEXT lines and merge overlapping windows.
+    const windows = [];
+    for (const [rs, re] of regions) {
+        const start = Math.max(0, rs - CONTEXT);
+        const end = Math.min(ops.length, re + CONTEXT);
+        const prev = windows[windows.length - 1];
+        if (prev !== undefined && start <= prev.end) {
+            prev.end = end;
+        }
+        else {
+            windows.push({ start, end });
+        }
+    }
+    const hunks = [];
+    for (const win of windows) {
+        let beforeStart = 0;
+        let afterStart = 0;
+        let countA = 0;
+        let countB = 0;
+        for (let k = 0; k < win.end; k++) {
+            const op = ops[k];
+            const inside = k >= win.start;
+            if (op.type === "del") {
+                if (!inside)
+                    beforeStart++;
+                if (inside)
+                    countA++;
+            }
+            else if (op.type === "add") {
+                if (!inside)
+                    afterStart++;
+                if (inside)
+                    countB++;
+            }
+            else {
+                if (!inside) {
+                    beforeStart++;
+                    afterStart++;
+                }
+                if (inside) {
+                    countA++;
+                    countB++;
+                }
+            }
+        }
+        // 1-based start lines; a side with zero lines starts at 0.
+        const startA = countA > 0 ? beforeStart + 1 : 0;
+        const startB = countB > 0 ? afterStart + 1 : 0;
+        const rangeA = countA === 1 ? `-${startA}` : `-${startA},${countA}`;
+        const rangeB = countB === 1 ? `+${startB}` : `+${startB},${countB}`;
+        const lines = [];
+        for (let k = win.start; k < win.end; k++) {
+            const op = ops[k];
+            if (op.type === "del")
+                lines.push(`-${op.line}`);
+            else if (op.type === "add")
+                lines.push(`+${op.line}`);
+            else
+                lines.push(` ${op.line}`);
+        }
+        hunks.push({ header: `@@ ${rangeA} ${rangeB} @@`, lines });
+    }
+    return hunks;
+}
+/**
+ * Unified diff between `before` and `after` for `path`, in git's format:
+ * `--- a/<path>` / `+++ b/<path>` headers, `@@ -l,s +l,s @@` hunk headers
+ * (count omitted when 1, `0,0` for an empty side), three lines of context and
+ * adjacent hunks merged when their context windows overlap. Identical inputs
+ * yield the empty string.
+ */
+export function unifiedDiff(path, before, after) {
+    const ops = computeOps(linesOf(before), linesOf(after));
+    const hunks = buildHunks(ops);
+    if (hunks.length === 0)
+        return "";
+    const parts = [];
+    for (const hunk of hunks) {
+        parts.push(hunk.header);
+        parts.push(...hunk.lines);
+    }
+    const header = `--- a/${path}\n+++ b/${path}\n`;
+    return `${header}${parts.join("\n")}\n`;
+}

package/dist/env.d.ts

@@ -0,0 +1,5 @@
+export interface KevinEnv {
+    projectRoot: string;
+    dataRoot: string;
+}
+export declare function resolveEnv(partial?: Partial<KevinEnv>): KevinEnv;

package/dist/env.js

@@ -0,0 +1,12 @@
+// KevinEnv — injected environment (K13-005, D13-03).
+// Defaults exist for standalone/test use while HOSTS inject explicitly.
+// resolveEnv performs NO filesystem access; it only resolves defaults
+// from process state (cwd/homedir).
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function resolveEnv(partial) {
+    return {
+        projectRoot: partial?.projectRoot ?? process.cwd(),
+        dataRoot: partial?.dataRoot ?? join(homedir(), ".opencode-kevin"),
+    };
+}

package/dist/escape.d.ts

@@ -0,0 +1,39 @@
+/**
+ * v1.0.0 (K10-027 / plan §5.7) — the untrusted-input boundary.
+ *
+ * One pure, total, idempotent escaping function per container Kevin
+ * writes stored text into. Every function here is a fixed point after
+ * one application — applying it twice equals applying it once — because
+ * a re-curated memory passes through the boundary on every regeneration
+ * and must not accumulate escaping.
+ *
+ * This module imports nothing and touches no filesystem. It is the
+ * boundary; the single enforcement point is ArtifactWriter (D6-01).
+ */
+/**
+ * Neutralise text destined for the AGENTS.md marker block: HTML-escape
+ * (the memory-format discipline, made idempotent) so the literal
+ * `<!-- kevin:end -->` marker sequence and every comment terminator
+ * lose their meaning inside the block. The line-level strip of anything
+ * containing `kevin:begin`/`kevin:end` stays in
+ * ArtifactWriter.sanitizeArtifactBody — it is a filter, not an escape.
+ */
+export declare function escapeForMarkerBlock(text: string): string;
+/**
+ * Neutralise fenced-code delimiters: any run of three or more backticks
+ * or tildes would close (or open) a markdown fence around the rendered
+ * block and let stored text masquerade as un-fenced document content.
+ * Each byte of the run becomes its numeric HTML entity, which renders
+ * identically but can never form a delimiter again.
+ */
+export declare function escapeForFence(text: string): string;
+/**
+ * Neutralise bytes that would terminate an OKF v2 line: newline,
+ * carriage return and every other C0 control character become their
+ * JSON-style escapes, so a statement can never split into a second
+ * line even if a future writer forgets JSON.stringify. Quotation marks
+ * and backslashes are deliberately NOT touched here — the OKF line is
+ * canonical JSON and re-escaping them would corrupt parsing; JSON
+ * already guarantees they stay inside the string.
+ */
+export declare function escapeForOkfLine(text: string): string;

package/dist/escape.js

@@ -0,0 +1,60 @@
+/**
+ * v1.0.0 (K10-027 / plan §5.7) — the untrusted-input boundary.
+ *
+ * One pure, total, idempotent escaping function per container Kevin
+ * writes stored text into. Every function here is a fixed point after
+ * one application — applying it twice equals applying it once — because
+ * a re-curated memory passes through the boundary on every regeneration
+ * and must not accumulate escaping.
+ *
+ * This module imports nothing and touches no filesystem. It is the
+ * boundary; the single enforcement point is ArtifactWriter (D6-01).
+ */
+const ENTITY_HEADS = /&(?!(amp|lt|gt|#\d+);)/g;
+/**
+ * Neutralise text destined for the AGENTS.md marker block: HTML-escape
+ * (the memory-format discipline, made idempotent) so the literal
+ * `<!-- kevin:end -->` marker sequence and every comment terminator
+ * lose their meaning inside the block. The line-level strip of anything
+ * containing `kevin:begin`/`kevin:end` stays in
+ * ArtifactWriter.sanitizeArtifactBody — it is a filter, not an escape.
+ */
+export function escapeForMarkerBlock(text) {
+    return text
+        .replace(ENTITY_HEADS, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+/**
+ * Neutralise fenced-code delimiters: any run of three or more backticks
+ * or tildes would close (or open) a markdown fence around the rendered
+ * block and let stored text masquerade as un-fenced document content.
+ * Each byte of the run becomes its numeric HTML entity, which renders
+ * identically but can never form a delimiter again.
+ */
+export function escapeForFence(text) {
+    return text
+        .replace(/`{3,}/g, (run) => "&#96;".repeat(run.length))
+        .replace(/~{3,}/g, (run) => "&#126;".repeat(run.length));
+}
+/**
+ * Neutralise bytes that would terminate an OKF v2 line: newline,
+ * carriage return and every other C0 control character become their
+ * JSON-style escapes, so a statement can never split into a second
+ * line even if a future writer forgets JSON.stringify. Quotation marks
+ * and backslashes are deliberately NOT touched here — the OKF line is
+ * canonical JSON and re-escaping them would corrupt parsing; JSON
+ * already guarantees they stay inside the string.
+ */
+export function escapeForOkfLine(text) {
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: neutralising control bytes is this function's entire job
+    return text.replace(/[\u0000-\u001f]/g, (c) => {
+        if (c === "\n")
+            return "\\n";
+        if (c === "\r")
+            return "\\r";
+        if (c === "\t")
+            return "\\t";
+        return `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`;
+    });
+}

package/dist/fingerprint.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Normalize an error/output string before fingerprinting.
+ *
+ * Steps:
+ *   1. Strip ANSI CSI sequences.
+ *   2. Lowercase (for case-insensitive matching of paths/extensions).
+ *   3. Replace `<path>.<ext>:<line>[:<col>` with `.<ext>` so the same
+ *      error thrown from different files hashes the same.
+ *   4. Collapse all whitespace runs to a single space and trim.
+ */
+export declare function normalize(content: string): string;
+/**
+ * Compute the FNV-1a 64-bit hash of `input`, returned as a 16-char
+ * lowercase hex string (zero-padded to 64 bits).
+ *
+ * FNV-1a: hash = offset_basis; for each byte: hash ^= byte; hash *= prime (mod 2^64).
+ */
+export declare function fnv1a64(input: string): string;
+/**
+ * Fingerprint an error/output string. Optionally salt the hash with
+ * `project_id` so the same error text in two different projects
+ * produces two distinct fingerprints (per decision D2-11/D2-14).
+ *
+ * Salt is prepended and separated by a NUL byte to avoid accidental
+ * collisions where one project's name is a prefix of another's.
+ */
+export declare function fingerprint(content: string, project_id?: string): string;

package/dist/fingerprint.js

@@ -0,0 +1,73 @@
+// ============================================================
+// Kevin 0.2.0 — fingerprint (K2-003)
+// ============================================================
+// Deterministic, zero-dependency content hash used to dedup
+// error memories and to throttle per-fingerprint reflection.
+//
+// We deliberately avoid node:crypto so the module is portable
+// across plugin hosts and stays cheap. FNV-1a 64-bit gives a
+// decent spread for short-to-medium error strings and is
+// reproducible across runs and platforms (BigInt arithmetic).
+// ============================================================
+const FNV_OFFSET_BASIS = 0xcbf29ce484222325n;
+const FNV_PRIME = 0x100000001b3n;
+const FNV_MOD = 1n << 64n;
+// ANSI CSI sequences (color codes, cursor moves, etc.).
+// biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI stripping requires matching the ESC (\x1b) control char by definition.
+const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
+// Path-with-line-and-column references: `src/foo.ts:42:7` -> `.ts`.
+// Matches any non-whitespace path prefix followed by a dotted
+// extension and `:NN` or `:NN:NN` line/column markers. Useful for
+// stripping absolute or per-repo paths before fingerprinting so
+// the same error text in two repos/copy-paste edits hashes alike.
+const PATH_LINE_RE = /[^\s:]*\.([a-z0-9]+):\d+(?::\d+)?/g;
+// Whitespace collapse — preserves token order but ignores
+// line-break and indentation differences.
+const WS_RE = /\s+/g;
+/**
+ * Normalize an error/output string before fingerprinting.
+ *
+ * Steps:
+ *   1. Strip ANSI CSI sequences.
+ *   2. Lowercase (for case-insensitive matching of paths/extensions).
+ *   3. Replace `<path>.<ext>:<line>[:<col>` with `.<ext>` so the same
+ *      error thrown from different files hashes the same.
+ *   4. Collapse all whitespace runs to a single space and trim.
+ */
+export function normalize(content) {
+    return content
+        .replace(ANSI_RE, "")
+        .toLowerCase()
+        .replace(PATH_LINE_RE, ".$1")
+        .replace(WS_RE, " ")
+        .trim();
+}
+/**
+ * Compute the FNV-1a 64-bit hash of `input`, returned as a 16-char
+ * lowercase hex string (zero-padded to 64 bits).
+ *
+ * FNV-1a: hash = offset_basis; for each byte: hash ^= byte; hash *= prime (mod 2^64).
+ */
+export function fnv1a64(input) {
+    let hash = FNV_OFFSET_BASIS;
+    for (let i = 0; i < input.length; i++) {
+        const byte = input.charCodeAt(i) & 0xff;
+        hash ^= BigInt(byte);
+        hash = (hash * FNV_PRIME) % FNV_MOD;
+    }
+    // Encode as 16-char lowercase hex.
+    return hash.toString(16).padStart(16, "0");
+}
+/**
+ * Fingerprint an error/output string. Optionally salt the hash with
+ * `project_id` so the same error text in two different projects
+ * produces two distinct fingerprints (per decision D2-11/D2-14).
+ *
+ * Salt is prepended and separated by a NUL byte to avoid accidental
+ * collisions where one project's name is a prefix of another's.
+ */
+export function fingerprint(content, project_id) {
+    const normalized = normalize(content);
+    const salted = project_id ? `${project_id}\u0000${normalized}` : normalized;
+    return fnv1a64(salted);
+}

package/dist/host.d.ts

@@ -0,0 +1,18 @@
+export type HostFlavour = "v1-only" | "v1+v2";
+export interface HostProject {
+    readonly id: string | null;
+    readonly worktree: string | null;
+    readonly directory: string | null;
+}
+export interface HostSurface {
+    readonly pluginVersion: string | null;
+    readonly flavour: HostFlavour;
+    readonly project: HostProject;
+    readonly hasShell: boolean;
+    readonly v2: {
+        readonly skill: boolean;
+        readonly reference: boolean;
+    };
+    readonly notes: readonly string[];
+}
+export declare function summarize(s: HostSurface): string;

package/dist/host.js

@@ -0,0 +1,7 @@
+export function summarize(s) {
+    const version = s.pluginVersion ?? "unknown";
+    const shell = s.hasShell ? "yes" : "no";
+    const skill = s.v2.skill ? "yes" : "no";
+    const reference = s.v2.reference ? "yes" : "no";
+    return `host plugin ${version}, flavour ${s.flavour}, shell ${shell}, v2 skill ${skill}, v2 reference ${reference}`;
+}

package/dist/idle-pipeline.d.ts

@@ -0,0 +1,9 @@
+export declare const IDLE_STEP_ORDER: readonly ["ledger.settle", "archiver.run", "retrospective", "reflectors.boost", "reflectors.penalize", "patternMiner.mine", "conventionMiner.mine", "conflictDetector.detect", "causalChain.onSessionIdle", "mailbox", "curator.propose", "sharedLayer.import", "snapshots.flush", "sessionRecordedWork", "metrics.flush", "perf.flush", "liveness.flush"];
+export type IdleStepName = (typeof IDLE_STEP_ORDER)[number];
+export type IdlePipelineDeps = Partial<Record<IdleStepName, () => void | Promise<void>>>;
+/**
+ * Run idle steps in canonical ORDER, executing only those present in deps.
+ * Each step is best-effort: a throwing step is swallowed so the chain continues,
+ * matching the adapter's `try { } catch { }` around each sub-step.
+ */
+export declare function composeIdlePipeline(deps: IdlePipelineDeps, order?: readonly IdleStepName[]): Promise<void>;

package/dist/idle-pipeline.js

@@ -0,0 +1,44 @@
+// K13-010 (D13-07) — single definition of session.idle step ORDER.
+// Both adapter (live) and replay (hermetic) consume this pipeline so a re-order
+// is visible in both paths. The audit demanded dedup of the hand-synced wiring.
+//
+// The pipeline is PURE sequencing: it receives injected step closures and runs
+// them in ORDER, swallowing per-step errors (best-effort, same contract as the
+// adapter's try/catch blocks around each idle sub-step).
+export const IDLE_STEP_ORDER = [
+    "ledger.settle",
+    "archiver.run",
+    "retrospective",
+    "reflectors.boost",
+    "reflectors.penalize",
+    "patternMiner.mine",
+    "conventionMiner.mine",
+    "conflictDetector.detect",
+    "causalChain.onSessionIdle",
+    "mailbox",
+    "curator.propose",
+    "sharedLayer.import",
+    "snapshots.flush",
+    "sessionRecordedWork",
+    "metrics.flush",
+    "perf.flush",
+    "liveness.flush",
+];
+/**
+ * Run idle steps in canonical ORDER, executing only those present in deps.
+ * Each step is best-effort: a throwing step is swallowed so the chain continues,
+ * matching the adapter's `try { } catch { }` around each sub-step.
+ */
+export async function composeIdlePipeline(deps, order = IDLE_STEP_ORDER) {
+    for (const name of order) {
+        const fn = deps[name];
+        if (!fn)
+            continue;
+        try {
+            await fn();
+        }
+        catch {
+            // best-effort — identical to adapter's per-step try/catch
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,72 @@
+export * from "./Store.js";
+export * from "./Migrate.js";
+export { MemoryService, DATE_NOW, mapRow, readOriginCallId, countSupersedeCandidates, hasRepoIdColumn } from "./MemoryService.js";
+export type { Memory, SlimMemory, SlimMemoryWithEvidence, SaveInput, QueryInput, GetRelevantInput, MemoryType, MemoryScope, MemoryOrigin, MemoryUpdateResult } from "./MemoryService.js";
+export * from "./ToolCallObserver.js";
+export * from "./Reflector.js";
+export * from "./ContextInjector.js";
+export * from "./QualityGate.js";
+export * from "./InjectionLedger.js";
+export * from "./Curator.js";
+export * from "./ArtifactWriter.js";
+export * from "./SharedLayer.js";
+export * from "./RepoIdentity.js";
+export * from "./RepoTruth.js";
+export * from "./ConflictDetector.js";
+export * from "./CausalChain.js";
+export * from "./PatternMiner.js";
+export * from "./ConventionMiner.js";
+export * from "./Feedback.js";
+export * from "./Archiver.js";
+export * from "./Retrospective.js";
+export * from "./Materializer.js";
+export * from "./HookLiveness.js";
+export * from "./perf.js";
+export * from "./metrics.js";
+export * from "./okf.js";
+export * from "./okf-export.js";
+export * from "./okf-import.js";
+export * from "./LessonFixer.js";
+export * from "./contract.js";
+export * from "./confidence.js";
+export * from "./diff.js";
+export * from "./escape.js";
+export * from "./fingerprint.js";
+export * from "./inferability.js";
+export * from "./query-tokenizer.js";
+export * from "./memory-format.js";
+export * from "./redact.js";
+export * from "./uuid.js";
+export * from "./sqlite-adapter.js";
+export { hasColumn, hasIgnoredColumn, hasCuratedColumn, hasTruthColumns, hasLayerColumn, hasRecurrenceColumn, hasArchivedColumn, hasFeedbackColumns, hasFeedbackTable } from "./columns.js";
+export * from "./time-ms.js";
+export * from "./idle-pipeline.js";
+export * from "./replay.js";
+export * from "./replay-types.js";
+export * from "./ChatBridge.js";
+export * from "./DashboardHtml.js";
+export { deleteMailbox, processActions, readMailbox, writeResults, verifyFresh, consumeMailbox } from "./TuiActions.js";
+export type { MailboxReadResult, PendingProposal, ProcessDeps, ActionStatus } from "./TuiActions.js";
+export * from "./TuiSnapshots.js";
+export type { ProposalView, ConflictView, HealthView, TuiSnapshotSet, TuiAction, ActionResult } from "./tui-types.js";
+export * from "./capabilities.js";
+export * from "./host.js";
+export { V2_SPECIFIER } from "./native.js";
+export type { NativeDeps, NativeRegistration, SettingsReader } from "./native.js";
+export * from "./kevin_approve.js";
+export { buildAudit, type AuditReport, type ChannelReport, type CurationReport, type TruthReport, type EmissionState } from "./kevin_audit.js";
+export * from "./kevin_bench.js";
+export * from "./kevin_conflicts.js";
+export * from "./kevin_contract.js";
+export * from "./kevin_doctor.js";
+export * from "./kevin_facts.js";
+export * from "./kevin_forget.js";
+export { handleNative } from "./kevin_native.js";
+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 "./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 ERROR_LESSON_MODE_VALUES: readonly ["all", "triage_only"];
+export declare const KEVIN_VERSION = "1.3.0";

package/dist/index.js

@@ -0,0 +1,109 @@
+// @jmtrin/kevin-core public entry — Bedrock (K13-002)
+// Explicit re-export list defines future C-10 surface; keep minimal and deliberate.
+export * from "./Store.js";
+export * from "./Migrate.js";
+// MemoryService has duplicate hasRepoIdColumn with columns.ts — export selectively (keep MemoryService's hasRepoIdColumn, columns provides other helpers)
+export { MemoryService, DATE_NOW, mapRow, readOriginCallId, countSupersedeCandidates, hasRepoIdColumn } from "./MemoryService.js";
+export * from "./ToolCallObserver.js";
+export * from "./Reflector.js";
+export * from "./ContextInjector.js";
+export * from "./QualityGate.js";
+export * from "./InjectionLedger.js";
+export * from "./Curator.js";
+export * from "./ArtifactWriter.js";
+export * from "./SharedLayer.js";
+export * from "./RepoIdentity.js";
+export * from "./RepoTruth.js";
+export * from "./ConflictDetector.js";
+export * from "./CausalChain.js";
+export * from "./PatternMiner.js";
+export * from "./ConventionMiner.js";
+export * from "./Feedback.js";
+export * from "./Archiver.js";
+export * from "./Retrospective.js";
+export * from "./Materializer.js";
+export * from "./HookLiveness.js";
+export * from "./perf.js";
+export * from "./metrics.js";
+export * from "./okf.js";
+export * from "./okf-export.js";
+export * from "./okf-import.js";
+export * from "./LessonFixer.js";
+export * from "./contract.js";
+export * from "./confidence.js";
+export * from "./diff.js";
+export * from "./escape.js";
+export * from "./fingerprint.js";
+export * from "./inferability.js";
+export * from "./query-tokenizer.js";
+export * from "./memory-format.js";
+export * from "./redact.js";
+export * from "./uuid.js";
+export * from "./sqlite-adapter.js";
+// columns has duplicate hasRepoIdColumn with MemoryService — export without that function (MemoryService's version is canonical via index)
+export { hasColumn, hasIgnoredColumn, hasCuratedColumn, hasTruthColumns, hasLayerColumn, hasRecurrenceColumn, hasArchivedColumn, hasFeedbackColumns, hasFeedbackTable } from "./columns.js";
+export * from "./time-ms.js";
+export * from "./idle-pipeline.js";
+export * from "./replay.js";
+export * from "./replay-types.js";
+export * from "./ChatBridge.js";
+export * from "./DashboardHtml.js";
+// TuiActions duplicates proposalToken with DashboardHtml — export selectively (exclude proposalToken)
+export { deleteMailbox, processActions, readMailbox, writeResults, verifyFresh, consumeMailbox } from "./TuiActions.js";
+export * from "./TuiSnapshots.js";
+// shims for isolation
+export * from "./capabilities.js";
+export * from "./host.js";
+export { V2_SPECIFIER } from "./native.js";
+// kevin_* handlers — avoid duplicate EmissionState / NativeDeps
+export * from "./kevin_approve.js";
+export { buildAudit } from "./kevin_audit.js";
+export * from "./kevin_bench.js";
+export * from "./kevin_conflicts.js";
+export * from "./kevin_contract.js";
+export * from "./kevin_doctor.js";
+export * from "./kevin_facts.js";
+export * from "./kevin_forget.js";
+export { handleNative } from "./kevin_native.js";
+export * from "./kevin_propose.js";
+export { kevinPublish } from "./kevin_publish.js";
+export * from "./kevin_why.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";
+export const KEVIN_CONFIG_KEYS = [
+    "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 const ERROR_LESSON_MODE_VALUES = ["all", "triage_only"];
+export const KEVIN_VERSION = "1.3.0";