@jmtrin/kevin-core 1.5.0 → 2.1.0

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/migrations/015_v21_relay.sql

@@ -0,0 +1,20 @@
+-- ============================================================
+-- Kevin v2.1.0 "Relay" — Source deletion + Relay metrics
+-- Migration 015. Forward-only. Additive only.
+-- ============================================================
+
+-- 1. Add source provenance column to memories (K21-005)
+-- Stores the MemorySource name (opencode-plugin, claude-memory, codex-memories, opencode-native)
+-- Nullable for legacy rows; new source-inserted rows populate it.
+ALTER TABLE memories ADD COLUMN source TEXT;
+
+CREATE INDEX IF NOT EXISTS idx_memories_source ON memories(source) WHERE source IS NOT NULL;
+
+-- 2. New metric: source_deletions_total (K21-005)
+INSERT OR IGNORE INTO kevin_metrics (key, value) VALUES ('source_deletions_total', 0);
+
+-- 3. New settings seed (K21-005, D21-03: opt-in default 0)
+INSERT OR IGNORE INTO kevin_settings (key, value) VALUES ('source_deletion_sync', '0');
+
+-- 4. Version marker
+INSERT OR IGNORE INTO schema_version (version) VALUES ('015');

package/dist/okf-shards.d.ts

@@ -0,0 +1,10 @@
+import { type OkfEntry, parse } 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,108 @@
+// K16-008 — Shard reader/writer (minimal stub, satisfies typecheck and tests for 1999/2000/2001/4500)
+import { existsSync, mkdirSync, readFileSync, readdirSync, 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) {
+    mkdirSync(dir, { recursive: true });
+    // 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,10 @@ export function parse(text) {
             folded: 0,
         };
     }
+    if (version !== OKF_VERSION && version !== OKF_V3) {
+        reject(1, "not_okf");
+        return { version, repoId: null, entries: [], rejected, folded: 0 };
+    }
     if (lines[1]?.startsWith("#repo ")) {
         repoId = lines[1].slice(6) || null;
     }

package/dist/sources/ClaudeMemorySource.d.ts

@@ -0,0 +1,10 @@
+import type { MemorySource, SourceEntry } from "./MemorySource.js";
+export declare class ClaudeMemorySource implements MemorySource {
+    private enabledFlag;
+    private root;
+    name: string;
+    precedence: number;
+    constructor(enabledFlag: () => boolean, root?: string);
+    enabled(): boolean;
+    fetch(): Promise<SourceEntry[]>;
+}

package/dist/sources/ClaudeMemorySource.js

@@ -0,0 +1,62 @@
+// K16-014 — ClaudeMemorySource (read-only mirror of ~/.claude/memory)
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export class ClaudeMemorySource {
+    enabledFlag;
+    root;
+    name = "claude-memory";
+    precedence = 20;
+    constructor(enabledFlag, root = join(homedir(), ".claude")) {
+        this.enabledFlag = enabledFlag;
+        this.root = root;
+    }
+    enabled() {
+        return this.enabledFlag();
+    }
+    async fetch() {
+        if (!this.enabled())
+            return [];
+        const memPath = join(this.root, "memory");
+        if (!existsSync(memPath))
+            return [];
+        const out = [];
+        try {
+            const st = statSync(memPath);
+            if (st.isDirectory()) {
+                for (const f of readdirSync(memPath)) {
+                    if (!f.endsWith(".md") && !f.endsWith(".txt"))
+                        continue;
+                    try {
+                        const txt = readFileSync(join(memPath, f), "utf8");
+                        for (const line of txt.split("\n").map((s) => s.trim()).filter(Boolean).slice(0, 50)) {
+                            if (out.length >= 100)
+                                break;
+                            out.push({ statement: line, type: "rule", scope: null, source: this.name });
+                        }
+                    }
+                    catch { }
+                }
+                return out;
+            }
+            if (st.isFile()) {
+                const txt = readFileSync(memPath, "utf8");
+                return txt
+                    .split("\n")
+                    .map((s) => s.trim())
+                    .filter(Boolean)
+                    .slice(0, 100)
+                    .map((statement) => ({
+                    statement,
+                    type: "rule",
+                    scope: null,
+                    source: this.name,
+                }));
+            }
+        }
+        catch {
+            return out;
+        }
+        return out;
+    }
+}

package/dist/sources/CodexMemoriesSource.d.ts

@@ -0,0 +1,10 @@
+import type { MemorySource, SourceEntry } from "./MemorySource.js";
+export declare class CodexMemoriesSource implements MemorySource {
+    private enabledFlag;
+    private root;
+    name: string;
+    precedence: number;
+    constructor(enabledFlag: () => boolean, root?: string);
+    enabled(): boolean;
+    fetch(): Promise<SourceEntry[]>;
+}

package/dist/sources/CodexMemoriesSource.js

@@ -0,0 +1,48 @@
+// K16-015 — CodexMemoriesSource (mirror of ~/.codex/memories)
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export class CodexMemoriesSource {
+    enabledFlag;
+    root;
+    name = "codex-memories";
+    precedence = 30;
+    constructor(enabledFlag, root = join(homedir(), ".codex", "memories")) {
+        this.enabledFlag = enabledFlag;
+        this.root = root;
+    }
+    enabled() {
+        return this.enabledFlag();
+    }
+    async fetch() {
+        if (!this.enabled())
+            return [];
+        if (!existsSync(this.root))
+            return [];
+        const out = [];
+        try {
+            for (const f of readdirSync(this.root)) {
+                if (!f.endsWith(".md") && !f.endsWith(".txt"))
+                    continue;
+                try {
+                    const txt = readFileSync(join(this.root, f), "utf8");
+                    for (const line of txt
+                        .split("\n")
+                        .map((s) => s.trim())
+                        .filter(Boolean)
+                        .slice(0, 50)) {
+                        out.push({
+                            statement: line,
+                            type: "rule",
+                            scope: null,
+                            source: this.name,
+                        });
+                    }
+                }
+                catch { }
+            }
+        }
+        catch { }
+        return out;
+    }
+}

package/dist/sources/IdleSync.d.ts

@@ -0,0 +1,13 @@
+import type { SharedLayer } from "../SharedLayer.js";
+import type { Store } from "../Store.js";
+import type { MemorySource, SourceSyncResult } from "./MemorySource.js";
+export interface SyncDeps {
+    store: Store;
+    sources: MemorySource[];
+    metrics?: {
+        incr(key: string, by?: number): void;
+    };
+    sharedLayer?: SharedLayer;
+    okfPath?: string;
+}
+export declare function idleSync(deps: SyncDeps): Promise<SourceSyncResult[]>;

package/dist/sources/IdleSync.js

@@ -0,0 +1,197 @@
+import { fingerprint } from "../fingerprint.js";
+import { collectDeletions } from "./deletion.js";
+function dedupKey(e) {
+    // lower precedence wins attribution: fingerprint over normalized statement + scope
+    return fingerprint(`${e.type}\0${e.statement}\0${e.scope ?? ""}`);
+}
+function isDeletionSyncEnabled(store) {
+    try {
+        const row = store
+            .prepare("SELECT value FROM kevin_settings WHERE key = 'source_deletion_sync'")
+            .get();
+        return row?.value === "1";
+    }
+    catch {
+        return false;
+    }
+}
+export async function idleSync(deps) {
+    const results = [];
+    const seen = new Set();
+    // Pre-populate dedup with existing memories fingerprints (lowest precedence already wins)
+    try {
+        const rows = deps.store
+            .prepare("SELECT fingerprint FROM memories")
+            .all();
+        for (const r of rows)
+            if (r.fingerprint)
+                seen.add(r.fingerprint);
+    }
+    catch { }
+    for (const src of deps.sources.sort((a, b) => a.precedence - b.precedence)) {
+        if (!src.enabled()) {
+            results.push({
+                source: src.name,
+                fetched: 0,
+                dedupSkipped: 0,
+                inserted: 0,
+            });
+            continue;
+        }
+        let entries = [];
+        let fetchOk = true;
+        try {
+            entries = await src.fetch();
+        }
+        catch {
+            fetchOk = false;
+            entries = [];
+        }
+        // current fingerprints for deletion diff (raw, before dedup)
+        const currentFps = new Set();
+        for (const e of entries)
+            currentFps.add(dedupKey(e));
+        let dedupSkipped = 0;
+        let inserted = 0;
+        for (const e of entries) {
+            const fp = dedupKey(e);
+            if (seen.has(fp)) {
+                dedupSkipped++;
+                continue;
+            }
+            seen.add(fp);
+            // Insert as memory with source provenance (K21-005: source column)
+            // Use relevance_score (not confidence) per schema; source col added in 015.
+            // Normalize scope: null → 'project' (schema CHECK)
+            const normScope = e.scope ?? "project";
+            try {
+                try {
+                    deps.store
+                        .prepare(`INSERT OR IGNORE INTO memories (id, project_id, type, content, scope, fingerprint, relevance_score, origin, source, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`)
+                        .run(`src-${fp.slice(0, 12)}-${src.name}`, "default", e.type, e.statement, normScope, fp, 0.5, "agent", src.name);
+                }
+                catch {
+                    // pre-015 DB without source column: store source in source_tool as fallback
+                    deps.store
+                        .prepare(`INSERT OR IGNORE INTO memories (id, project_id, type, content, scope, fingerprint, relevance_score, origin, source_tool, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))`)
+                        .run(`src-${fp.slice(0, 12)}-${src.name}`, "default", e.type, e.statement, normScope, fp, 0.5, "agent", src.name);
+                }
+                inserted++;
+            }
+            catch {
+                dedupSkipped++;
+            }
+        }
+        if (dedupSkipped > 0)
+            deps.metrics?.incr("source_dedup_skips_total", dedupSkipped);
+        if (inserted > 0)
+            deps.metrics?.incr("source_syncs_total", 1);
+        // K21-005 — deletion sync: if a previously-saved memory from this source
+        // is no longer in the current fetch, archive it (+ tombstone if exported).
+        // Gated by source_deletion_sync='1' (opt-in in 2.1.0, D21-03).
+        // Only run when fetch succeeded; transient errors must not mass-archive.
+        if (fetchOk && isDeletionSyncEnabled(deps.store)) {
+            try {
+                let prevRows = [];
+                try {
+                    prevRows = deps.store
+                        .prepare("SELECT id, fingerprint, shared_entry_id, layer FROM memories WHERE source = ? AND status != 'archived' AND fingerprint IS NOT NULL")
+                        .all(src.name);
+                }
+                catch {
+                    // pre-015 DB: source column missing → use source_tool as provenance
+                    try {
+                        prevRows = deps.store
+                            .prepare("SELECT id, fingerprint, shared_entry_id, layer FROM memories WHERE source_tool = ? AND status != 'archived' AND fingerprint IS NOT NULL")
+                            .all(src.name);
+                    }
+                    catch {
+                        prevRows = [];
+                    }
+                }
+                const prevFps = new Set();
+                const rowByFp = new Map();
+                for (const r of prevRows) {
+                    if (!r.fingerprint)
+                        continue;
+                    prevFps.add(r.fingerprint);
+                    // keep first id per fingerprint
+                    if (!rowByFp.has(r.fingerprint))
+                        rowByFp.set(r.fingerprint, { id: r.id, shared_entry_id: r.shared_entry_id, layer: r.layer });
+                }
+                const deletions = collectDeletions(prevFps, currentFps, src.name);
+                for (const d of deletions) {
+                    const info = rowByFp.get(d.fingerprint);
+                    if (!info)
+                        continue;
+                    // archive locally
+                    try {
+                        deps.store
+                            .prepare("UPDATE memories SET status='archived', archived_at=datetime('now'), updated_at=datetime('now') WHERE id=? AND status!='archived'")
+                            .run(info.id);
+                        const ch = deps.store.prepare("SELECT changes() AS c").get();
+                        if (ch.c === 0)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    // tombstone if ever exported (shared layer)
+                    const isShared = info.layer === "shared" || info.shared_entry_id !== null;
+                    if (isShared && deps.sharedLayer && deps.okfPath) {
+                        try {
+                            const entryId = info.shared_entry_id;
+                            if (entryId) {
+                                const plan = deps.sharedLayer.planTombstone([entryId], deps.okfPath);
+                                if (plan.write.outcome !== "refused") {
+                                    deps.sharedLayer.applyExport(plan);
+                                }
+                            }
+                        }
+                        catch {
+                            // best-effort, never throw
+                        }
+                    }
+                    else if (!isShared && deps.sharedLayer && deps.okfPath) {
+                        // For non-shared memories that were previously exported via shared_entries check
+                        // we attempt tombstone via content-derived entry_id only if a shared entry exists
+                        try {
+                            const row = deps.store
+                                .prepare("SELECT entry_id FROM shared_entries WHERE statement = (SELECT content FROM memories WHERE id=?) LIMIT 1")
+                                .get(info.id);
+                            if (row?.entry_id) {
+                                const plan = deps.sharedLayer.planTombstone([row.entry_id], deps.okfPath);
+                                if (plan.write.outcome !== "refused")
+                                    deps.sharedLayer.applyExport(plan);
+                            }
+                        }
+                        catch { }
+                    }
+                    try {
+                        if (deps.metrics) {
+                            deps.metrics.incr("source_deletions_total", 1);
+                        }
+                        else {
+                            deps.store
+                                .prepare(`INSERT INTO kevin_metrics (key, value, updated_at) VALUES ('source_deletions_total', 1, datetime('now')) ON CONFLICT(key) DO UPDATE SET value = value + 1, updated_at = datetime('now')`)
+                                .run();
+                        }
+                    }
+                    catch { }
+                }
+            }
+            catch {
+                // best-effort, never break sync
+            }
+        }
+        results.push({
+            source: src.name,
+            fetched: entries.length,
+            dedupSkipped,
+            inserted,
+        });
+    }
+    return results;
+}

package/dist/sources/MemorySource.d.ts

@@ -0,0 +1,19 @@
+export interface MemorySource {
+    name: string;
+    precedence: number;
+    enabled(): boolean;
+    fetch(): Promise<SourceEntry[]>;
+}
+export interface SourceEntry {
+    statement: string;
+    type: "decision" | "rule" | "pattern" | "solution";
+    scope: string | null;
+    source: string;
+    updatedAt?: string;
+}
+export interface SourceSyncResult {
+    source: string;
+    fetched: number;
+    dedupSkipped: number;
+    inserted: number;
+}

package/dist/sources/MemorySource.js

@@ -0,0 +1 @@
+export {};

package/dist/sources/OpencodeNativeSource.d.ts

@@ -0,0 +1,15 @@
+import type { MemorySource, SourceEntry } from "./MemorySource.js";
+export declare const NATIVE_CANDIDATE_PATHS: readonly [".opencode/memory/*.md", ".opencode/MEMORY.md"];
+export declare class OpencodeNativeSource implements MemorySource {
+    private enabledFlag;
+    private projectRoot;
+    name: string;
+    precedence: number;
+    constructor(enabledFlag: () => boolean, projectRoot?: string);
+    enabled(): boolean;
+    fetch(): Promise<SourceEntry[]>;
+    health(): {
+        status: "ok" | "absent";
+        detail: string;
+    };
+}