@jmtrin/opencode-kevin 0.9.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

@@ -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_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

package/dist/plugin/kevin_publish.js

@@ -16,4 +16,3 @@ export function kevinPublish(deps) {
         },
     };
 }
-//# sourceMappingURL=kevin_publish.js.map

package/dist/plugin/kevin_why.js

@@ -126,4 +126,3 @@ export function kevinWhy(store, query) {
         related_rules: relatedRules,
     };
 }
-//# sourceMappingURL=kevin_why.js.map

package/dist/plugin/memory-format.js

@@ -57,4 +57,3 @@ export function formatMemorySnippets(memories, tag) {
         return "";
     return wrapBlock(memories.map(formatSnippet).join("\n"), tag);
 }
-//# sourceMappingURL=memory-format.js.map

package/dist/plugin/metrics.js

@@ -278,4 +278,3 @@ export class Metrics {
         }
     }
 }
-//# sourceMappingURL=metrics.js.map

package/dist/plugin/native.js

@@ -188,4 +188,3 @@ function bumpNativeCounter(store, key) {
 			   updated_at = datetime('now')`)
         .run(key);
 }
-//# sourceMappingURL=native.js.map

package/dist/plugin/okf-export.js

@@ -132,4 +132,3 @@ export function exportMarkdown(store, projectId = null) {
     }
     return lines.join("\n");
 }
-//# sourceMappingURL=okf-export.js.map

package/dist/plugin/okf-import.js

@@ -269,4 +269,3 @@ export function importOkf(bundle, memoryService) {
     }
     return { imported, superseded };
 }
-//# sourceMappingURL=okf-import.js.map

package/dist/plugin/okf.js

@@ -301,4 +301,3 @@ export function parse(text) {
 export function computeEntryId(type, statement, scope) {
     return fnv1a64(`okf:v2\u0000${type}\u0000${statement}\u0000${scope ?? ""}`);
 }
-//# sourceMappingURL=okf.js.map

package/dist/plugin/perf.d.ts

@@ -0,0 +1,35 @@
+import type { Store } from "./Store.js";
+export type PerfScope = "tool.execute.before" | "tool.execute.after" | "chat.message" | "chat.system.transform" | "session.compacting" | "event" | "session.idle" | "dispose";
+export interface Budget {
+    readonly scope: PerfScope;
+    readonly p95Ms: number;
+    readonly maxMs: number;
+}
+export declare const BUDGETS: readonly Budget[];
+export interface PerfStat {
+    readonly scope: PerfScope;
+    readonly count: number;
+    readonly p50: number;
+    readonly p95: number;
+    readonly max: number;
+    readonly budget: Budget;
+    readonly withinBudget: boolean;
+}
+export declare class Perf {
+    private readonly enabled;
+    private readonly capacity;
+    private readonly rings;
+    private readonly cursors;
+    private readonly counts;
+    constructor(opts: {
+        enabled: boolean;
+        capacity?: number | string;
+    });
+    static fromSettings(settings: Record<string, string | null | undefined>): Perf;
+    measure<T>(scope: PerfScope, fn: () => T): T;
+    measureAsync<T>(scope: PerfScope, fn: () => Promise<T>): Promise<T>;
+    private record;
+    stats(): readonly PerfStat[];
+    flush(store: Store): void;
+    reset(): void;
+}

package/dist/plugin/perf.js

@@ -0,0 +1,174 @@
+export const BUDGETS = [
+    { scope: "tool.execute.before", p95Ms: 2, maxMs: 10 },
+    { scope: "tool.execute.after", p95Ms: 5, maxMs: 25 },
+    { scope: "chat.message", p95Ms: 2, maxMs: 10 },
+    { scope: "chat.system.transform", p95Ms: 15, maxMs: 50 },
+    { scope: "session.compacting", p95Ms: 15, maxMs: 50 },
+    { scope: "event", p95Ms: 5, maxMs: 25 },
+    { scope: "session.idle", p95Ms: 150, maxMs: 600 },
+    { scope: "dispose", p95Ms: 50, maxMs: 250 },
+];
+function clampCapacity(raw) {
+    if (raw === null || raw === undefined || raw === "")
+        return 512;
+    const n = Number.parseInt(raw, 10);
+    if (Number.isNaN(n))
+        return 512;
+    return Math.min(8192, Math.max(64, n));
+}
+export class Perf {
+    enabled;
+    capacity;
+    rings;
+    cursors;
+    counts;
+    constructor(opts) {
+        this.enabled = opts.enabled;
+        if (typeof opts.capacity === "string") {
+            this.capacity = clampCapacity(opts.capacity);
+        }
+        else if (typeof opts.capacity === "number") {
+            this.capacity = Math.min(8192, Math.max(64, Math.floor(opts.capacity)));
+        }
+        else {
+            this.capacity = 512;
+        }
+        this.rings = new Map();
+        this.cursors = new Map();
+        this.counts = new Map();
+        const scopes = BUDGETS.map((b) => b.scope);
+        for (const s of scopes) {
+            this.rings.set(s, new Float64Array(this.capacity));
+            this.cursors.set(s, 0);
+            this.counts.set(s, 0);
+        }
+    }
+    static fromSettings(settings) {
+        const enabled = settings.perf_enabled === "1";
+        const cap = clampCapacity(settings.perf_ring_capacity);
+        return new Perf({ enabled, capacity: cap });
+    }
+    measure(scope, fn) {
+        if (!this.enabled)
+            return fn();
+        const start = performance.now();
+        try {
+            return fn();
+        }
+        finally {
+            const dur = performance.now() - start;
+            this.record(scope, dur);
+        }
+    }
+    async measureAsync(scope, fn) {
+        if (!this.enabled)
+            return fn();
+        const start = performance.now();
+        try {
+            return await fn();
+        }
+        finally {
+            const dur = performance.now() - start;
+            this.record(scope, dur);
+        }
+    }
+    record(scope, ms) {
+        const ring = this.rings.get(scope);
+        if (!ring)
+            return;
+        const cur = this.cursors.get(scope) ?? 0;
+        ring[cur % this.capacity] = ms;
+        this.cursors.set(scope, (cur + 1) % this.capacity);
+        this.counts.set(scope, (this.counts.get(scope) ?? 0) + 1);
+    }
+    stats() {
+        const out = [];
+        for (const b of BUDGETS) {
+            const ring = this.rings.get(b.scope);
+            if (!ring)
+                continue;
+            const count = this.counts.get(b.scope) ?? 0;
+            if (count === 0) {
+                out.push({
+                    scope: b.scope,
+                    count: 0,
+                    p50: 0,
+                    p95: 0,
+                    max: 0,
+                    budget: b,
+                    withinBudget: true,
+                });
+                continue;
+            }
+            const n = Math.min(count, this.capacity);
+            // Copy live samples: need to reconstruct in insertion order but for percentiles order doesn't matter.
+            // Take last n entries from ring (wrap-aware).
+            const samples = [];
+            const cur = this.cursors.get(b.scope) ?? 0;
+            // If count < capacity, samples are ring[0..count-1]; else ring[0..capacity-1] all valid but order is cur..cur+cap
+            if (count < this.capacity) {
+                for (let i = 0; i < count; i++)
+                    samples.push(ring[i]);
+            }
+            else {
+                for (let i = 0; i < this.capacity; i++)
+                    samples.push(ring[i]);
+            }
+            const sorted = [...samples].sort((a, b) => a - b);
+            // Percentile method: nearest-rank — p is the value at index ceil(p/100 * n) - 1
+            // of the ascending-sorted copy. Stated here so an implementer comparing against
+            // another percentile definition can see which one was chosen.
+            const p50 = sorted[Math.max(0, Math.ceil(sorted.length * 0.5) - 1)];
+            const p95 = sorted[Math.max(0, Math.ceil(sorted.length * 0.95) - 1)];
+            const max = sorted[sorted.length - 1];
+            out.push({
+                scope: b.scope,
+                count,
+                p50,
+                p95,
+                max,
+                budget: b,
+                withinBudget: p95 <= b.p95Ms,
+            });
+        }
+        return out;
+    }
+    flush(store) {
+        if (!this.enabled)
+            return;
+        const stats = this.stats();
+        let recorded = 0;
+        let breaches = 0;
+        for (const s of stats) {
+            if (s.count === 0)
+                continue;
+            store
+                .prepare("INSERT INTO perf_samples (scope, sample_count, p50_ms, p95_ms, max_ms, budget_p95_ms, within_budget) VALUES (?, ?, ?, ?, ?, ?, ?)")
+                .run(s.scope, s.count, s.p50, s.p95, s.max, s.budget.p95Ms, s.withinBudget ? 1 : 0);
+            recorded++;
+            if (!s.withinBudget)
+                breaches++;
+        }
+        if (recorded > 0) {
+            store
+                .prepare(`UPDATE kevin_metrics SET value = value + ? WHERE key = 'perf_samples_recorded'`)
+                .run(recorded);
+        }
+        if (breaches > 0) {
+            store
+                .prepare(`UPDATE kevin_metrics SET value = value + ? WHERE key = 'perf_budget_breaches'`)
+                .run(breaches);
+        }
+        this.reset();
+    }
+    reset() {
+        for (const b of BUDGETS) {
+            // Zero the ring too: cursors and counts alone would let the next
+            // period's stats() read stale pre-reset samples whenever
+            // count < capacity (review fix, v1.0.0).
+            this.rings.get(b.scope)?.fill(0);
+            this.cursors.set(b.scope, 0);
+            this.counts.set(b.scope, 0);
+        }
+    }
+}

package/dist/plugin/query-tokenizer.js

@@ -83,4 +83,3 @@ export function quoteToken(token) {
 export function toMatchClause(tokens, separator) {
     return tokens.map(quoteToken).join(separator);
 }
-//# sourceMappingURL=query-tokenizer.js.map

package/dist/plugin/redact.js

@@ -16,4 +16,3 @@ export function stripPrivate(text) {
         return `<private: redacted ${n} chars>`;
     });
 }
-//# sourceMappingURL=redact.js.map

package/dist/plugin/replay-types.js

@@ -154,4 +154,3 @@ function toSchema(parse) {
 }
 export const replayEventSchema = toSchema(parseEvent);
 export const replayTranscriptSchema = toSchema(parseTranscript);
-//# sourceMappingURL=replay-types.js.map

package/dist/plugin/replay.js

@@ -200,4 +200,3 @@ function totalMemories(store) {
     const row = store.prepare("SELECT COUNT(*) AS n FROM memories").get();
     return row.n ?? 0;
 }
-//# sourceMappingURL=replay.js.map