@jmtrin/opencode-kevin 0.8.0 → 1.0.0

package/dist/plugin/kevin_native.d.ts

@@ -0,0 +1,29 @@
+import type { Store } from "./Store.js";
+import type { HostSurface } from "./host.js";
+import type { SettingsReader } from "./native.js";
+export type NativeAction = "show" | "enable" | "disable";
+export interface NativeRegistrationRow {
+    readonly surface: "skill" | "reference";
+    readonly registered: boolean;
+    readonly verified: boolean;
+    readonly attached_at: string | null;
+}
+export interface NativeReport {
+    readonly action: NativeAction;
+    /** The setting value: '1' or '0' as stored (TEXT). */
+    readonly value: "1" | "0";
+    /** Whether registration would be effective on THIS host (v2 subpath present). */
+    readonly effective: boolean;
+    /** Present when `effective` is false: why the intent is inert. */
+    readonly reason?: string;
+    /** The latest persisted outcome per surface (show only). */
+    readonly registrations?: NativeRegistrationRow[];
+    /** The restart note (enable/disable only). */
+    readonly note?: string;
+}
+export interface NativeDeps {
+    readonly host: HostSurface;
+    readonly store: Store;
+    readonly settings: SettingsReader;
+}
+export declare function handleNative(action: NativeAction, deps: NativeDeps): NativeReport;

package/dist/plugin/kevin_native.js

@@ -0,0 +1,79 @@
+// v0.9.0 (K9-019 / plan §5.5, D9-12) — `kevin_native`: inspect and toggle
+// `native_registration_enabled`.
+//
+// Pure in the sense that matters: `show` reads only; `enable`/`disable`
+// write `kevin_settings` and nothing else. Neither action re-attaches —
+// the probe is frozen for the process lifetime (D9-12) — and the response
+// says so explicitly, naming a restart as the requirement. `enable` on a
+// host without the v2 subpath succeeds and reports the registration as
+// inert: the setting is a statement of intent that becomes effective when
+// the host catches up, and refusing would make it untestable on the
+// majority of installations.
+//
+// The stored value is TEXT `'1'` or `'0'` — never a boolean, never
+// `'true'` (kevin_settings.value is TEXT; compare with `=== "1"`).
+function lastRows(store) {
+    try {
+        return store
+            .prepare(`SELECT surface, registered, verified, attached_at
+				 FROM native_registrations
+				 ORDER BY attached_at DESC, id DESC
+				 LIMIT 20`)
+            .all()
+            .map((row) => {
+            const r = row;
+            return {
+                surface: r.surface,
+                registered: r.registered === 1,
+                verified: r.verified === 1,
+                attached_at: r.attached_at,
+            };
+        });
+    }
+    catch {
+        // pre-010 database: the table does not exist yet — no rows to
+        // report, and that is the truth.
+        return [];
+    }
+}
+/** v0.9.0 (K9-019 / plan §5.5, D9-12) — the pure decision: the probe is
+ * frozen for the process lifetime, so "effective" is derived from the
+ * resolved host surface, never from a fresh probe call. */
+function effectiveOn(host) {
+    return host.v2.skill || host.v2.reference;
+}
+export function handleNative(action, deps) {
+    const current = deps.settings.getSetting("native_registration_enabled", "0");
+    const value = current === "1" ? "1" : "0";
+    if (action === "show") {
+        const report = {
+            action,
+            value,
+            effective: effectiveOn(deps.host),
+            registrations: lastRows(deps.store),
+            ...(effectiveOn(deps.host)
+                ? {}
+                : {
+                    reason: "v2 subpath absent from the resolved host package — registration would be inert",
+                }),
+        };
+        return report;
+    }
+    const next = action === "enable" ? "1" : "0";
+    deps.store
+        .prepare(`INSERT INTO kevin_settings (key, value) VALUES (?, ?)
+			 ON CONFLICT(key) DO UPDATE SET value = excluded.value`)
+        .run("native_registration_enabled", next);
+    const report = {
+        action,
+        value: next,
+        effective: effectiveOn(deps.host),
+        note: "the probe is frozen for the process lifetime — restart the host for the change to take effect",
+        ...(effectiveOn(deps.host)
+            ? {}
+            : {
+                reason: "v2 subpath absent from the resolved host package — registration would be inert",
+            }),
+    };
+    return report;
+}

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.d.ts

@@ -0,0 +1,92 @@
+import { type Materializer } from "./Materializer.js";
+import type { Store } from "./Store.js";
+import type { HostSurface } from "./host.js";
+/** The surface `attachNative()` returned. `verified` is filled by the
+ * read-back checks (K9-014/015) once the host ran `setup()`. */
+export interface NativeRegistration {
+    registered: {
+        skill: boolean;
+        reference: boolean;
+    };
+    verified: {
+        skill: boolean;
+        reference: boolean;
+    };
+    notes: string[];
+}
+/** Minimal settings reader — matches MemoryService.getSetting(key, fallback). */
+export interface SettingsReader {
+    getSetting(key: string, fallback?: string): string | null;
+}
+export interface NativeDeps {
+    materializer: Materializer;
+    settings: SettingsReader;
+    /**
+     * v0.9.0 (K9-014 / plan §5.4) — reports the outcome of each surface
+     * registration once the host ran `setup()`. `registered` reflects
+     * whether the transform completed; `verified` whether the read-back
+     * (`draft.list()`) contained the provided source. The host's own
+     * `setup()` runs asynchronously, so this callback may fire after
+     * `attachNative()` resolved.
+     */
+    onVerified?: (surface: "skill" | "reference", registered: boolean, verified: boolean) => void;
+    /**
+     * v0.9.0 (K9-017 / plan §6.2) — the persistence sink. When present,
+     * every surface outcome is appended to `native_registrations` and the
+     * two live counters are bumped. Attach time is construction, not a
+     * hot path, so a direct write is correct here and the
+     * `metrics.flush()` cadence does not apply.
+     */
+    store?: Store;
+}
+/** The only place in the repository allowed to name the v2 subpath. */
+export declare const V2_SPECIFIER = "@opencode-ai/plugin/v2/promise";
+/**
+ * Duck-typed mirror of the host's v2 PluginContext. The host's own
+ * compile-time types (dist/v2/promise/context.d.ts) are not importable
+ * here — a static type import would name the specifier outside a dynamic
+ * `import()` and break the containment scan.
+ */
+export interface KevinNativeContext {
+    readonly skill: {
+        transform(hook: (draft: unknown) => Promise<void> | void): Promise<void> | void;
+    };
+    readonly reference: {
+        transform(hook: (draft: unknown) => Promise<void> | void): Promise<void> | void;
+    };
+}
+/**
+ * Duck-typed mirror of the v2 `Plugin` contract
+ * (dist/v2/promise/plugin.d.ts). `define()` is the identity function —
+ * 54 bytes, `return plugin` — so adopting it is neither a framework nor
+ * a commitment (D9-02); the object literal below already satisfies the
+ * contract.
+ */
+export interface KevinNativePlugin {
+    readonly id: string;
+    readonly setup: (context: KevinNativeContext) => Promise<void> | void;
+}
+/** The skill body Kevin registers through `skill.transform`. */
+export declare function kevinSkillSource(materializer: Materializer): string;
+/**
+ * Build the v2 plugin. Registration replaces emission (D9-10): when the
+ * host runs `setup()`, the skill/reference surfaces are registered
+ * natively and the Materializer's `*_emission_enabled` file path is
+ * skipped for those surfaces (guard in K9-016).
+ */
+export declare function buildNativePlugin(deps: NativeDeps): KevinNativePlugin;
+export interface AttachOptions {
+    /** Injectable v2 loader for tests; defaults to the real dynamic import. */
+    importV2?: () => Promise<unknown>;
+    /** Collects notes for the caller when the result is null. */
+    notes?: string[];
+}
+/**
+ * Attach the native surface when the host exposes it AND the user asked
+ * for it. Returns `null` — cleanly, with a `note` — whenever the host
+ * lacks the subpath or `native_registration_enabled` is not `'1'`; that
+ * is the default on every existing installation, so the default
+ * behaviour of this release is byte-identical to v0.8.0. Never throws
+ * (D9-12): every failure path is a `null` plus a `note`.
+ */
+export declare function attachNative(host: HostSurface, deps: NativeDeps, options?: AttachOptions): Promise<NativeRegistration | null>;

package/dist/plugin/native.js

@@ -0,0 +1,190 @@
+import { SKILL_TOPIC } from "./Materializer.js";
+import { uuidv7 } from "./uuid.js";
+/** The only place in the repository allowed to name the v2 subpath. */
+export const V2_SPECIFIER = "@opencode-ai/plugin/v2/promise";
+/** The skill body Kevin registers through `skill.transform`. */
+export function kevinSkillSource(materializer) {
+    return materializer.skillBody();
+}
+/**
+ * Build the v2 plugin. Registration replaces emission (D9-10): when the
+ * host runs `setup()`, the skill/reference surfaces are registered
+ * natively and the Materializer's `*_emission_enabled` file path is
+ * skipped for those surfaces (guard in K9-016).
+ */
+export function buildNativePlugin(deps) {
+    return {
+        id: "opencode-kevin",
+        setup: async (ctx) => {
+            try {
+                await ctx.skill.transform(async (draft) => {
+                    const source = kevinSkillSource(deps.materializer);
+                    // The draft is a mutable builder valid only for the
+                    // duration of this callback; it never escapes (D9-10
+                    // property 3). K9-014's source scan asserts that.
+                    const draftApi = draft;
+                    if (typeof draftApi.source !== "function") {
+                        deps.onVerified?.("skill", false, false);
+                        return;
+                    }
+                    draftApi.source(source);
+                    // v0.9.0 (K9-014 / plan §5.4 property 2) — verification is a
+                    // read-back: the registered source must show up in the
+                    // draft's own list(). An unverified registration is a note
+                    // (and a metric in K9-017), never a throw.
+                    const verified = typeof draftApi.list === "function" &&
+                        draftApi.list().some((entry) => entry === source);
+                    deps.onVerified?.("skill", true, verified);
+                });
+            }
+            catch {
+                // A rejecting transform still reports, never throws (K9-014).
+                deps.onVerified?.("skill", false, false);
+            }
+            try {
+                await ctx.reference.transform(async (draft) => {
+                    // v0.9.0 (K9-015 / plan §5.4, D6-14) — one add() per
+                    // materialized ref target (topic !== SKILL_TOPIC), named
+                    // `@kevin/<topic>`. Topics follow the v0.6.0 rule
+                    // `<type>-<dominant token>`; dominantToken already
+                    // excludes hex-like tokens, so a fingerprint prefix can
+                    // never become a reference name. Sources use the v2
+                    // `{ type: "local", path }` shape (read from the
+                    // resolved SDK's ReferenceLocalSource, duck-typed).
+                    const draftApi = draft;
+                    if (typeof draftApi.add !== "function") {
+                        deps.onVerified?.("reference", false, false);
+                        return;
+                    }
+                    const added = [];
+                    for (const target of deps.materializer.bundleTargets()) {
+                        if (target.topic === SKILL_TOPIC)
+                            continue;
+                        const name = `@kevin/${target.topic}`;
+                        draftApi.add(name, {
+                            type: "local",
+                            path: target.path,
+                        });
+                        added.push(name);
+                    }
+                    // Verification is the same read-back as K9-014: every
+                    // name we added must show up in the draft's own list().
+                    const listed = typeof draftApi.list === "function" ? draftApi.list() : [];
+                    const listedNames = new Set(listed.map((entry) => {
+                        const tuple = entry;
+                        return tuple[0];
+                    }));
+                    const verified = added.every((name) => listedNames.has(name));
+                    deps.onVerified?.("reference", true, verified);
+                });
+            }
+            catch {
+                deps.onVerified?.("reference", false, false);
+            }
+        },
+    };
+}
+/**
+ * Attach the native surface when the host exposes it AND the user asked
+ * for it. Returns `null` — cleanly, with a `note` — whenever the host
+ * lacks the subpath or `native_registration_enabled` is not `'1'`; that
+ * is the default on every existing installation, so the default
+ * behaviour of this release is byte-identical to v0.8.0. Never throws
+ * (D9-12): every failure path is a `null` plus a `note`.
+ */
+export async function attachNative(host, deps, options = {}) {
+    const notes = options.notes ?? [];
+    const enabled = deps.settings.getSetting("native_registration_enabled", "0") === "1";
+    if (!enabled)
+        return null;
+    if (!host.v2.skill && !host.v2.reference) {
+        notes.push("v2 subpath absent from the resolved host package — native registration skipped");
+        return null;
+    }
+    let mod;
+    try {
+        mod = await (options.importV2 ?? (() => import(/* @vite-ignore */ V2_SPECIFIER)))();
+    }
+    catch {
+        notes.push("v2 subpath import rejected — native registration skipped");
+        return null;
+    }
+    const record = mod;
+    const define = typeof record.define === "function"
+        ? record.define
+        : null;
+    if (define === null) {
+        notes.push("v2 module exposes no define() — native registration skipped");
+        return null;
+    }
+    // `define()` is the identity function (D9-02): passing the built
+    // plugin through it validates the contract without adding a framework.
+    // v0.9.0 (K9-014 / plan §5.4 property 2) — the collector for the
+    // read-back results: `verified` is filled by the host running setup()
+    // (draft.list()), reported back through onVerified. The setup callback
+    // may fire after this function resolved; the caller keeps the returned
+    // registration as the final word.
+    const registered = { skill: host.v2.skill, reference: host.v2.reference };
+    const verified = { skill: false, reference: false };
+    const plugin = buildNativePlugin({
+        ...deps,
+        onVerified: (surface, didRegister, isVerified) => {
+            if (!didRegister)
+                registered[surface] = false;
+            verified[surface] = isVerified;
+            if (!isVerified) {
+                notes.push(`${surface} read-back does not contain the provided source — unverified registration`);
+            }
+            // v0.9.0 (K9-017 / plan §6.2) — append the outcome row at attach
+            // time (construction, not a hot path; a direct write is correct,
+            // the flush cadence does not apply). Only surfaces the host
+            // actually exposes are persisted: a surface the host cannot
+            // serve is not an outcome to record.
+            if (deps.store && host.v2[surface]) {
+                const note = !isVerified
+                    ? `${surface} read-back does not contain the provided source — unverified registration`
+                    : null;
+                persistRegistration(deps.store, surface, didRegister, isVerified, note);
+            }
+        },
+    });
+    define(plugin);
+    return {
+        registered,
+        verified,
+        notes,
+    };
+}
+/**
+ * v0.9.0 (K9-017 / plan §6.2) — one `native_registrations` row per
+ * surface per attach attempt, plus the two live counters. The counters
+ * live OUTSIDE the frozen `METRIC_KEYS` ladder (K7-004) but persist to
+ * the same `kevin_metrics` table, following the v0.6.0 `incrRegistered`
+ * precedent (K6-018/019): written immediately, never debounced. The
+ * `surface` CHECK lives in the schema (migration 010), so a bad surface
+ * fails loudly at the constraint rather than being coerced — the closed
+ * enumeration is deliberate (plan §6.2).
+ */
+function persistRegistration(store, surface, registered, verified, note) {
+    store
+        .prepare(`INSERT INTO native_registrations (id, surface, registered, verified, note)
+			 VALUES (?, ?, ?, ?, ?)`)
+        .run(uuidv7(), surface, registered ? 1 : 0, verified ? 1 : 0, note);
+    if (verified) {
+        bumpNativeCounter(store, "native_registrations_total");
+    }
+    else if (registered) {
+        // "Registered but unverified": the host accepted the call and did
+        // not honour it — the interesting state (K9-017).
+        bumpNativeCounter(store, "native_registration_failures");
+    }
+}
+function bumpNativeCounter(store, key) {
+    store
+        .prepare(`INSERT INTO kevin_metrics (key, value, updated_at)
+			 VALUES (?, 1, datetime('now'))
+			 ON CONFLICT(key) DO UPDATE SET
+			   value = value + excluded.value,
+			   updated_at = datetime('now')`)
+        .run(key);
+}

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