@jmtrin/opencode-kevin 0.8.0 → 1.0.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

@@ -93,6 +93,66 @@ export interface AuditReport {
         precision_local?: number;
         reason?: "immature_db";
     };
+    /**
+     * v0.9.0 (K9-020 / plan §5.5) — the host block, alongside the v0.7.0
+     * `mix` and v0.8.0 `team` blocks. Pure SQL: hook states in aggregate
+     * (live/dead/unknown counts, fires and errors totals), the resolved
+     * plugin version, native registration outcomes per surface, and the
+     * verdict derivable from the database alone. On a pre-010 database
+     * the block is omitted (not zero-valued) and `"partial": true` set,
+     * following the channels/curation precedent.
+     */
+    host?: {
+        plugin_version: string | null;
+        hooks: {
+            live: number;
+            dead: number;
+            unknown: number;
+            fires_total: number;
+            errors_total: number;
+        };
+        native: {
+            total: number;
+            verified: number;
+            failures: number;
+            by_surface: Record<string, {
+                registered: number;
+                verified: number;
+            }>;
+        };
+        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,
@@ -401,6 +403,145 @@ export function buildAudit(store, metrics, capabilities = ALL_FALSE_CAPABILITIES
     catch {
         partial = true;
     }
+    // v0.9.0 (K9-020 / plan §5.5) — the host block, mirroring the
+    // channels/curation precedent: gated on migration 010's schema, pure
+    // SQL, omitted (not zero-valued) on a pre-010 database with
+    // `partial` set. The verdict is derived entirely in SQL: degraded
+    // when any hook is dead, unknown when no hook has been observed at
+    // all (never rounded to healthy), healthy otherwise.
+    let host;
+    let hasSchema010 = false;
+    try {
+        const row = store
+            .prepare("SELECT 1 AS n FROM sqlite_master WHERE type='table' AND name='hook_liveness'")
+            .get();
+        hasSchema010 = !!row;
+    }
+    catch {
+        hasSchema010 = false;
+    }
+    if (hasSchema010) {
+        try {
+            const hookRow = store
+                .prepare(`SELECT
+					 COUNT(*) AS total,
+					 SUM(CASE WHEN dead_since IS NOT NULL THEN 1 ELSE 0 END) AS dead,
+					 SUM(CASE WHEN fire_count > 0 THEN 1 ELSE 0 END) AS live,
+					 SUM(fire_count) AS fires_total,
+					 SUM(error_count) AS errors_total
+					 FROM hook_liveness`)
+                .get();
+            const dead = hookRow.dead ?? 0;
+            const live = hookRow.live ?? 0;
+            const unknown = hookRow.total - dead - live;
+            const versionRow = store
+                .prepare(`SELECT plugin_version FROM host_probes
+					 ORDER BY probed_at DESC, id DESC LIMIT 1`)
+                .get();
+            const regRows = store
+                .prepare(`SELECT surface, registered, verified, COUNT(*) AS n
+					 FROM native_registrations
+					 GROUP BY surface, registered, verified`)
+                .all();
+            const bySurface = {};
+            let total = 0;
+            let verified = 0;
+            let failures = 0;
+            for (const row of regRows) {
+                total += row.n;
+                if (row.verified === 1)
+                    verified += row.n;
+                if (row.registered === 1 && row.verified === 0)
+                    failures += row.n;
+                const acc = bySurface[row.surface] ?? { registered: 0, verified: 0 };
+                acc.registered += row.registered === 1 ? row.n : 0;
+                acc.verified += row.verified === 1 ? row.n : 0;
+                bySurface[row.surface] = acc;
+            }
+            host = {
+                plugin_version: versionRow?.plugin_version ?? null,
+                hooks: {
+                    live,
+                    dead,
+                    unknown: unknown < 0 ? 0 : unknown,
+                    fires_total: hookRow.fires_total ?? 0,
+                    errors_total: hookRow.errors_total ?? 0,
+                },
+                native: { total, verified, failures, by_surface: bySurface },
+                verdict: dead > 0
+                    ? "degraded"
+                    : hookRow.total === 0
+                        ? "unknown"
+                        : unknown > 0
+                            ? "unknown"
+                            : "healthy",
+            };
+        }
+        catch {
+            partial = true;
+            host = undefined;
+        }
+    }
+    // v0.9.0 (K9-020): pre-010 databases simply omit `host` without
+    // 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,
@@ -414,7 +555,9 @@ export function buildAudit(store, metrics, capabilities = ALL_FALSE_CAPABILITIES
         channels,
         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

@@ -0,0 +1,62 @@
+import type { Store } from "./Store.js";
+import type { HostSurface } from "./host.js";
+import type { SettingsReader } from "./native.js";
+export interface DoctorHook {
+    readonly hook: string;
+    readonly experimental: boolean;
+    readonly state: "live" | "dead" | "unknown";
+    readonly fire_count: number;
+    readonly expected_count: number;
+    readonly since?: string;
+}
+export interface DoctorReport {
+    readonly host: {
+        readonly plugin_version: string | null;
+        readonly flavour: string;
+        readonly shell_available: boolean;
+        readonly v2: {
+            readonly skill: boolean;
+            readonly reference: boolean;
+        };
+    };
+    readonly hooks: DoctorHook[];
+    readonly dependencies: {
+        readonly declared: string[];
+        readonly zod_copies: number | null;
+        readonly note?: string;
+    };
+    readonly native: {
+        readonly enabled: boolean;
+        readonly registered: {
+            readonly skill: boolean;
+            readonly reference: boolean;
+        };
+        readonly verified: {
+            readonly skill: boolean;
+            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;
+}
+/**
+ * Count resolved zod copies under `cwd`'s dependency tree. The expected
+ * value after K9-005 is 1; a second copy is exactly the regression this
+ * field exists to catch. On any walk failure the count is `null` and the
+ * note says so — never a guess.
+ */
+export declare function countZodCopies(cwd: string): {
+    copies: number | null;
+    note?: string;
+};
+export interface DoctorOptions {
+    /** Directory to walk for zod copies; defaults to process.cwd(). */
+    readonly zodRoot?: string;
+}
+export declare function buildDoctor(store: Store, host: HostSurface, settings: SettingsReader, options?: DoctorOptions): DoctorReport;

package/dist/plugin/kevin_doctor.js

@@ -0,0 +1,196 @@
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { reduceVerdict, } from "./HookLiveness.js";
+import { HOOK_NAMES } from "./Migrate.js";
+/** Dead first, then unknown, then live — the failure is the first thing
+ * on screen. Ties break on the canonical hook name. */
+const STATE_ORDER = {
+    dead: 0,
+    unknown: 1,
+    live: 2,
+};
+/** The hooks block is pure SQL over the persisted hook_liveness table:
+ * the dead flag is materialized at expect() time (K9-010) so flush() can
+ * persist dead_since even when report() never runs — this block reads
+ * that persisted state, independent of any live HookLiveness object. */
+function hooksBlock(store) {
+    let rows = [];
+    try {
+        rows = store
+            .prepare("SELECT hook, experimental, fire_count, expected_count, dead_since FROM hook_liveness")
+            .all();
+    }
+    catch {
+        return { hooks: [], partial: true };
+    }
+    // Only hooks the plugin knows about are reported; a foreign row (from
+    // a future release) is skipped, mirroring HookLiveness.loadFromDb.
+    const reports = rows
+        .filter((row) => HOOK_NAMES.includes(row.hook))
+        .map((row) => ({
+        hook: row.hook,
+        experimental: row.experimental === 1,
+        state: row.fire_count > 0
+            ? "live"
+            : row.dead_since !== null
+                ? "dead"
+                : "unknown",
+        firstSeenAt: null,
+        lastSeenAt: null,
+        fireCount: row.fire_count,
+        expectedCount: row.expected_count,
+        deadSince: row.dead_since,
+    }));
+    reports.sort((a, b) => STATE_ORDER[a.state] - STATE_ORDER[b.state] ||
+        a.hook.localeCompare(b.hook));
+    const hooks = reports.map((r) => ({
+        hook: r.hook,
+        experimental: r.experimental,
+        state: r.state,
+        fire_count: r.fireCount,
+        expected_count: r.expectedCount,
+        ...(r.deadSince !== null ? { since: r.deadSince } : {}),
+    }));
+    return { hooks, partial: false };
+}
+/**
+ * Count resolved zod copies under `cwd`'s dependency tree. The expected
+ * value after K9-005 is 1; a second copy is exactly the regression this
+ * field exists to catch. On any walk failure the count is `null` and the
+ * note says so — never a guess.
+ */
+export function countZodCopies(cwd) {
+    try {
+        if (!existsSync(cwd)) {
+            return { copies: null, note: "zod resolution walk failed" };
+        }
+        const seen = new Set();
+        const stack = [cwd];
+        let copies = 0;
+        // Bounded walk: node_modules is normally shallow; nested copies
+        // (node_modules/<pkg>/node_modules/zod) sit within a few levels.
+        for (let depth = 0; stack.length > 0 && depth < 8; depth += 1) {
+            const next = [];
+            for (const dir of stack) {
+                const nm = join(dir, "node_modules");
+                if (!existsSync(nm))
+                    continue;
+                let entries;
+                try {
+                    entries = readdirSync(nm, { withFileTypes: true });
+                }
+                catch {
+                    continue;
+                }
+                for (const entry of entries) {
+                    if (!entry.isDirectory())
+                        continue;
+                    if (entry.name === "zod") {
+                        const pkg = join(nm, "zod", "package.json");
+                        if (existsSync(pkg) && !seen.has(pkg)) {
+                            seen.add(pkg);
+                            copies += 1;
+                        }
+                    }
+                    else if (entry.name !== ".bin" && entry.name !== ".cache") {
+                        next.push(join(nm, entry.name));
+                    }
+                }
+            }
+            stack.length = 0;
+            stack.push(...next);
+        }
+        return { copies };
+    }
+    catch {
+        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
+            .prepare("SELECT surface, registered, verified FROM native_registrations WHERE surface = ? ORDER BY attached_at DESC, id DESC LIMIT 1")
+            .get(surface);
+        if (!row)
+            return { registered: false, verified: false };
+        return { registered: row.registered === 1, verified: row.verified === 1 };
+    }
+    catch {
+        return { registered: false, verified: false };
+    }
+}
+export function buildDoctor(store, host, settings, options = {}) {
+    // The host block comes from the frozen probe result captured at
+    // construction — kevin_doctor never re-probes (K9-004: probe once,
+    // freeze, reuse).
+    const hooks = hooksBlock(store);
+    let verdict = reduceVerdict(hooks.hooks.map((h) => ({
+        hook: h.hook,
+        experimental: h.experimental,
+        state: h.state,
+        firstSeenAt: null,
+        lastSeenAt: null,
+        fireCount: h.fire_count,
+        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 {
+        host: {
+            plugin_version: host.pluginVersion,
+            flavour: host.flavour,
+            shell_available: host.hasShell,
+            v2: { skill: host.v2.skill, reference: host.v2.reference },
+        },
+        hooks: hooks.hooks,
+        dependencies: {
+            declared: ["@opencode-ai/plugin"],
+            zod_copies: zod.copies,
+            ...(zod.note !== undefined ? { note: zod.note } : {}),
+        },
+        native: {
+            enabled,
+            registered: {
+                skill: lastRegistration(store, "skill").registered,
+                reference: lastRegistration(store, "reference").registered,
+            },
+            verified: {
+                skill: lastRegistration(store, "skill").verified,
+                reference: lastRegistration(store, "reference").verified,
+            },
+        },
+        verdict: verdict.verdict,
+        reason: verdict.reason,
+        ...(breaches !== null ? { perf: { scopes_over_budget: breaches } } : {}),
+        partial: hooks.partial,
+    };
+}

package/dist/plugin/kevin_facts.js

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