@jmtrin/opencode-kevin 1.2.0 → 1.4.0

package/dist/plugin/okf-import.js

@@ -1,271 +0,0 @@
-import { fingerprint as computeFingerprint } from "./fingerprint.js";
-import { uuidv7 } from "./uuid.js";
-const PAIR_RE = /^([a-z_]+):\s*(.*)$/i;
-const ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-/**
- * v0.3.0 fix — Clean state-machine parser for the frontmatter bundle
- * format produced by `okf-export.ts::exportOkf`. Each entry is:
- *
- *   ---
- *   id: <uuid>
- *   type: <decision|rule|pattern>
- *   confidence: 0.70
- *   evidence_count: 2
- *   last_verified_at: 2026-07-25 12:34:56
- *   fingerprint: <hex>
- *   created: 2026-07-25 12:00:00
- *   scope: project
- *   ---
- *
- *   <content body, may span multiple lines, may include `---` lines
- *    within — the body terminator is the NEXT top-level `---` followed
- *    by an `id:` line, or EOF>
- *
- * The previous implementation only ever flagged `inFm = true` once and
- * never reset `contentStarted` between entries, so 2..N entries were
- * silently dropped (bug #1). This rewrite handles arbitrary numbers of
- * consecutive frontmatter sections.
- */
-export function parseMarkdownBundle(text) {
-    const lines = text.replace(/\r\n/g, "\n").split("\n");
-    const entries = [];
-    let i = 0;
-    let fm = null;
-    let body = [];
-    // True when we have just seen a `---` opener and are collecting
-    // `key: value` pairs until the matching `---` closer.
-    const isFmKey = (s) => PAIR_RE.test(s) || s.trim() === "";
-    while (i < lines.length) {
-        const line = lines[i];
-        // Seek an opening `---`.
-        if (line.trim() !== "---") {
-            i++;
-            continue;
-        }
-        // Trivially empty bundle (just opener/closer with no keys) — skip.
-        if (lines[i + 1]?.trim() === "---") {
-            i += 2;
-            continue;
-        }
-        // Begin frontmatter collection.
-        fm = {};
-        body = [];
-        i++;
-        let closed = false;
-        while (i < lines.length) {
-            const cur = lines[i];
-            if (cur.trim() === "---") {
-                closed = true;
-                i++;
-                break;
-            }
-            const m = cur.match(PAIR_RE);
-            if (m) {
-                fm[m[1].toLowerCase()] = m[2].trim();
-            }
-            i++;
-        }
-        if (!closed)
-            break;
-        if (!fm.id)
-            continue;
-        // Collect body until the next top-level `---` opener. The opener
-        // is recognizable as `---` followed by an `id:` pair in the next
-        // frontmatter block; we look ahead conservatively: a `---` line
-        // immediately followed by a `key:` line is an opener, anything
-        // else is body content.
-        while (i < lines.length) {
-            const cur = lines[i];
-            if (cur.trim() === "---") {
-                // peek the NEXT non-empty line — if it looks like a PAIR,
-                // this `---` is an opener for the next entry, so stop body
-                // here without consuming.
-                let j = i + 1;
-                while (j < lines.length && lines[j].trim() === "")
-                    j++;
-                if (j < lines.length && isFmKey(lines[j]) && PAIR_RE.test(lines[j])) {
-                    break;
-                }
-                // Otherwise treat as body content (e.g. thematic break).
-                body.push(cur);
-                i++;
-                continue;
-            }
-            body.push(cur);
-            i++;
-        }
-        const content = body.join("\n").trim();
-        if (!content)
-            continue;
-        const type = (fm.type ?? "context").toLowerCase();
-        const id = ID_RE.test(fm.id) ? fm.id : uuidv7();
-        const fp = fm.fingerprint ?? null;
-        const evidenceCount = Number.parseInt(fm.evidence_count ?? "0", 10) || 0;
-        const recurrenceCount = Number.parseInt(fm.recurrence_count ?? "0", 10) || 0;
-        const lastVerified = fm.last_verified_at ?? null;
-        entries.push({
-            id,
-            type,
-            content,
-            fingerprint: fp,
-            evidence_count: evidenceCount,
-            recurrence_count: recurrenceCount,
-            last_verified_at: lastVerified,
-        });
-    }
-    return entries;
-}
-/**
- * v0.3.0 fix — Fallback parser for the markdown-style `##` heading
- * format produced by `okf-export.ts::exportMarkdown`. The previous
- * version extracted `fingerprint: null` for every entry (regex was
- * pinned to 16 hex chars while actual fingerprints are variable
- * length) and contaminated `content` with the heading line and
- * metadata bullets. This version cleanly separates metadata bullets
- * (looking for `**ID:**`, `**Fingerprint:**`, `**Evidence count:**`,
- * `**Last verified:**`, `**Scope:**` prefixes) from the content
- * body, which starts after the first blank line following the bullet
- * block and runs until the trailing `---` separator (or EOF).
- */
-export function parseMarkdownHeadings(text) {
-    const normalized = text.replace(/\r\n/g, "\n");
-    // Split on `## ` headings; first chunk is the document preamble.
-    const chunks = normalized.split(/^##\s+/m).slice(1);
-    const entries = [];
-    for (const chunk of chunks) {
-        const lines = chunk.split("\n");
-        const typeMatch = lines[0]?.match(/^([A-Za-z]+):\s*/);
-        const type = typeMatch ? typeMatch[1].toLowerCase() : "context";
-        const fm = {};
-        let bodyStart = -1;
-        // True once at least one `- **Key:**` bullet was consumed; the
-        // body starts at the FIRST blank line AFTER the bullet block.
-        // Blank lines before any bullet (e.g. right after the `##` heading)
-        // must be skipped, not treated as body delimiters.
-        let sawBullet = false;
-        for (let k = 1; k < lines.length; k++) {
-            const ln = lines[k];
-            const bulletId = ln.match(/^- \*\*ID:\*\*\s*`([^`]+)`/);
-            const bulletFp = ln.match(/^- \*\*Fingerprint:\*\*\s*`([a-f0-9]+)`/i);
-            const bulletEv = ln.match(/^- \*\*Evidence count:\*\*\s*(\d+)/);
-            const bulletRec = ln.match(/^- \*\*Recurrence count:\*\*\s*(\d+)/);
-            const bulletLv = ln.match(/^- \*\*Last verified:\*\*\s*(.+)$/);
-            if (bulletId) {
-                fm.id = bulletId[1];
-                sawBullet = true;
-            }
-            else if (bulletFp) {
-                fm.fingerprint = bulletFp[1];
-                sawBullet = true;
-            }
-            else if (bulletEv) {
-                fm.evidence_count = bulletEv[1];
-                sawBullet = true;
-            }
-            else if (bulletRec) {
-                fm.recurrence_count = bulletRec[1];
-                sawBullet = true;
-            }
-            else if (bulletLv) {
-                fm.last_verified_at = bulletLv[1].trim();
-                sawBullet = true;
-            }
-            else if (ln.trim() === "") {
-                // First blank line after bullet block — body starts here.
-                if (sawBullet) {
-                    bodyStart = k + 1;
-                    break;
-                }
-                // Leading blank line (right after the heading) — skip.
-            }
-            else {
-                // Other bullets (e.g. `- **Confidence:**`, `- **Scope:**`)
-                // are not captured — skip them; the bullet block ends at
-                // the next blank line.
-            }
-        }
-        if (bodyStart < 0)
-            bodyStart = 1;
-        const bodyLines = [];
-        for (let k = bodyStart; k < lines.length; k++) {
-            const ln = lines[k];
-            if (ln.trim() === "---")
-                break;
-            bodyLines.push(ln);
-        }
-        const content = bodyLines.join("\n").trim();
-        if (!content)
-            continue;
-        const id = fm.id && ID_RE.test(fm.id) ? fm.id : uuidv7();
-        entries.push({
-            id,
-            type,
-            content,
-            fingerprint: fm.fingerprint ?? null,
-            evidence_count: Number.parseInt(fm.evidence_count ?? "0", 10) || 0,
-            recurrence_count: Number.parseInt(fm.recurrence_count ?? "0", 10) || 0,
-            last_verified_at: fm.last_verified_at ?? null,
-        });
-    }
-    return entries;
-}
-const IMPORT_ALLOWED_TYPES = new Set([
-    "decision",
-    "rule",
-    "pattern",
-    "context",
-]);
-/**
- * v0.3.0 fix — Ingest a bundle (frontmatter OR markdown) into the
- * local SQLite store as `context` memories with `origin='imported'`.
- *
- * Fixes over the v0.3.0 baseline:
- *   * Multi-entry bundles now produce N imports instead of N=1 — the
- *     parser bug is closed.
- *   * `ParsedEntry.evidence_count` and `last_verified_at` are
- *     threaded through so causal confidence survives a round-trip.
- *   * `ImportResult.superseded` is populated using
- *     `countSupersedeCandidates`, which mirrors the supersede logic
- *     in `MemoryService.save()`. Previously it was hard-coded to 0.
- *   * Generated ids use `uuidv7()` (the project's id generator)
- *     instead of `crypto.randomUUID()` for consistency.
- */
-export function importOkf(bundle, memoryService) {
-    let entries = parseMarkdownBundle(bundle);
-    if (entries.length === 0) {
-        entries = parseMarkdownHeadings(bundle);
-    }
-    let imported = 0;
-    let superseded = 0;
-    for (const entry of entries) {
-        if (!IMPORT_ALLOWED_TYPES.has(entry.type))
-            continue;
-        const fp = entry.fingerprint ?? computeFingerprint(entry.content, undefined);
-        // Count rows that save() will mark as superseded (decision/rule
-        // with the same fingerprint). The supersede update itself runs
-        // inside MemoryService.save() in a single transaction; we count
-        // here to surface the value to the caller.
-        superseded += memoryService.countSupersedeCandidates(entry.type, fp, null);
-        memoryService.save({
-            type: entry.type,
-            // BUG-008 — preserve the bundle id so a round-trip (export →
-            // import) keeps memory identity and `getById` stays stable.
-            id: entry.id,
-            // BUG-009 — the content is the bundle body verbatim. The old
-            // code appended `[imported evidence_count=N, ...]`, which the
-            // ContextInjector later injected verbatim into model prompts;
-            // the values travel via the typed fields below instead.
-            content: entry.content,
-            scope: "project",
-            origin: "imported",
-            fingerprint: fp,
-            evidenceCount: entry.evidence_count > 0 ? entry.evidence_count : undefined,
-            // BUG-008 — restore the recurrence demotion so the re-imported
-            // copy keeps the v0.4.0 two-sided confidence of the source.
-            recurrenceCount: entry.recurrence_count > 0 ? entry.recurrence_count : undefined,
-            lastVerifiedAt: entry.last_verified_at ?? undefined,
-        });
-        imported++;
-    }
-    return { imported, superseded };
-}

package/dist/plugin/okf.d.ts

@@ -1,107 +0,0 @@
-/** OKF v2 format version marker, written on the first header line. */
-export declare const OKF_VERSION = 2;
-/** 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. */
-export declare const MAX_ENTRIES = 2000;
-export type OkfOp = "assert" | "tombstone";
-/**
- * A v2 entry. The field set is plan §5.3/§5.4: the two integer
- * counters (`evidence`, `recurrence`) are transported and
- * `confidence` is DERIVED at read time — the file contains no
- * floats at all, so two machines computing a confidence slightly
- * differently still emit byte-identical lines.
- */
-export interface OkfEntry {
-    entry_id: string;
-    type: "decision" | "rule" | "pattern" | "solution";
-    statement: string;
-    scope: string | null;
-    evidence: number;
-    recurrence: number;
-    origin: string;
-    author_hash: string | null;
-    op: OkfOp;
-    created_at: string;
-    supersedes: string | null;
-}
-/**
- * Canonical JSON of an entry: keys in alphabetical order, no space
- * argument, integers only (no float is ever written — plan §5.3).
- * The object is constructed explicitly so the source object's
- * insertion order can never leak into the bytes.
- */
-export declare function canonicalize(e: OkfEntry): string;
-/**
- * Emit the v2 file: three `#` header lines, then every entry sorted
- * ascending by `entry_id`, one per line, LF endings, exactly one
- * terminating newline. Entries over MAX_LINE_BYTES (measured in
- * BYTES — a Japanese statement passes a `.length` check and fails a
- * 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;
-/**
- * Group both corpora by `entry_id`, fold each group through `join()`,
- * and return the result sorted ascending by `entry_id`. Order of the
- * inputs does not matter: join() is commutative, and the fold order is
- * the only place input order could leak in — it cannot, by algebra.
- */
-export declare function merge(a: OkfEntry[], b: OkfEntry[]): OkfEntry[];
-/**
- * Derived, never serialized — reuses the v0.4.0 two-sided confidence
- * formula verbatim (plan §5.4). A lesson that keeps recurring is
- * DEMOTED rather than merely un-promoted; shared and local memories
- * are repriced identically by the same formula.
- */
-export declare function deriveConfidence(e: OkfEntry): number;
-export interface RejectedLine {
-    line: number;
-    reason: string;
-}
-export interface ParseResult {
-    version: number;
-    repoId: string | null;
-    /** Folded via join() and sorted ascending by entry_id. */
-    entries: OkfEntry[];
-    /** parse never throws; bad lines are reported. */
-    rejected: RejectedLine[];
-    /** Duplicate entry_ids collapsed by join(). */
-    folded: number;
-}
-/**
- * v0.8.0 (K8-013 / plan §5.4, D8-13) — the field lattice. Every field
- * resolves through a max, a min, or an absorbing boolean OR over a
- * totally ordered set; there is no "prefer the newer" anywhere.
- * Precondition: `a.entry_id === b.entry_id`.
- */
-export declare function join(a: OkfEntry, b: OkfEntry): OkfEntry;
-/**
- * parse() is a TOTAL function — it never throws, on any input,
- * including binary (D8-14). The file is expected to arrive damaged:
- * a conflict resolution leaves `<<<<<<< HEAD` markers, an editor
- * truncates the last line, a merge tool mangles an encoding. Every
- * unusable line becomes a `RejectedLine`; the good entries survive.
- *
- * Reason taxonomy (closed): not_okf, version_ahead, bad_json,
- * missing_field, wrong_type, id_mismatch, unknown_op, line_too_long,
- * corpus_too_large.
- */
-export declare function parse(text: string): ParseResult;
-/**
- * Compute the identity of an OKF entry: `fnv1a64("okf:v2\0" + type +
- * "\0" + statement + "\0" + (scope ?? ""))`.
- *
- * D8-05 — deliberately NOT `fingerprint()`:
- *  - it salts with `project_id`, so every clone would produce a
- *    different id for the same rule, the shared file would accumulate
- *    one entry per developer per rule, and the merge fold would never
- *    once fire;
- *  - it runs `normalize()`, which lowercases and rewrites
- *    `path.ext:line:col` — both destructive for a curated statement,
- *    where casing and file paths carry meaning.
- *
- * NUL separators keep (`rule`, "ab", "c") distinct from
- * ("rule", "a", "bc") — plain concatenation could never.
- */
-export declare function computeEntryId(type: string, statement: string, scope?: string | null): string;

package/dist/plugin/okf.js

@@ -1,303 +0,0 @@
-// ============================================================
-// Kevin 0.8.0 — OKF v2 codec (F2, K8-010 … K8-015)
-// ============================================================
-// The Open Kevin Format: the committed, shareable artifact of the
-// shared layer (plan §3.3). Everything in this module is a pure
-// function — no database, no filesystem, no clock. The format is
-// the release: if `join()` is not a semilattice then silent git
-// merges, order-independent imports and correct both-sides
-// conflict resolution all evaporate.
-//
-// Entry ids are deliberately the THIRD fingerprint identity
-// dimension in the codebase (v0.7.0's Principle 26; plan §3.3's
-// table). The first is `fingerprint()` (error text, salted with
-// `project_id`, normalized) and the second is the convention /
-// decision fingerprints of v0.7.0 (derived from the normalized
-// statement). This one is unsalted and un-normalized, and it is
-// the ONLY cross-machine-stable dimension in the schema.
-// ============================================================
-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;
-/** 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. */
-export const MAX_ENTRIES = 2000;
-const OKF_KEY_ORDER = [
-    "author_hash",
-    "created_at",
-    "entry_id",
-    "evidence",
-    "op",
-    "origin",
-    "recurrence",
-    "scope",
-    "statement",
-    "supersedes",
-    "type",
-];
-/**
- * Canonical JSON of an entry: keys in alphabetical order, no space
- * argument, integers only (no float is ever written — plan §5.3).
- * The object is constructed explicitly so the source object's
- * insertion order can never leak into the bytes.
- */
-export function canonicalize(e) {
-    const ordered = {};
-    for (const key of OKF_KEY_ORDER) {
-        ordered[key] = e[key];
-    }
-    return JSON.stringify(ordered);
-}
-/**
- * Emit the v2 file: three `#` header lines, then every entry sorted
- * ascending by `entry_id`, one per line, LF endings, exactly one
- * terminating newline. Entries over MAX_LINE_BYTES (measured in
- * BYTES — a Japanese statement passes a `.length` check and fails a
- * byte check) and corpora over MAX_ENTRIES are refused, not
- * truncated (plan §5.3, physical rules).
- */
-export function serialize(entries, repoId, 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}`,
-        `#repo ${repoId}`,
-        `#generated-by opencode-kevin/${version}`,
-    ];
-    for (const e of sorted) {
-        const line = canonicalize(e);
-        if (Buffer.byteLength(line, "utf8") > MAX_LINE_BYTES) {
-            throw new Error(`okf: entry ${e.entry_id} canonicalizes to ${Buffer.byteLength(line, "utf8")} bytes, over MAX_LINE_BYTES (${MAX_LINE_BYTES})`);
-        }
-        lines.push(line);
-    }
-    return `${lines.join("\n")}\n`;
-}
-/**
- * Group both corpora by `entry_id`, fold each group through `join()`,
- * and return the result sorted ascending by `entry_id`. Order of the
- * inputs does not matter: join() is commutative, and the fold order is
- * the only place input order could leak in — it cannot, by algebra.
- */
-export function merge(a, b) {
-    const byId = new Map();
-    for (const e of [...a, ...b]) {
-        const existing = byId.get(e.entry_id);
-        byId.set(e.entry_id, existing ? join(existing, e) : e);
-    }
-    return [...byId.values()].sort((x, y) => x.entry_id < y.entry_id ? -1 : x.entry_id > y.entry_id ? 1 : 0);
-}
-/**
- * Derived, never serialized — reuses the v0.4.0 two-sided confidence
- * formula verbatim (plan §5.4). A lesson that keeps recurring is
- * DEMOTED rather than merely un-promoted; shared and local memories
- * are repriced identically by the same formula.
- */
-export function deriveConfidence(e) {
-    return computeConfidence(e.evidence, e.recurrence);
-}
-const OKF_TYPES = new Set(["decision", "rule", "pattern", "solution"]);
-function pickMin(a, b) {
-    if (a === null)
-        return b;
-    if (b === null)
-        return a;
-    return a <= b ? a : b;
-}
-/**
- * v0.8.0 (K8-013 / plan §5.4, D8-13) — the field lattice. Every field
- * resolves through a max, a min, or an absorbing boolean OR over a
- * totally ordered set; there is no "prefer the newer" anywhere.
- * Precondition: `a.entry_id === b.entry_id`.
- */
-export function join(a, b) {
-    return {
-        entry_id: a.entry_id,
-        // Equal by construction unless a hash collision — resolve by
-        // lexicographic min so the function stays total and deterministic.
-        type: a.type <= b.type ? a.type : b.type,
-        statement: a.statement <= b.statement ? a.statement : b.statement,
-        scope: pickMin(a.scope, b.scope),
-        evidence: Math.max(a.evidence, b.evidence),
-        recurrence: Math.max(a.recurrence, b.recurrence),
-        origin: a.origin <= b.origin ? a.origin : b.origin,
-        author_hash: pickMin(a.author_hash, b.author_hash),
-        // Tombstone absorbs: no undelete, no timestamp tiebreak (D8-09).
-        op: a.op === "tombstone" || b.op === "tombstone" ? "tombstone" : "assert",
-        // Birthday semantics: min is the only choice stable under replay.
-        created_at: a.created_at <= b.created_at ? a.created_at : b.created_at,
-        supersedes: pickMin(a.supersedes, b.supersedes),
-    };
-}
-/**
- * parse() is a TOTAL function — it never throws, on any input,
- * including binary (D8-14). The file is expected to arrive damaged:
- * a conflict resolution leaves `<<<<<<< HEAD` markers, an editor
- * truncates the last line, a merge tool mangles an encoding. Every
- * unusable line becomes a `RejectedLine`; the good entries survive.
- *
- * Reason taxonomy (closed): not_okf, version_ahead, bad_json,
- * missing_field, wrong_type, id_mismatch, unknown_op, line_too_long,
- * corpus_too_large.
- */
-export function parse(text) {
-    const rejected = [];
-    const reject = (line, reason) => {
-        rejected.push({ line, reason });
-    };
-    // A UTF-8 BOM breaks the `#okf ` prefix check; strip it first.
-    const body = text.replace(/^\uFEFF/, "");
-    const lines = body.split(/\r\n|\r|\n/);
-    let version = 0;
-    let repoId = null;
-    if (!(lines[0]?.startsWith("#okf ") ?? false)) {
-        reject(1, "not_okf");
-        return { version, repoId, entries: [], rejected, folded: 0 };
-    }
-    const declared = Number(lines[0].slice(5));
-    version = Number.isInteger(declared) && declared >= 0 ? declared : 0;
-    if (version > OKF_VERSION) {
-        // Guessing at a future format's semantics is how corpora get
-        // corrupted — refuse the whole file, never a best-effort parse.
-        return {
-            version,
-            repoId: null,
-            entries: [],
-            rejected: [{ line: 1, reason: "version_ahead" }],
-            folded: 0,
-        };
-    }
-    if (lines[1]?.startsWith("#repo ")) {
-        repoId = lines[1].slice(6) || null;
-    }
-    const byId = new Map();
-    let folded = 0;
-    let accepted = 0;
-    for (let i = 2; i < lines.length; i++) {
-        const line = lines[i];
-        if (line === "")
-            continue; // trailing newline / blank lines
-        if (line.startsWith("#"))
-            continue; // header/comment lines
-        const lineNo = i + 1;
-        if (Buffer.byteLength(line, "utf8") > MAX_LINE_BYTES) {
-            reject(lineNo, "line_too_long");
-            continue;
-        }
-        let raw;
-        try {
-            raw = JSON.parse(line);
-        }
-        catch {
-            reject(lineNo, "bad_json");
-            continue;
-        }
-        if (typeof raw !== "object" || raw === null) {
-            reject(lineNo, "bad_json");
-            continue;
-        }
-        const o = raw;
-        const missing = (k) => o[k] === undefined;
-        const wrong = (k, ok) => !missing(k) && !ok(o[k]);
-        const stringField = (k) => !wrong(k, (v) => typeof v === "string");
-        const nullableString = (k) => !wrong(k, (v) => v === null || typeof v === "string");
-        const intField = (k) => !wrong(k, (v) => typeof v === "number" && Number.isInteger(v) && v >= 0);
-        if (missing("entry_id"))
-            reject(lineNo, "missing_field");
-        else if (!stringField("entry_id"))
-            reject(lineNo, "wrong_type");
-        else if (missing("type"))
-            reject(lineNo, "missing_field");
-        else if (typeof o.type !== "string" || !OKF_TYPES.has(o.type))
-            reject(lineNo, "wrong_type");
-        else if (missing("statement"))
-            reject(lineNo, "missing_field");
-        else if (!stringField("statement"))
-            reject(lineNo, "wrong_type");
-        else if (!nullableString("scope"))
-            reject(lineNo, "wrong_type");
-        else if (missing("evidence"))
-            reject(lineNo, "missing_field");
-        else if (!intField("evidence"))
-            reject(lineNo, "wrong_type");
-        else if (missing("recurrence"))
-            reject(lineNo, "missing_field");
-        else if (!intField("recurrence"))
-            reject(lineNo, "wrong_type");
-        else if (missing("origin"))
-            reject(lineNo, "missing_field");
-        else if (!stringField("origin"))
-            reject(lineNo, "wrong_type");
-        else if (!nullableString("author_hash"))
-            reject(lineNo, "wrong_type");
-        else if (missing("op"))
-            reject(lineNo, "missing_field");
-        else if (o.op !== "assert" && o.op !== "tombstone")
-            reject(lineNo, "unknown_op");
-        else if (missing("created_at"))
-            reject(lineNo, "missing_field");
-        else if (!stringField("created_at"))
-            reject(lineNo, "wrong_type");
-        else if (!nullableString("supersedes"))
-            reject(lineNo, "wrong_type");
-        else {
-            // The tamper-evident check: a hand-edited statement without
-            // an updated entry_id is caught here, not silently ranked.
-            const recomputed = computeEntryId(o.type, o.statement, (o.scope ?? null));
-            if (recomputed !== o.entry_id) {
-                reject(lineNo, "id_mismatch");
-                continue;
-            }
-            const e = {
-                entry_id: o.entry_id,
-                type: o.type,
-                statement: o.statement,
-                scope: (o.scope ?? null),
-                evidence: o.evidence,
-                recurrence: o.recurrence,
-                origin: o.origin,
-                author_hash: (o.author_hash ?? null),
-                op: o.op,
-                created_at: o.created_at,
-                supersedes: (o.supersedes ?? null),
-            };
-            const existing = byId.get(e.entry_id);
-            if (existing) {
-                byId.set(e.entry_id, join(existing, e));
-                folded++;
-                continue;
-            }
-            if (accepted >= MAX_ENTRIES) {
-                reject(lineNo, "corpus_too_large");
-                continue;
-            }
-            byId.set(e.entry_id, e);
-            accepted++;
-        }
-    }
-    const entries = [...byId.values()].sort((a, b) => a.entry_id < b.entry_id ? -1 : a.entry_id > b.entry_id ? 1 : 0);
-    return { version, repoId, entries, rejected, folded };
-}
-/**
- * Compute the identity of an OKF entry: `fnv1a64("okf:v2\0" + type +
- * "\0" + statement + "\0" + (scope ?? ""))`.
- *
- * D8-05 — deliberately NOT `fingerprint()`:
- *  - it salts with `project_id`, so every clone would produce a
- *    different id for the same rule, the shared file would accumulate
- *    one entry per developer per rule, and the merge fold would never
- *    once fire;
- *  - it runs `normalize()`, which lowercases and rewrites
- *    `path.ext:line:col` — both destructive for a curated statement,
- *    where casing and file paths carry meaning.
- *
- * NUL separators keep (`rule`, "ab", "c") distinct from
- * ("rule", "a", "bc") — plain concatenation could never.
- */
-export function computeEntryId(type, statement, scope) {
-    return fnv1a64(`okf:v2\u0000${type}\u0000${statement}\u0000${scope ?? ""}`);
-}