@jmtrin/kevin-core 1.3.0

package/dist/ConventionMiner.js

@@ -0,0 +1,242 @@
+import { fingerprint } from "./fingerprint.js";
+const DEFAULT_MIN_SUPPORT = 5;
+export class ConventionMiner {
+    store;
+    memoryService;
+    projectId;
+    metrics;
+    constructor(store, memoryService, projectId, metrics) {
+        this.store = store;
+        this.memoryService = memoryService;
+        this.projectId = projectId;
+        this.metrics = metrics ?? null;
+        // `memoryService` is retained for emission (K7-012); mining itself is
+        // store-only.
+        void this.memoryService;
+    }
+    /** v0.7.0 (K7-010) — the `sequence` miner over successful tool_calls. */
+    mineSequence(minSupport = DEFAULT_MIN_SUPPORT) {
+        const rows = this.fetchToolCalls();
+        if (rows.length === 0)
+            return [];
+        // Group successful calls by session in execution order (ts ASC, then id
+        // as a deterministic tie-break).
+        const bySession = new Map();
+        const sorted = [...rows]
+            .filter((r) => r.success === 1)
+            .sort((a, b) => a.session_id === b.session_id
+            ? compareTs(a.ts, b.ts) || a.id.localeCompare(b.id)
+            : a.session_id.localeCompare(b.session_id));
+        for (const r of sorted) {
+            const list = bySession.get(r.session_id) ?? [];
+            list.push(r);
+            bySession.set(r.session_id, list);
+        }
+        const map = new Map();
+        const record = (key, statement, sessionId) => {
+            let cand = map.get(key);
+            if (!cand) {
+                cand = { key, statement, sessions: new Set() };
+                map.set(key, cand);
+            }
+            cand.sessions.add(sessionId);
+        };
+        for (const [sessionId, list] of bySession) {
+            if (list.length < 2)
+                continue;
+            for (let i = 0; i < list.length - 1; i++) {
+                const a = list[i];
+                const b = list[i + 1];
+                const aTok = tokenOf(a);
+                const bTok = tokenOf(b);
+                const key2 = `seq::${aTok}::${bTok}`;
+                const stmt2 = statementForSequence(aTok, bTok);
+                record(key2, stmt2, sessionId);
+                if (i + 2 < list.length) {
+                    const c = list[i + 2];
+                    const cTok = tokenOf(c);
+                    const key3 = `seq::${aTok}::${bTok}::${cTok}`;
+                    const stmt3 = statementForSequence3(aTok, bTok, cTok);
+                    record(key3, stmt3, sessionId);
+                }
+            }
+        }
+        return this.materialize(map, minSupport, "sequence");
+    }
+    /** v0.7.0 (K7-011) — the `co_edit` miner over same-session file writes. */
+    mineCoEdit(minSupport = DEFAULT_MIN_SUPPORT) {
+        const rows = this.fetchToolCalls();
+        if (rows.length === 0)
+            return [];
+        // Successful file writes (broad: any success call mentioning a path) per
+        // session. Pairs span two different directory prefixes.
+        const bySession = new Map();
+        const sorted = [...rows]
+            .filter((r) => r.success === 1 && pathOf(r) !== null)
+            .sort((a, b) => a.session_id === b.session_id
+            ? compareTs(a.ts, b.ts) || a.id.localeCompare(b.id)
+            : a.session_id.localeCompare(b.session_id));
+        for (const r of sorted) {
+            const list = bySession.get(r.session_id) ?? [];
+            list.push(pathOf(r));
+            bySession.set(r.session_id, list);
+        }
+        const map = new Map();
+        const record = (key, statement, sessionId) => {
+            let cand = map.get(key);
+            if (!cand) {
+                cand = { key, statement, sessions: new Set() };
+                map.set(key, cand);
+            }
+            cand.sessions.add(sessionId);
+        };
+        for (const [sessionId, paths] of bySession) {
+            const unique = [...new Set(paths)];
+            if (unique.length < 2)
+                continue;
+            // Bounded enumeration: a large session must not explode into an
+            // O(n²) pair set. Cap distinct prefixes per session at 40.
+            const limit = Math.min(unique.length, 40);
+            for (let i = 0; i < limit; i++) {
+                const pA = unique[i];
+                for (let j = i + 1; j < limit; j++) {
+                    const pB = unique[j];
+                    const prefixA = dirOf(pA);
+                    const prefixB = dirOf(pB);
+                    if (prefixA === prefixB)
+                        continue;
+                    const [lo, hi] = prefixA < prefixB ? [prefixA, prefixB] : [prefixB, prefixA];
+                    const key = `coedit::${lo}::${hi}`;
+                    const stmt = `every new file under ${lo}/ is accompanied by a change under ${hi}/`;
+                    record(key, stmt, sessionId);
+                }
+            }
+        }
+        return this.materialize(map, minSupport, "co_edit");
+    }
+    /** v0.7.0 (K7-012) — mine both kinds in one call. */
+    mine(minSupport = DEFAULT_MIN_SUPPORT) {
+        return [
+            ...this.mineSequence(minSupport),
+            ...this.mineCoEdit(minSupport),
+        ].sort((a, b) => a.statement.localeCompare(b.statement));
+    }
+    /**
+     * v0.7.0 (K7-012 / plan §5.4, D7-11) — emit mined(conventions) as `rule`
+     * memories. Returns the number of memories created or refreshed and
+     * increments `conventions_mined`. Runs on session.idle only, behind
+     * convention_mining_enabled. The fingerprint derives from the statement,
+     * so a re-mine of an unchanged convention collides and supersedes.
+     */
+    emit(conventions) {
+        let emitted = 0;
+        for (const c of conventions) {
+            const derivedFingerprint = fingerprint(c.statement, this.projectId);
+            // save() derives the fingerprint-based supersede/collision path for
+            // `rule` types automatically, so re-emitting an unchanged convention
+            // refreshes rather than duplicates.
+            this.memoryService.save({
+                type: "rule",
+                origin: "pattern",
+                scope: "project",
+                projectId: this.projectId,
+                fingerprint: derivedFingerprint,
+                content: c.statement,
+                relevanceScore: 0.5,
+                sourceTool: "ConventionMiner",
+            });
+            this.metrics?.incr("conventions_mined", 1);
+            emitted += 1;
+        }
+        return emitted;
+    }
+    materialize(map, minSupport, kind) {
+        const out = [];
+        for (const cand of map.values()) {
+            if (cand.sessions.size < minSupport)
+                continue;
+            out.push({
+                fingerprint: fingerprint(cand.statement, this.projectId),
+                statement: cand.statement,
+                support: cand.sessions.size,
+                kind,
+            });
+        }
+        // Deterministic order: lexicographic by statement (ties are resolved).
+        return out.sort((a, b) => a.statement.localeCompare(b.statement));
+    }
+    fetchToolCalls() {
+        const rows = this.store
+            .prepare(`SELECT id, session_id, ts, tool, success, args_summary
+				 FROM tool_calls
+				 WHERE project_id = ?
+				 ORDER BY session_id, ts`)
+            .all(this.projectId);
+        return rows;
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers — deterministic token/path extraction. Every value is normalized so
+// the same underlying fact never collides via a JavaScript type difference.
+// ---------------------------------------------------------------------------
+/** `<tool>:<first path segment>` token for sequence mining. */
+function tokenOf(r) {
+    const seg = firstPathSegment(r.args_summary);
+    return `${r.tool}:${seg}`;
+}
+function compareTs(a, b) {
+    return a.localeCompare(b);
+}
+/** First path segment of the first path-like argument, else "*". */
+function firstPathSegment(argsSummary) {
+    const paths = pathSegments(argsSummary);
+    const first = paths[0];
+    if (!first)
+        return "*";
+    return first.split("/").filter(Boolean)[0] ?? "*";
+}
+/** All path segments found in args_summary, in appearance order. */
+function pathSegments(argsSummary) {
+    const text = argsSummary ?? "";
+    const found = [];
+    // Try JSON object string values first.
+    try {
+        const parsed = JSON.parse(text);
+        if (typeof parsed === "object" &&
+            parsed !== null &&
+            !Array.isArray(parsed)) {
+            for (const v of Object.values(parsed)) {
+                if (typeof v === "string" && /\//.test(v) && !v.includes(" ")) {
+                    found.push(v.replace(/\\/g, "/").toLowerCase().trim());
+                }
+            }
+        }
+    }
+    catch {
+        /* not JSON */
+    }
+    if (found.length === 0) {
+        const m = text.match(/[^\s"':,=]*\/[^\s"':,=]*/g);
+        for (const tok of m ?? []) {
+            found.push(tok.replace(/\\/g, "/").toLowerCase().trim());
+        }
+    }
+    return found;
+}
+/** Directory of a path (drop the filename). `src/routes/user.ts` → `src/routes`. */
+function dirOf(p) {
+    const segs = p.split("/").filter(Boolean);
+    segs.pop();
+    return segs.join("/") || "*";
+}
+/** A deterministic path for a call if it is a file write/read on disk. */
+function pathOf(r) {
+    const segs = pathSegments(r.args_summary);
+    return segs[0] ?? null;
+}
+function statementForSequence(a, b) {
+    return `every ${a} is immediately followed by ${b}`;
+}
+function statementForSequence3(a, b, c) {
+    return `every ${a} is followed by ${b} and then ${c}`;
+}

package/dist/Curator.d.ts

@@ -0,0 +1,118 @@
+import { type KevinEnv } from "./env.js";
+import { type ArtifactWriter } from "./ArtifactWriter.js";
+import type { MemoryService } from "./MemoryService.js";
+import type { Store } from "./Store.js";
+import type { Metrics } from "./metrics.js";
+/**
+ * K6-012/013 — v0.6.0 pull — candidate selection, line rendering and the
+ * proposal lifecycle (plan §5.4/§5.5).
+ *
+ * Deliberately fs-free: this module holds NO filesystem capability — reads
+ * and writes are delegated to the `ArtifactWriter` at the call site (D6-01).
+ */
+export interface CurationCandidate {
+    readonly memoryId: string;
+    /** The single AGENTS.md bullet. */
+    readonly line: string;
+    readonly confidence: number;
+    /** e.g. "verified 3×, last 2026-08-04". */
+    readonly evidence: string;
+}
+export type ProposalKind = "agents_md" | "skill" | "reference";
+export type ProposalStatus = "pending" | "approved" | "rejected" | "applied" | "superseded";
+export type ProposalTransition = "approve" | "reject" | "apply" | "supersede";
+/** Plan §5.4 — the row shape of §6's `curation_proposals` table, surfaced. */
+export interface CurationProposal {
+    readonly id: string;
+    readonly kind: ProposalKind;
+    readonly targetPath: string;
+    readonly memoryIds: readonly string[];
+    readonly proposedText: string;
+    readonly diff: string;
+    readonly status: ProposalStatus;
+    readonly createdAt: string;
+}
+/** v0.8.0 (K8-023 / plan §5.7) — the candidate source. */
+export type CandidateSource = "memories" | "shared";
+export declare function firstSentence(content: string): string;
+export declare class Curator {
+    private readonly store;
+    private readonly memoryService;
+    private readonly projectId;
+    private readonly repoId?;
+    private readonly env?;
+    private readonly metrics;
+    constructor(store: Store, memoryService: MemoryService, projectId: string, metrics?: Metrics | null, repoId?: string | null | undefined, env?: KevinEnv | undefined);
+    /**
+     * v0.8.0 (K8-023 / plan §5.7) — the source the flag selects. When
+     * `shared_layer_enabled` is on, curation reads the committed OKF file's
+     * projection (`shared_entries`) instead of the local `memories` table.
+     * The routing lives here, next to the predicate it switches, so a
+     * reviewer sees substrate and rendering change together (D8-11).
+     */
+    private sourceFromFlag;
+    /** v0.8.0 (K8-023) — the shared-layer candidate rows. */
+    private sharedRows;
+    /**
+     * Plan §5.4 selection predicate — all clauses must hold, evaluated
+     * verbatim. The confidence floor cannot be expressed in SQL (it is the
+     * two-sided formula of `computeConfidence`), so the cheap clauses run
+     * in SQL and confidence is computed and filtered per row in JS.
+     *
+     * The floor is `confidence >= 0.6` where the feedback arm of D6-09 also
+     * clears it: `computeConfidence` credits one positive human verdict at
+     * 0.05 (K5-010), so a row with `feedback_positive = 1` and no causal
+     * evidence scores 0.55 — yet D6-09's warrant is "either the world
+     * verified it twice, or a human verified it once". The disjunction
+     * (K6-012 acceptance) is the floor's complement for the feedback arm.
+     *
+     * Ordered by `confidence DESC, updated_at DESC`, capped at 20 lines and
+     * 4000 characters of content, whichever binds first. The char budget
+     * counts the raw content length: rendered lines are truncated to 160
+     * chars, so a rendered-line budget could never bind before the line cap.
+     *
+     * v0.8.0 (K8-023 / plan §5.7) — `source` selects the substrate: the
+     * v0.6.0 path over `memories` ("local") or the shared layer. The
+     * predicate, the caps and the deterministic sort are unchanged in both
+     * cases — only the FROM changes. The shared schema has no feedback
+     * columns, so the feedback disjunct of the predicate can never fire
+     * there; `evidence >= 2` is its SQL half, evaluated in the query.
+     */
+    candidates(limit?: number, source?: CandidateSource): CurationCandidate[];
+    /**
+     * Renders the block sorted by memory id (D6-10): confidence orders
+     * selection, id orders output. Adding one candidate to a set of ten
+     * must change exactly one line of the rendered block.
+     */
+    renderBlock(candidates: CurationCandidate[]): string;
+    /**
+     * Plan §5.4 — strict dry run (D5-08): plan only, never write. Returns a
+     * pending proposal per call, or [] when no candidate clears the floor.
+     *
+     * The proposal is a whole-block proposal: the persisted `proposed_text`
+     * is the merged block (current block in the file + new candidate lines),
+     * so approving it replaces the file block with exactly what was reviewed.
+     * The current block is learned from `plan().before` — the Curator has no
+     * fs capability, the writer reads (D6-01). Both plan calls are
+     * deterministic, so a second propose() with unchanged inputs reproduces
+     * the persisted diff byte-identically.
+     *
+     * A new proposal supersedes prior pending (or rejected) rows for the
+     * same (project_id, kind, target_path) triple — §5.5's regeneration
+     * arrow. Rows are never deleted (the audit trail is append-only).
+     *
+     * The schema's `memory_id` column is singular while a whole-block
+     * proposal carries several ids; the contributing ids are stored joined
+     * by "," (uuidv7 ids contain no comma) and split on read.
+     */
+    propose(kind: ProposalKind, writer: ArtifactWriter): CurationProposal[];
+    /**
+     * Plan §5.5 state machine, as explicit transitions with an exhaustive
+     * switch — an unknown transition or an illegal source state throws
+     * rather than silently no-oping. `decided_at` stamps approve/reject/
+     * supersede, `applied_at` stamps apply.
+     */
+    transition(proposalId: string, transition: ProposalTransition): ProposalStatus;
+    /** Plan §5.6 target paths. agents_md is a setting; skill/reference live under ~/.opencode-kevin. */
+    private targetPathFor;
+}

package/dist/Curator.js

@@ -0,0 +1,326 @@
+import { join } from "node:path";
+import { resolveEnv } from "./env.js";
+import { MARKER_BEGIN, MARKER_END, } from "./ArtifactWriter.js";
+import { computeConfidence } from "./confidence.js";
+import { normalize } from "./fingerprint.js";
+import { uuidv7 } from "./uuid.js";
+const MAX_CANDIDATE_LINES = 20;
+const MAX_CANDIDATE_CHARS = 4000;
+const CONFIDENCE_FLOOR = 0.6;
+const MAX_SENTENCE_CHARS = 160;
+export function firstSentence(content) {
+    const match = content.match(/^[\s\S]*?(?=[.!?](?:\s|$)|\r?\n|$)/);
+    const sentence = (match ? match[0] : content).trim();
+    return sentence.slice(0, MAX_SENTENCE_CHARS);
+}
+function evidenceString(row) {
+    const parts = [];
+    if (row.evidence_count >= 2) {
+        const last = row.last_verified_at
+            ? `, last ${row.last_verified_at.slice(0, 10)}`
+            : "";
+        parts.push(`verified ${row.evidence_count}×${last}`);
+    }
+    if (row.feedback_positive >= 1) {
+        parts.push(`feedback ${row.feedback_positive}×`);
+    }
+    return parts.join(", ");
+}
+export class Curator {
+    store;
+    memoryService;
+    projectId;
+    repoId;
+    env;
+    metrics;
+    constructor(store, memoryService, projectId, metrics, repoId, env) {
+        this.store = store;
+        this.memoryService = memoryService;
+        this.projectId = projectId;
+        this.repoId = repoId;
+        this.env = env;
+        this.metrics = metrics ?? null;
+    }
+    /**
+     * v0.8.0 (K8-023 / plan §5.7) — the source the flag selects. When
+     * `shared_layer_enabled` is on, curation reads the committed OKF file's
+     * projection (`shared_entries`) instead of the local `memories` table.
+     * The routing lives here, next to the predicate it switches, so a
+     * reviewer sees substrate and rendering change together (D8-11).
+     */
+    sourceFromFlag() {
+        return this.memoryService.getSetting("shared_layer_enabled", "0") === "1"
+            ? "shared"
+            : "memories";
+    }
+    /** v0.8.0 (K8-023) — the shared-layer candidate rows. */
+    sharedRows() {
+        if (!this.repoId) {
+            throw new Error("shared source requires a repoId");
+        }
+        return this.store
+            .prepare(`SELECT entry_id AS id, statement AS content,
+				        evidence AS evidence_count,
+				        0 AS recurrence_count,
+				        0 AS feedback_positive,
+				        0 AS feedback_negative,
+				        NULL AS last_verified_at,
+				        created_at AS updated_at
+				 FROM shared_entries
+				 WHERE repo_id = ?
+				   AND op = 'assert'
+				   AND evidence >= 2`)
+            .all(this.repoId);
+    }
+    /**
+     * Plan §5.4 selection predicate — all clauses must hold, evaluated
+     * verbatim. The confidence floor cannot be expressed in SQL (it is the
+     * two-sided formula of `computeConfidence`), so the cheap clauses run
+     * in SQL and confidence is computed and filtered per row in JS.
+     *
+     * The floor is `confidence >= 0.6` where the feedback arm of D6-09 also
+     * clears it: `computeConfidence` credits one positive human verdict at
+     * 0.05 (K5-010), so a row with `feedback_positive = 1` and no causal
+     * evidence scores 0.55 — yet D6-09's warrant is "either the world
+     * verified it twice, or a human verified it once". The disjunction
+     * (K6-012 acceptance) is the floor's complement for the feedback arm.
+     *
+     * Ordered by `confidence DESC, updated_at DESC`, capped at 20 lines and
+     * 4000 characters of content, whichever binds first. The char budget
+     * counts the raw content length: rendered lines are truncated to 160
+     * chars, so a rendered-line budget could never bind before the line cap.
+     *
+     * v0.8.0 (K8-023 / plan §5.7) — `source` selects the substrate: the
+     * v0.6.0 path over `memories` ("local") or the shared layer. The
+     * predicate, the caps and the deterministic sort are unchanged in both
+     * cases — only the FROM changes. The shared schema has no feedback
+     * columns, so the feedback disjunct of the predicate can never fire
+     * there; `evidence >= 2` is its SQL half, evaluated in the query.
+     */
+    candidates(limit, source = "memories") {
+        const rows = source === "shared"
+            ? this.sharedRows()
+            : this.store
+                .prepare(`SELECT id, content, evidence_count, recurrence_count,
+					        feedback_positive, feedback_negative,
+					        last_verified_at, updated_at
+					 FROM memories
+					 WHERE status = 'active'
+					   AND ignored = 0
+					   AND curated = 0
+					   AND (inferable IS NULL OR inferable != 1)
+					   AND (evidence_count >= 2 OR feedback_positive >= 1)`)
+                .all();
+        const scored = rows
+            .map((row) => ({
+            row,
+            confidence: computeConfidence(row.evidence_count ?? 0, row.recurrence_count ?? 0, row.feedback_positive ?? 0, row.feedback_negative ?? 0),
+        }))
+            .filter((s) => s.confidence >= CONFIDENCE_FLOOR || s.row.feedback_positive >= 1)
+            .sort((a, b) => b.confidence - a.confidence ||
+            b.row.updated_at.localeCompare(a.row.updated_at));
+        const maxLines = limit ?? MAX_CANDIDATE_LINES;
+        const result = [];
+        let totalChars = 0;
+        for (const s of scored) {
+            if (result.length >= maxLines)
+                break;
+            if (totalChars + s.row.content.length > MAX_CANDIDATE_CHARS)
+                break;
+            const evidence = evidenceString(s.row);
+            result.push({
+                memoryId: s.row.id,
+                line: `- ${firstSentence(s.row.content)} (${evidence})`,
+                confidence: s.confidence,
+                evidence,
+            });
+            totalChars += s.row.content.length;
+        }
+        return result;
+    }
+    /**
+     * Renders the block sorted by memory id (D6-10): confidence orders
+     * selection, id orders output. Adding one candidate to a set of ten
+     * must change exactly one line of the rendered block.
+     */
+    renderBlock(candidates) {
+        const sorted = [...candidates].sort((a, b) => a.memoryId.localeCompare(b.memoryId));
+        return `${sorted.map((c) => c.line).join("\n")}\n`;
+    }
+    /**
+     * Plan §5.4 — strict dry run (D5-08): plan only, never write. Returns a
+     * pending proposal per call, or [] when no candidate clears the floor.
+     *
+     * The proposal is a whole-block proposal: the persisted `proposed_text`
+     * is the merged block (current block in the file + new candidate lines),
+     * so approving it replaces the file block with exactly what was reviewed.
+     * The current block is learned from `plan().before` — the Curator has no
+     * fs capability, the writer reads (D6-01). Both plan calls are
+     * deterministic, so a second propose() with unchanged inputs reproduces
+     * the persisted diff byte-identically.
+     *
+     * A new proposal supersedes prior pending (or rejected) rows for the
+     * same (project_id, kind, target_path) triple — §5.5's regeneration
+     * arrow. Rows are never deleted (the audit trail is append-only).
+     *
+     * The schema's `memory_id` column is singular while a whole-block
+     * proposal carries several ids; the contributing ids are stored joined
+     * by "," (uuidv7 ids contain no comma) and split on read.
+     */
+    propose(kind, writer) {
+        const targetPath = this.targetPathFor(kind);
+        const candidates = this.candidates(undefined, this.sourceFromFlag());
+        if (candidates.length === 0)
+            return [];
+        const readPlan = writer.plan(targetPath, this.renderBlock(candidates));
+        const currentBlock = extractBlock(readPlan.before);
+        // v0.7.0 (K7-013 / plan §4, D6-09) — de-duplicate against the WHOLE
+        // file, not just the region between Kevin's markers. A convention the
+        // user already wrote in their own words in their own section must not
+        // be proposed back to them. The comparison is over the same normalized
+        // tokens the fingerprint uses — no new similarity metric (D7-11).
+        const entireFile = wholeFileLines(readPlan.before);
+        const freshCandidates = candidates.filter((candidate) => !entireFile.has(normalizeBullet(candidate.line)));
+        if (freshCandidates.length === 0 && currentBlock === "")
+            return [];
+        const newBlock = this.renderBlock(freshCandidates);
+        const newLines = newBlock.split("\n").filter((l) => l !== "");
+        const mergedBlock = newLines.length === 0
+            ? currentBlock
+            : currentBlock === ""
+                ? `${newLines.join("\n")}\n`
+                : `${currentBlock}${currentBlock.endsWith("\n") ? "" : "\n"}${newLines.join("\n")}\n`;
+        // v0.7.0 (K7-013) — nothing new to propose: every candidate is already
+        // in the file (inside or outside the markers). A vacuous proposal would
+        // be noise; return none.
+        const plan = writer.plan(targetPath, mergedBlock);
+        const prior = this.store
+            .prepare(`SELECT id FROM curation_proposals
+				 WHERE project_id = ? AND kind = ? AND target_path = ?
+				   AND status IN ('pending', 'rejected')`)
+            .all(this.projectId, kind, targetPath);
+        for (const row of prior) {
+            this.transition(row.id, "supersede");
+        }
+        const memoryIds = freshCandidates.map((c) => c.memoryId);
+        const id = uuidv7();
+        this.store
+            .prepare(`INSERT INTO curation_proposals
+				 (id, project_id, memory_id, kind, target_path,
+				  proposed_text, diff, status)
+				 VALUES (?, ?, ?, ?, ?, ?, ?, 'pending')`)
+            .run(id, this.projectId, memoryIds.join(","), kind, targetPath, mergedBlock, plan.diff);
+        this.metrics?.incr("proposals_created", 1);
+        const row = this.store
+            .prepare("SELECT created_at FROM curation_proposals WHERE id = ?")
+            .get(id);
+        return [
+            {
+                id,
+                kind,
+                targetPath,
+                memoryIds,
+                proposedText: mergedBlock,
+                diff: plan.diff,
+                status: "pending",
+                createdAt: row.created_at,
+            },
+        ];
+    }
+    /**
+     * Plan §5.5 state machine, as explicit transitions with an exhaustive
+     * switch — an unknown transition or an illegal source state throws
+     * rather than silently no-oping. `decided_at` stamps approve/reject/
+     * supersede, `applied_at` stamps apply.
+     */
+    transition(proposalId, transition) {
+        const row = this.store
+            .prepare("SELECT status FROM curation_proposals WHERE id = ?")
+            .get(proposalId);
+        if (!row) {
+            throw new Error(`proposal not found: ${proposalId}`);
+        }
+        const status = row.status;
+        let next = null;
+        switch (transition) {
+            case "approve":
+                if (status === "pending")
+                    next = "approved";
+                break;
+            case "reject":
+                if (status === "pending")
+                    next = "rejected";
+                break;
+            case "apply":
+                if (status === "approved")
+                    next = "applied";
+                break;
+            case "supersede":
+                if (status === "pending" || status === "rejected") {
+                    next = "superseded";
+                }
+                break;
+            default:
+                throw new Error(`unknown transition: ${transition}`);
+        }
+        if (next === null) {
+            throw new Error(`illegal transition: ${status} -> ${transition}`);
+        }
+        if (next === "applied") {
+            this.store
+                .prepare("UPDATE curation_proposals SET status = 'applied', applied_at = datetime('now') WHERE id = ?")
+                .run(proposalId);
+        }
+        else {
+            this.store
+                .prepare("UPDATE curation_proposals SET status = ?, decided_at = datetime('now') WHERE id = ?")
+                .run(next, proposalId);
+        }
+        return next;
+    }
+    /** Plan §5.6 target paths. agents_md is a setting; skill/reference live under ~/.opencode-kevin. */
+    targetPathFor(kind) {
+        switch (kind) {
+            case "agents_md":
+                return this.memoryService.getSetting("agents_md_path", "AGENTS.md");
+            case "skill":
+                return join(resolveEnv(this.env).dataRoot, "skills", "project-knowledge.md");
+            case "reference":
+                return join(resolveEnv(this.env).dataRoot, "refs", "project-knowledge.md");
+        }
+    }
+}
+/** The block content currently between the markers, "" when absent or malformed. */
+function extractBlock(before) {
+    const begin = before.indexOf(MARKER_BEGIN);
+    const end = before.indexOf(MARKER_END);
+    if (begin === -1 || end === -1 || end < begin)
+        return "";
+    return before
+        .slice(begin + MARKER_BEGIN.length, end)
+        .replace(/^\r?\n/, "")
+        .replace(/\r?\n$/, "");
+}
+/**
+ * v0.7.0 (K7-013 / plan §4) — the normalized set of bullet statements across
+ * the WHOLE file, including any the user wrote outside Kevin's markers. Only
+ * markdown bullets (`- ...`) are considered: prose and the marker lines are
+ * never a candidate to propose back.
+ */
+function wholeFileLines(before) {
+    const set = new Set();
+    for (const line of before.split(/\r?\n/)) {
+        if (line.trim().startsWith("-")) {
+            set.add(normalizeBullet(line));
+        }
+    }
+    return set;
+}
+/** Normalize a rendered bullet for de-duplication — strip the marker prefix. */
+function normalizeBullet(line) {
+    const statement = line
+        .replace(/^\s*-\s+/, "")
+        .trim()
+        .replace(/\s+\((?:verified|feedback)[^)]*\)\s*$/i, "");
+    return normalize(statement);
+}