@jmtrin/opencode-kevin 0.9.0 → 1.1.0

package/dist/plugin/inferability.js

@@ -86,4 +86,3 @@ export function classify(memory) {
     // Rule 5.
     return "unknown";
 }
-//# sourceMappingURL=inferability.js.map

package/dist/plugin/kevin_approve.js

@@ -50,4 +50,3 @@ export function kevinApprove(store, memoryService, curator, writer, metrics, arg
 function sqliteNow() {
     return new Date().toISOString().slice(0, 19).replace("T", " ");
 }
-//# sourceMappingURL=kevin_approve.js.map

package/dist/plugin/kevin_audit.d.ts

@@ -122,6 +122,37 @@ export interface AuditReport {
         };
         verdict: "healthy" | "degraded" | "unknown";
     };
+    /**
+     * v1.0.0 (K10-020 / plan §5.6) — the perf block: per scope, the most
+     * recent `perf_samples` aggregate row (count/p50/p95/max) plus the
+     * stored budget and verdict. The stored aggregates are used DIRECTLY —
+     * re-aggregating aggregates would produce a number with no meaning
+     * (plan anti-pattern 42), and using the most recent row per scope is
+     * exactly what `bench:check` does, so `within_budget` agrees with it
+     * on the same data. Omitted (not zero-valued) on a pre-011 database,
+     * following the host precedent.
+     */
+    perf?: {
+        scopes: Record<string, {
+            count: number;
+            p50: number;
+            p95: number;
+            max: number;
+            budget_p95: number;
+            within_budget: boolean;
+        }>;
+    };
+    /**
+     * v1.0.0 (K10-020 / plan §5.6) — the contract block: the live contract's
+     * identity, computed from source rather than the database, so it is
+     * present even on a pre-011 database.
+     */
+    contract?: {
+        contract_version: number;
+        digest: string;
+        clause_count: number;
+        deprecated_count: number;
+    };
     partial: boolean;
 }
 /**

package/dist/plugin/kevin_audit.js

@@ -1,5 +1,7 @@
 import { effectivePrePromptCap } from "./ContextInjector.js";
 import { hasRepoIdColumn } from "./MemoryService.js";
+import { contractDigest, describeContract } from "./contract.js";
+import { BUDGETS } from "./perf.js";
 const ALL_FALSE_CAPABILITIES = {
     skills: false,
     references: false,
@@ -484,6 +486,62 @@ export function buildAudit(store, metrics, capabilities = ALL_FALSE_CAPABILITIES
     // marking the report partial — the host block is additive, unlike
     // channels/curation which are the v0.6.0 scoreboard. Existing
     // v0.8.0-era tests run on 007/008 stores and expect partial false.
+    // v1.0.0 (K10-020 / plan §5.6) — perf block: the most recent aggregate
+    // row per scope, read directly from perf_samples. A scope with no rows
+    // reports count 0, zero timings and within_budget true — never NULL,
+    // never NaN. Omitted on a pre-011 database (host precedent).
+    let perf;
+    let hasSchema011 = false;
+    try {
+        const row = store
+            .prepare("SELECT 1 AS n FROM sqlite_master WHERE type='table' AND name='perf_samples'")
+            .get();
+        hasSchema011 = !!row;
+    }
+    catch {
+        hasSchema011 = false;
+    }
+    if (hasSchema011) {
+        try {
+            const scopes = {};
+            const latest = store.prepare(`SELECT sample_count AS count, p50_ms AS p50, p95_ms AS p95,
+						max_ms AS max, budget_p95_ms AS budget_p95, within_budget
+					 FROM perf_samples WHERE scope = ? ORDER BY id DESC LIMIT 1`);
+            for (const budget of BUDGETS) {
+                const row = latest.get(budget.scope);
+                scopes[budget.scope] = row
+                    ? {
+                        count: row.count,
+                        p50: row.p50,
+                        p95: row.p95,
+                        max: row.max,
+                        budget_p95: row.budget_p95,
+                        within_budget: row.within_budget === 1,
+                    }
+                    : {
+                        count: 0,
+                        p50: 0,
+                        p95: 0,
+                        max: 0,
+                        budget_p95: budget.p95Ms,
+                        within_budget: true,
+                    };
+            }
+            perf = { scopes };
+        }
+        catch {
+            perf = undefined;
+        }
+    }
+    // v1.0.0 (K10-020 / plan §5.6) — contract block: pure function of the
+    // source, no database involvement.
+    const liveContract = describeContract();
+    const contract = {
+        contract_version: liveContract.contractVersion,
+        digest: contractDigest(liveContract),
+        clause_count: liveContract.clauses.length,
+        deprecated_count: liveContract.clauses.filter((c) => c.deprecated).length,
+    };
     return {
         memories,
         injections,
@@ -498,7 +556,8 @@ export function buildAudit(store, metrics, capabilities = ALL_FALSE_CAPABILITIES
         curation,
         team,
         host,
+        perf,
+        contract,
         partial,
     };
 }
-//# sourceMappingURL=kevin_audit.js.map

package/dist/plugin/kevin_bench.d.ts

@@ -0,0 +1,10 @@
+import type { Store } from "./Store.js";
+export interface KevinBenchDeps {
+    store: Store;
+    /** Working directory used to locate bench/corpus (defaults process.cwd()). */
+    cwd?: string;
+}
+export interface KevinBenchArgs {
+    action: "status" | "last";
+}
+export declare function buildKevinBench(deps: KevinBenchDeps, args: KevinBenchArgs): Record<string, unknown>;

package/dist/plugin/kevin_bench.js

@@ -0,0 +1,82 @@
+/**
+ * K10-019 — kevin_bench: reports what `npm run bench` recorded.
+ *
+ * It NEVER runs the benchmark — running it from inside a live session
+ * would measure the session and pollute the user's database. The module
+ * imports nothing from scripts/bench.ts; the corpus digest of the on-disk
+ * corpus is recomputed here with the same fnv1a64 discipline so a result
+ * computed from a different corpus is visibly a different measurement.
+ */
+import { readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { fnv1a64 } from "./fingerprint.js";
+function onDiskCorpusDigest(cwd) {
+    try {
+        const dir = join(cwd, "bench", "corpus");
+        statSync(dir);
+        const mem = readFileSync(join(dir, "memories.jsonl"), "utf8");
+        const q = readFileSync(join(dir, "queries.jsonl"), "utf8");
+        return {
+            digest: fnv1a64(`${mem}\n${q}`),
+            queries: q.split("\n").filter((l) => l.trim().length > 0).length,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function noRuns() {
+    return {
+        has_runs: false,
+        hint: "npm run bench",
+    };
+}
+export function buildKevinBench(deps, args) {
+    if (args.action === "status") {
+        const count = deps.store
+            .prepare("SELECT COUNT(*) AS c FROM bench_runs")
+            .get();
+        if (!count || count.c === 0)
+            return noRuns();
+        const latest = deps.store
+            .prepare("SELECT corpus_digest, contract_digest, package_version, runtime, ran_at FROM bench_runs ORDER BY id DESC LIMIT 1")
+            .get();
+        if (!latest)
+            return noRuns();
+        const disk = onDiskCorpusDigest(deps.cwd ?? process.cwd());
+        return {
+            has_runs: true,
+            total_runs: count.c,
+            corpus_digest: latest.corpus_digest,
+            contract_digest: latest.contract_digest,
+            package_version: latest.package_version,
+            runtime: latest.runtime,
+            last_ran_at: latest.ran_at,
+            corpus_on_disk: disk === null ? null : disk.digest,
+            matches_disk_corpus: disk !== null && disk.digest === latest.corpus_digest,
+        };
+    }
+    const latest = deps.store
+        .prepare("SELECT corpus_digest, contract_digest, package_version, runtime, ran_at FROM bench_runs ORDER BY id DESC LIMIT 1")
+        .get();
+    if (!latest)
+        return noRuns();
+    const rows = deps.store
+        .prepare("SELECT arm, k, precision_at_k, recall_at_k, mrr FROM bench_runs WHERE corpus_digest = ? AND ran_at = ?")
+        .all(latest.corpus_digest, latest.ran_at);
+    return {
+        has_runs: true,
+        corpus_digest: latest.corpus_digest,
+        contract_digest: latest.contract_digest,
+        package_version: latest.package_version,
+        runtime: latest.runtime,
+        ran_at: latest.ran_at,
+        arms: rows.map((r) => ({
+            arm: r.arm,
+            k: r.k,
+            precision_at_k: r.precision_at_k,
+            recall_at_k: r.recall_at_k,
+            mrr: r.mrr,
+        })),
+    };
+}

package/dist/plugin/kevin_conflicts.js

@@ -48,4 +48,3 @@ export function executeKevinConflicts(deps, action, id, keep, requestedStatus) {
         conflicts: rows,
     };
 }
-//# sourceMappingURL=kevin_conflicts.js.map

package/dist/plugin/kevin_contract.d.ts

@@ -0,0 +1,8 @@
+export interface KevinContractDeps {
+    packageVersion: string;
+}
+export interface KevinContractArgs {
+    clause?: string;
+    format?: "summary" | "full";
+}
+export declare function buildKevinContract(deps: KevinContractDeps, args: KevinContractArgs): Record<string, unknown>;

package/dist/plugin/kevin_contract.js

@@ -0,0 +1,59 @@
+/**
+ * K10-018 — kevin_contract: the frozen surface, inspectable at runtime.
+ *
+ * Read-only. Returns the live contract with its digest and per-clause
+ * stability/since/deprecation; with `clause`, one clause's full value.
+ * No filesystem paths, no project ids, no LLM, no network.
+ */
+import { contractDigest, describeContract, } from "./contract.js";
+export function buildKevinContract(deps, args) {
+    const contract = describeContract();
+    const digest = contractDigest(contract);
+    const format = args.format ?? "summary";
+    if (args.clause !== undefined) {
+        const clause = contract.clauses.find((c) => c.id === args.clause);
+        if (!clause) {
+            return {
+                error: "unknown_clause",
+                clause: args.clause,
+                known_clauses: contract.clauses.map((c) => c.id),
+            };
+        }
+        return {
+            contract_version: contract.contractVersion,
+            digest,
+            package_version: deps.packageVersion,
+            clause: {
+                id: clause.id,
+                title: clause.title,
+                stability: clause.stability,
+                since: clause.since,
+                ...(clause.deprecated ? { deprecated: clause.deprecated } : {}),
+                ...(clause.replacement ? { replacement: clause.replacement } : {}),
+                value: clause.value,
+            },
+        };
+    }
+    if (format === "full") {
+        return {
+            contract_version: contract.contractVersion,
+            digest,
+            package_version: deps.packageVersion,
+            clauses: contract.clauses,
+            deprecated: contract.clauses.filter((c) => c.deprecated).map((c) => c.id),
+        };
+    }
+    return {
+        contract_version: contract.contractVersion,
+        digest,
+        package_version: deps.packageVersion,
+        clauses: contract.clauses.map((c) => ({
+            id: c.id,
+            title: c.title,
+            stability: c.stability,
+            since: c.since,
+            ...(c.deprecated ? { deprecated: c.deprecated } : {}),
+        })),
+        deprecated: contract.clauses.filter((c) => c.deprecated).map((c) => c.id),
+    };
+}

package/dist/plugin/kevin_doctor.d.ts

@@ -36,6 +36,11 @@ export interface DoctorReport {
             readonly reference: boolean;
         };
     };
+    /** v1.0.0 (K10-021) — scopes whose most recent sample exceeded their
+     * p95 budget. Omitted entirely on pre-011 databases (no table). */
+    readonly perf?: {
+        readonly scopes_over_budget: readonly string[];
+    };
     readonly verdict: "healthy" | "degraded" | "unknown";
     readonly reason: string;
     readonly partial: boolean;

package/dist/plugin/kevin_doctor.js

@@ -106,6 +106,22 @@ export function countZodCopies(cwd) {
         return { copies: null, note: "zod resolution walk failed" };
     }
 }
+/** v1.0.0 (K10-021) — scopes whose most recent perf sample breached the
+ * p95 budget. The within_budget flag is materialized by Perf.flush()
+ * against the frozen BUDGETS; this block reads that persisted verdict
+ * and never re-aggregates. A missing table (pre-011 DB) yields no
+ * block rather than an empty one, matching the hooks precedent. */
+function perfOverBudget(store) {
+    try {
+        const rows = store
+            .prepare("SELECT DISTINCT scope FROM perf_samples WHERE within_budget = 0 ORDER BY scope")
+            .all();
+        return rows.map((r) => r.scope);
+    }
+    catch {
+        return null;
+    }
+}
 function lastRegistration(store, surface) {
     try {
         const row = store
@@ -124,7 +140,7 @@ export function buildDoctor(store, host, settings, options = {}) {
     // construction — kevin_doctor never re-probes (K9-004: probe once,
     // freeze, reuse).
     const hooks = hooksBlock(store);
-    const verdict = reduceVerdict(hooks.hooks.map((h) => ({
+    let verdict = reduceVerdict(hooks.hooks.map((h) => ({
         hook: h.hook,
         experimental: h.experimental,
         state: h.state,
@@ -134,6 +150,18 @@ export function buildDoctor(store, host, settings, options = {}) {
         expectedCount: h.expected_count,
         deadSince: h.since ?? null,
     })));
+    // v1.0.0 (K10-021) — a slow plugin is not healthy even when every
+    // hook is live. A budget breach degrades the verdict and names the
+    // scope; a dead hook keeps its reason; `unknown` is never rounded up.
+    const breaches = perfOverBudget(store);
+    if (breaches !== null &&
+        breaches.length > 0 &&
+        verdict.verdict !== "degraded") {
+        verdict = {
+            verdict: "degraded",
+            reason: `perf budget exceeded: ${breaches.join(", ")}`,
+        };
+    }
     const zod = countZodCopies(options.zodRoot ?? process.cwd());
     const enabled = settings.getSetting("native_registration_enabled", "0") === "1";
     return {
@@ -162,7 +190,7 @@ export function buildDoctor(store, host, settings, options = {}) {
         },
         verdict: verdict.verdict,
         reason: verdict.reason,
+        ...(breaches !== null ? { perf: { scopes_over_budget: breaches } } : {}),
         partial: hooks.partial,
     };
 }
-//# sourceMappingURL=kevin_doctor.js.map

package/dist/plugin/kevin_facts.js

@@ -34,4 +34,3 @@ export function buildKevinFacts(deps, refresh) {
         penalized,
     };
 }
-//# sourceMappingURL=kevin_facts.js.map

package/dist/plugin/kevin_forget.d.ts

@@ -0,0 +1,33 @@
+import type { MemoryService } from "./MemoryService.js";
+import type { SharedLayer } from "./SharedLayer.js";
+import type { Store } from "./Store.js";
+import type { Metrics } from "./metrics.js";
+export interface ForgetInput {
+    ids: string[];
+    confirm?: boolean;
+}
+export interface Deps {
+    store: Store;
+    memoryService: MemoryService;
+    sharedLayer: SharedLayer;
+    okfPath: string;
+    metrics: Metrics;
+}
+export interface ForgetResult {
+    action: "forget";
+    ok: boolean;
+    dry_run: boolean;
+    per_id: Array<{
+        id: string;
+        archived: boolean;
+        reason?: string;
+        tombstone?: {
+            entry_id: string;
+            planned: boolean;
+            applied: boolean;
+        };
+    }>;
+    noop?: boolean;
+    reason?: string;
+}
+export declare function handleForget(input: ForgetInput, deps: Deps): ForgetResult;

package/dist/plugin/kevin_forget.js

@@ -0,0 +1,260 @@
+import { computeEntryId } from "./okf.js";
+export function handleForget(input, deps) {
+    // v1.1.0 — every invocation counts, including dry runs and refusals (K11-005)
+    try {
+        deps.metrics.incr("forget_requests_total", 1);
+    }
+    catch {
+        // best-effort
+    }
+    if (!input.ids || input.ids.length === 0) {
+        return {
+            action: "forget",
+            ok: false,
+            dry_run: input.confirm !== true,
+            per_id: [],
+            reason: "no_ids",
+        };
+    }
+    const isDry = input.confirm !== true;
+    const per_id = [];
+    let anyChange = false;
+    let anyTombstonePlanned = false;
+    // Helper to compute entry_id for a memory row
+    const getEntryId = (row) => {
+        if (row.shared_entry_id)
+            return row.shared_entry_id;
+        return computeEntryId(row.type, row.content, row.scope);
+    };
+    // For dry_run: just plan, mutate nothing
+    if (isDry) {
+        for (const id of input.ids) {
+            const row = deps.store
+                .prepare("SELECT id, type, content, scope, status, layer, shared_entry_id FROM memories WHERE id = ?")
+                .get(id);
+            if (!row) {
+                per_id.push({ id, archived: false, reason: "not_found" });
+                continue;
+            }
+            if (row.status === "archived") {
+                // Idempotence: already archived
+                const isShared = row.layer === "shared" || row.shared_entry_id !== null;
+                if (isShared) {
+                    const entryId = getEntryId(row);
+                    try {
+                        const plan = deps.sharedLayer.planTombstone([entryId], deps.okfPath);
+                        const planned = plan.write.outcome !== "refused" && plan.entriesAdded > 0;
+                        // Already archived implies tombstone already applied, so planned should be false (noop)
+                        per_id.push({
+                            id,
+                            archived: false,
+                            reason: "already_archived",
+                            tombstone: { entry_id: entryId, planned: false, applied: false },
+                        });
+                        void plan;
+                        void planned;
+                    }
+                    catch {
+                        per_id.push({
+                            id,
+                            archived: false,
+                            reason: "already_archived",
+                            tombstone: { entry_id: entryId, planned: false, applied: false },
+                        });
+                    }
+                }
+                else {
+                    per_id.push({ id, archived: false, reason: "already_archived" });
+                }
+                continue;
+            }
+            // Would archive
+            anyChange = true;
+            const isShared = row.layer === "shared" || row.shared_entry_id !== null;
+            if (isShared) {
+                const entryId = getEntryId(row);
+                let planned = false;
+                try {
+                    const plan = deps.sharedLayer.planTombstone([entryId], deps.okfPath);
+                    // planTombstone returns ExportPlan with write outcome; if refused, planned false
+                    planned = plan.write.outcome !== "refused";
+                    anyTombstonePlanned = anyTombstonePlanned || planned;
+                    per_id.push({
+                        id,
+                        archived: true,
+                        tombstone: { entry_id: entryId, planned, applied: false },
+                    });
+                }
+                catch {
+                    per_id.push({
+                        id,
+                        archived: true,
+                        tombstone: { entry_id: entryId, planned: false, applied: false },
+                    });
+                }
+            }
+            else {
+                per_id.push({ id, archived: true });
+            }
+        }
+        const noop = !anyChange;
+        return {
+            action: "forget",
+            ok: true,
+            dry_run: true,
+            per_id,
+            ...(noop ? { noop: true } : {}),
+        };
+    }
+    // Apply mode: confirm === true
+    // We need to archive locally and publish tombstones through applyExport
+    let partial = false;
+    let appliedTombstones = 0;
+    for (const id of input.ids) {
+        const row = deps.store
+            .prepare("SELECT id, type, content, scope, status, layer, shared_entry_id FROM memories WHERE id = ?")
+            .get(id);
+        if (!row) {
+            per_id.push({ id, archived: false, reason: "not_found" });
+            continue;
+        }
+        if (row.status === "archived") {
+            const isShared = row.layer === "shared" || row.shared_entry_id !== null;
+            if (isShared) {
+                const entryId = getEntryId(row);
+                per_id.push({
+                    id,
+                    archived: false,
+                    reason: "already_archived",
+                    tombstone: { entry_id: entryId, planned: false, applied: false },
+                });
+            }
+            else {
+                per_id.push({ id, archived: false, reason: "already_archived" });
+            }
+            continue;
+        }
+        // Archive locally in a transaction
+        let archived = false;
+        try {
+            deps.store.transaction(() => {
+                deps.store
+                    .prepare(`UPDATE memories SET status = 'archived', archived_at = datetime('now'), updated_at = datetime('now') WHERE id = ? AND status != 'archived'`)
+                    .run(id);
+                const changes = deps.store.prepare("SELECT changes() AS c").get();
+                if (changes.c > 0)
+                    archived = true;
+            });
+        }
+        catch (e) {
+            per_id.push({ id, archived: false, reason: "db_error" });
+            partial = true;
+            continue;
+        }
+        anyChange = anyChange || archived;
+        const isShared = row.layer === "shared" || row.shared_entry_id !== null;
+        if (!isShared) {
+            per_id.push({ id, archived });
+            continue;
+        }
+        const entryId = getEntryId(row);
+        // Plan tombstone
+        let plan;
+        try {
+            plan = deps.sharedLayer.planTombstone([entryId], deps.okfPath);
+        }
+        catch (e) {
+            // plan failure: rollback DB archive for this id (best-effort)
+            try {
+                deps.store
+                    .prepare(`UPDATE memories SET status = 'active', archived_at = NULL WHERE id = ?`)
+                    .run(id);
+            }
+            catch { }
+            per_id.push({
+                id,
+                archived: false,
+                reason: "plan_failed",
+                tombstone: { entry_id: entryId, planned: false, applied: false },
+            });
+            partial = true;
+            continue;
+        }
+        if (plan.write.outcome === "refused") {
+            // Refusal reasons are reused verbatim (repo_mismatch, unknown_entry)
+            const reason = plan.write.reason ?? "refused";
+            per_id.push({
+                id,
+                archived,
+                reason,
+                tombstone: { entry_id: entryId, planned: false, applied: false },
+            });
+            // DB archive already done; keep it (local archive is independent of shared refusal)
+            continue;
+        }
+        // Apply through single write funnel
+        try {
+            const applied = deps.sharedLayer.applyExport(plan);
+            const wasWritten = applied.applied === "written";
+            const wasNoop = applied.applied === "noop";
+            if (wasWritten)
+                appliedTombstones++;
+            // per_id tombstone: planned true if not refused, applied true only if written
+            per_id.push({
+                id,
+                archived,
+                tombstone: {
+                    entry_id: entryId,
+                    planned: true,
+                    applied: wasWritten,
+                },
+            });
+            void wasNoop;
+        }
+        catch (e) {
+            // v1.1.0 — failure mid-way: transaction rollback restores DB; already-applied OKF write is reported honestly
+            // For this id, DB was already archived, but file write failed. We attempt to rollback DB for this id.
+            try {
+                deps.store
+                    .prepare(`UPDATE memories SET status = 'active', archived_at = NULL WHERE id = ?`)
+                    .run(id);
+                archived = false;
+            }
+            catch { }
+            per_id.push({
+                id,
+                archived: false,
+                reason: "partial",
+                tombstone: { entry_id: entryId, planned: true, applied: false },
+            });
+            partial = true;
+            // Continue to next id? According spec, failure mid-way reports ok:false reason partial
+            // We keep processing remaining ids? For now we continue but mark partial.
+        }
+    }
+    // Metrics: increment forget_tombstones_published by applied count (only when written, not noop)
+    if (appliedTombstones > 0) {
+        try {
+            deps.metrics.incr("forget_tombstones_published", appliedTombstones);
+        }
+        catch { }
+    }
+    const noop = !anyChange && per_id.every((p) => p.archived === false);
+    if (partial) {
+        return {
+            action: "forget",
+            ok: false,
+            dry_run: false,
+            per_id,
+            reason: "partial",
+            ...(noop ? { noop: true } : {}),
+        };
+    }
+    return {
+        action: "forget",
+        ok: true,
+        dry_run: false,
+        per_id,
+        ...(noop ? { noop: true } : {}),
+    };
+}

package/dist/plugin/kevin_native.js

@@ -77,4 +77,3 @@ export function handleNative(action, deps) {
     };
     return report;
 }
-//# sourceMappingURL=kevin_native.js.map

package/dist/plugin/kevin_propose.js

@@ -12,4 +12,3 @@ export function kevinPropose(curator, writer, kind) {
         })),
     };
 }
-//# sourceMappingURL=kevin_propose.js.map