@jmtrin/opencode-kevin 1.2.0 → 1.4.0

package/dist/plugin/ConventionMiner.js

@@ -1,242 +0,0 @@
-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/plugin/Curator.d.ts

@@ -1,116 +0,0 @@
-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 metrics;
-    constructor(store: Store, memoryService: MemoryService, projectId: string, metrics?: Metrics | null, repoId?: string | null | 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/plugin/Curator.js

@@ -1,324 +0,0 @@
-import { homedir } from "node:os";
-import { join } from "node:path";
-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;
-    metrics;
-    constructor(store, memoryService, projectId, metrics, repoId) {
-        this.store = store;
-        this.memoryService = memoryService;
-        this.projectId = projectId;
-        this.repoId = repoId;
-        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(homedir(), ".opencode-kevin", "skills", "project-knowledge.md");
-            case "reference":
-                return join(homedir(), ".opencode-kevin", "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);
-}

package/dist/plugin/DashboardHtml.d.ts

@@ -1,5 +0,0 @@
-import type { TuiSnapshotSet } from "./tui-types.js";
-export declare function escapeHtml(text: string): string;
-export declare function proposalToken(proposalId: string, proposedText: string): string;
-export declare function renderDashboard(views: TuiSnapshotSet): string;
-export declare function writeDashboard(root: string, views: TuiSnapshotSet): string;