@avocadostudio-ai/orchestrator-core 0.3.2 → 0.3.3

package/dist/durable/in-memory-durable-store.js

@@ -0,0 +1,363 @@
+import { randomUUID } from "node:crypto";
+import { CHECK_RUN_CAP, CORRECTION_CAP, PROPOSAL_CAP, SNOOZE_WINDOW_MS } from "./sqlite-durable-store.js";
+import { fallbackImpact } from "./finding-impact.js";
+/*
+ * In-memory `DurableStore`. Two jobs, both real.
+ *
+ * 1. It is the reference semantics. `durable-store.test.ts` runs one conformance
+ *    suite against this and the SQLite store, so a behaviour that drifts between
+ *    them fails rather than being discovered by whoever swaps implementations.
+ *
+ * 2. It is the honest fallback. `createOrchestrator()` already degrades to
+ *    memory-only when `better-sqlite3` cannot be loaded, and reports it through
+ *    `persistence: { ok: false, reason }`. Findings and memory should degrade
+ *    the same way and report the same thing — not throw, and not pretend.
+ *
+ * Nothing here is durable. The name describes the interface, not this class.
+ */
+const SEVERITY_ORDER = { error: 0, warning: 1, info: 2 };
+/** A fingerprint is unique per scope, never globally. See the SQLite index. */
+function fingerprintKey(scopeKey, fingerprint) {
+    return `${scopeKey}\u0000${fingerprint}`;
+}
+export class InMemoryDurableStore {
+    findings = new Map();
+    /** (scopeKey, fingerprint) → finding id. Mirrors the SQLite unique index. */
+    byFingerprint = new Map();
+    runs = new Map();
+    memory = new Map();
+    corrections = [];
+    proposals = new Map();
+    now;
+    constructor(options = {}) {
+        this.now = options.now ?? Date.now;
+    }
+    /** Keep the newest `cap` rows per scope, matching the SQLite store's trim. */
+    trim(map, scopeKey, cap, order) {
+        const forScope = [...map.values()].filter((row) => row.scopeKey === scopeKey);
+        if (forScope.length <= cap)
+            return;
+        forScope
+            .sort((a, b) => order(a) - order(b))
+            .slice(0, forScope.length - cap)
+            .forEach((row) => map.delete(row.id));
+    }
+    // Findings ---------------------------------------------------------------
+    async recordFindings(runId, findings) {
+        const at = this.now();
+        let opened = 0;
+        let updated = 0;
+        for (const f of findings) {
+            const fpKey = fingerprintKey(f.scopeKey, f.fingerprint);
+            const existingId = this.byFingerprint.get(fpKey);
+            const existing = existingId ? this.findings.get(existingId) : undefined;
+            if (!existing) {
+                const id = randomUUID();
+                this.findings.set(id, {
+                    ...f,
+                    id,
+                    impact: f.impact ?? fallbackImpact(f.severity),
+                    status: "open",
+                    lastRunId: runId,
+                    firstSeenAt: at,
+                    lastSeenAt: at
+                });
+                this.byFingerprint.set(fpKey, id);
+                opened += 1;
+                continue;
+            }
+            // `status` and `firstSeenAt` deliberately survive — see the SQLite store.
+            const next = {
+                ...existing,
+                slug: f.slug,
+                ruleId: f.ruleId,
+                agent: f.agent,
+                severity: f.severity,
+                // Recomputed every run — the page's weight moves even when the finding
+                // does not. See the SQLite store.
+                impact: f.impact ?? fallbackImpact(f.severity),
+                title: f.title,
+                lastRunId: runId,
+                lastSeenAt: at
+            };
+            if (f.detail === undefined)
+                delete next.detail;
+            else
+                next.detail = f.detail;
+            if (f.evidence === undefined)
+                delete next.evidence;
+            else
+                next.evidence = f.evidence;
+            if (f.proposedOps === undefined)
+                delete next.proposedOps;
+            else
+                next.proposedOps = f.proposedOps;
+            if (existing.status === "fixed") {
+                next.status = "open";
+                delete next.resolvedAt;
+                opened += 1;
+            }
+            else {
+                updated += 1;
+            }
+            this.findings.set(existing.id, next);
+        }
+        return { opened, updated };
+    }
+    async reconcileFindings(args) {
+        if (args.slugs.length === 0)
+            return { closed: 0 };
+        const at = args.at ?? this.now();
+        const inScope = new Set(args.slugs);
+        let closed = 0;
+        for (const record of this.findings.values()) {
+            if (record.scopeKey !== args.scopeKey)
+                continue;
+            // `snoozed` closes too — see the SQLite store. A snooze defers the
+            // report, not the problem.
+            if (record.status !== "open" && record.status !== "snoozed")
+                continue;
+            if (record.lastRunId === args.runId)
+                continue;
+            if (!inScope.has(record.slug))
+                continue;
+            if (args.agent && record.agent !== args.agent)
+                continue;
+            const next = { ...record, status: "fixed", resolvedAt: at };
+            delete next.snoozedUntil;
+            this.findings.set(record.id, next);
+            closed += 1;
+        }
+        return { closed };
+    }
+    async listFindings(query) {
+        const statuses = query.status
+            ? new Set(Array.isArray(query.status) ? query.status : [query.status])
+            : null;
+        if (statuses && statuses.size === 0)
+            return [];
+        const limit = Math.max(1, Math.min(query.limit ?? 500, 5000));
+        return [...this.findings.values()]
+            .filter((f) => f.scopeKey === query.scopeKey)
+            .filter((f) => (query.slug ? f.slug === query.slug : true))
+            .filter((f) => (query.agent ? f.agent === query.agent : true))
+            .filter((f) => (query.severity ? f.severity === query.severity : true))
+            .filter((f) => (statuses ? statuses.has(f.status) : true))
+            // Impact leads, severity breaks its ties — mirroring the SQLite ORDER BY.
+            .sort((a, b) => b.impact - a.impact ||
+            SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity] ||
+            b.lastSeenAt - a.lastSeenAt)
+            .slice(0, limit)
+            .map((f) => ({ ...f }));
+    }
+    async getFinding(id) {
+        const record = this.findings.get(id);
+        return record ? { ...record } : null;
+    }
+    async setFindingStatus(id, status, at) {
+        const record = this.findings.get(id);
+        if (!record)
+            return;
+        const when = at ?? this.now();
+        const next = { ...record, status };
+        // Deferred is not resolved, so `snoozed` clears `resolvedAt` like `open`.
+        if (status === "open" || status === "snoozed")
+            delete next.resolvedAt;
+        else
+            next.resolvedAt = when;
+        if (status === "snoozed")
+            next.snoozedUntil = when + SNOOZE_WINDOW_MS;
+        else
+            delete next.snoozedUntil;
+        this.findings.set(id, next);
+    }
+    async wakeSnoozedFindings(scopeKey, now) {
+        const at = now ?? this.now();
+        let woken = 0;
+        for (const record of this.findings.values()) {
+            if (record.scopeKey !== scopeKey || record.status !== "snoozed")
+                continue;
+            if (record.snoozedUntil == null || record.snoozedUntil > at)
+                continue;
+            const next = { ...record, status: "open" };
+            delete next.snoozedUntil;
+            delete next.resolvedAt;
+            this.findings.set(record.id, next);
+            woken += 1;
+        }
+        return { woken };
+    }
+    // Check runs -------------------------------------------------------------
+    async startCheckRun(run) {
+        const record = {
+            ...run,
+            pagesScanned: 0,
+            findingsOpened: 0,
+            findingsClosed: 0,
+            costUsd: 0
+        };
+        this.runs.set(run.id, record);
+        this.trim(this.runs, run.scopeKey, CHECK_RUN_CAP, (r) => r.startedAt);
+        return { ...record };
+    }
+    async finishCheckRun(id, patch) {
+        const record = this.runs.get(id);
+        if (!record)
+            return;
+        this.runs.set(id, { ...record, ...patch });
+    }
+    async listCheckRuns(scopeKey, limit = 50) {
+        return [...this.runs.values()]
+            .filter((r) => r.scopeKey === scopeKey)
+            .sort((a, b) => b.startedAt - a.startedAt)
+            .slice(0, Math.max(1, Math.min(limit, 1000)))
+            .map((r) => ({ ...r }));
+    }
+    // Memory -----------------------------------------------------------------
+    async putMemory(input, at) {
+        const createdAt = at ?? this.now();
+        const previous = [...this.memory.values()].find((m) => m.status === "active" &&
+            m.scope === input.scope &&
+            m.scopeKey === input.scopeKey &&
+            m.kind === input.kind &&
+            m.key === input.key);
+        if (previous)
+            this.memory.set(previous.id, { ...previous, status: "superseded" });
+        const record = {
+            ...input,
+            id: randomUUID(),
+            confidence: input.confidence ?? 1,
+            status: "active",
+            ...(previous ? { supersedesId: previous.id } : {}),
+            createdAt,
+            useCount: 0
+        };
+        this.memory.set(record.id, record);
+        return { ...record };
+    }
+    async listMemory(query = {}) {
+        const kinds = query.kind
+            ? new Set(Array.isArray(query.kind) ? query.kind : [query.kind])
+            : null;
+        if (kinds && kinds.size === 0)
+            return [];
+        const status = query.status ?? "active";
+        const limit = Math.max(1, Math.min(query.limit ?? 500, 5000));
+        return [...this.memory.values()]
+            .filter((m) => (query.scopeKey ? m.scopeKey === query.scopeKey : true))
+            .filter((m) => (query.scope ? m.scope === query.scope : true))
+            .filter((m) => (kinds ? kinds.has(m.kind) : true))
+            .filter((m) => m.status === status)
+            .sort((a, b) => b.createdAt - a.createdAt)
+            .slice(0, limit)
+            .map((m) => ({ ...m }));
+    }
+    async touchMemory(ids, at) {
+        const when = at ?? this.now();
+        for (const id of ids) {
+            const record = this.memory.get(id);
+            if (!record)
+                continue;
+            this.memory.set(id, { ...record, lastUsedAt: when, useCount: record.useCount + 1 });
+        }
+    }
+    async setMemoryStatus(id, status) {
+        const record = this.memory.get(id);
+        if (!record)
+            return;
+        // Reactivating demotes whatever is active for that key — otherwise this
+        // store would hold two active records for one key and hand a planner two
+        // contradicting facts, while SQLite refused the same write outright.
+        if (status === "active") {
+            for (const other of this.memory.values()) {
+                if (other.id === id)
+                    continue;
+                if (other.status !== "active")
+                    continue;
+                if (other.scope !== record.scope ||
+                    other.scopeKey !== record.scopeKey ||
+                    other.kind !== record.kind ||
+                    other.key !== record.key) {
+                    continue;
+                }
+                this.memory.set(other.id, { ...other, status: "superseded" });
+            }
+        }
+        this.memory.set(id, { ...record, status });
+    }
+    // Corrections ------------------------------------------------------------
+    async recordCorrection(input, at) {
+        const record = { ...input, id: randomUUID(), at: at ?? this.now() };
+        this.corrections.push(record);
+        const forScope = this.corrections.filter((c) => c.scopeKey === record.scopeKey);
+        if (forScope.length > CORRECTION_CAP) {
+            const drop = new Set(forScope.sort((a, b) => a.at - b.at).slice(0, forScope.length - CORRECTION_CAP).map((c) => c.id));
+            for (let i = this.corrections.length - 1; i >= 0; i -= 1) {
+                if (drop.has(this.corrections[i].id))
+                    this.corrections.splice(i, 1);
+            }
+        }
+        return { ...record };
+    }
+    async listCorrections(query = {}) {
+        const limit = Math.max(1, Math.min(query.limit ?? 200, 5000));
+        return this.corrections
+            .filter((c) => (query.scopeKey ? c.scopeKey === query.scopeKey : true))
+            .filter((c) => (query.outcome ? c.outcome === query.outcome : true))
+            .filter((c) => (query.since != null ? c.at >= query.since : true))
+            .slice()
+            .sort((a, b) => b.at - a.at)
+            .slice(0, limit)
+            .map((c) => ({ ...c }));
+    }
+    // Proposals --------------------------------------------------------------
+    async putProposal(input) {
+        const existing = this.proposals.get(input.id);
+        const record = {
+            ...input,
+            status: existing?.status ?? "pending",
+            ...(existing?.resolvedAt != null ? { resolvedAt: existing.resolvedAt } : {}),
+            createdAt: existing?.createdAt ?? input.createdAt
+        };
+        this.proposals.set(record.id, record);
+        this.trim(this.proposals, record.scopeKey, PROPOSAL_CAP, (p) => p.createdAt);
+        return { ...record };
+    }
+    async getProposal(id) {
+        const record = this.proposals.get(id);
+        return record ? { ...record } : null;
+    }
+    async listProposals(query) {
+        const limit = Math.max(1, Math.min(query.limit ?? 100, 1000));
+        return [...this.proposals.values()]
+            .filter((p) => p.scopeKey === query.scopeKey)
+            .filter((p) => (query.status ? p.status === query.status : true))
+            .sort((a, b) => b.createdAt - a.createdAt)
+            .slice(0, limit)
+            .map((p) => ({ ...p }));
+    }
+    async setProposalStatus(id, status, at) {
+        const record = this.proposals.get(id);
+        if (!record)
+            return;
+        const next = { ...record, status };
+        if (status === "pending")
+            delete next.resolvedAt;
+        else
+            next.resolvedAt = at ?? this.now();
+        this.proposals.set(id, next);
+    }
+    async expireProposals(now) {
+        const at = now ?? this.now();
+        let expired = 0;
+        for (const record of this.proposals.values()) {
+            if (record.status !== "pending")
+                continue;
+            if (record.expiresAt == null || record.expiresAt > at)
+                continue;
+            this.proposals.set(record.id, { ...record, status: "expired", resolvedAt: at });
+            expired += 1;
+        }
+        return { expired };
+    }
+}

package/dist/durable/index.d.ts

@@ -0,0 +1,5 @@
+export { getDurableStore, resetDurableStore, setDurableStore, durableStoreIsEphemeral, discardPendingProposalsForSession, sweepExpiredProposals } from "./durable-store-singleton.ts";
+export { loadPendingPlan, savePendingPlan, clearPendingPlan, peekPendingPlan } from "./pending-plan-store.ts";
+export { SqliteDurableStore, type SqliteDurableStoreOptions } from "./sqlite-durable-store.ts";
+export { InMemoryDurableStore, type InMemoryDurableStoreOptions } from "./in-memory-durable-store.ts";
+export type { DurableStore, FindingInput, FindingRecord, FindingQuery, FindingSeverity, FindingStatus, FindingEvidence, CheckRunInput, CheckRunRecord, CheckRunPatch, CheckRunTrigger, MemoryInput, MemoryRecord, MemoryQuery, MemoryScope, MemoryKind, MemorySource, MemoryStatus, CorrectionInput, CorrectionRecord, CorrectionQuery, CorrectionOutcome, ProposalInput, ProposalRecord, ProposalQuery, ProposalStatus } from "./types.ts";

package/dist/durable/index.js

@@ -0,0 +1,4 @@
+export { getDurableStore, resetDurableStore, setDurableStore, durableStoreIsEphemeral, discardPendingProposalsForSession, sweepExpiredProposals } from "./durable-store-singleton.js";
+export { loadPendingPlan, savePendingPlan, clearPendingPlan, peekPendingPlan } from "./pending-plan-store.js";
+export { SqliteDurableStore } from "./sqlite-durable-store.js";
+export { InMemoryDurableStore } from "./in-memory-durable-store.js";

package/dist/durable/pending-plan-store.d.ts

@@ -0,0 +1,28 @@
+import { type PendingApprovalPlan } from "../state/session-state.ts";
+/**
+ * Map-only read. For call sites that only need to know whether a plan is live
+ * in this process and must not pay for a query.
+ */
+export declare function peekPendingPlan(session: string): PendingApprovalPlan | undefined;
+/**
+ * Read the pending plan, rehydrating from the durable store on a Map miss.
+ *
+ * An expired row is treated as absent rather than deleted: eviction is the
+ * sweeper's job, and a read is not the place to discover that a plan the user
+ * is looking at right now has just aged out mid-request.
+ */
+export declare function loadPendingPlan(session: string): Promise<PendingApprovalPlan | undefined>;
+/** Set the plan in memory and mirror it to the durable store. */
+export declare function savePendingPlan(session: string, plan: PendingApprovalPlan): Promise<void>;
+/**
+ * Drop the plan from memory and resolve its durable row.
+ *
+ * `outcome` is recorded rather than deleted, so "how often does a human discard
+ * what we proposed" stays answerable — which is the same signal the corrections
+ * table is for, and the reason `expectedId` matters. A turn that applies
+ * something unrelated must not record a held plan as `approved`: it was never
+ * reviewed, and writing that down poisons the one number this is here to make
+ * available. Pass the id of the plan actually acted on; omit it only where the
+ * intent really is "whatever chat plan is pending, it is over".
+ */
+export declare function clearPendingPlan(session: string, outcome: "approved" | "discarded", expectedId?: string): Promise<void>;

package/dist/durable/pending-plan-store.js

@@ -0,0 +1,156 @@
+import { pendingApprovalPlanBySession } from "../state/session-state.js";
+import { getDurableStore, isDiscardInFlight, noteDurableFailure } from "./durable-store-singleton.js";
+/*
+ * Write-through durability for the pending approval plan.
+ *
+ * `pendingApprovalPlanBySession` stays the hot path — a Map read is what the
+ * chat pipeline wants and there is no reason to make it a query. What changes is
+ * that the Map is no longer the only copy: every plan is mirrored into the
+ * `proposals` table, and a read that misses rehydrates from there.
+ *
+ * The case this exists for is not a crash. It is the ordinary one: an agent
+ * runs at 03:00, produces a plan, and the process that produced it is gone long
+ * before anyone looks. Today that plan is in a Map that was never persisted and
+ * is evicted by age, so the morning's "approve" finds nothing and silently
+ * re-plans from the original message — at best spending tokens to reproduce
+ * work, at worst producing a different plan than the one that was reviewed.
+ *
+ * Every durable write here is best-effort. If the store is unavailable the chat
+ * path must behave exactly as it did before this module existed: in-memory, and
+ * honest about it through `durableHealth()`. A findings feature is not permitted
+ * to take chat down with it.
+ */
+/*
+ * Two different TTLs, because they answer two different questions.
+ *
+ * The Map's hour (`APPROVAL_PLAN_TTL_MS` in session-state) is "how long do we
+ * keep an abandoned approval warm in this process" — a memory-pressure answer.
+ * Reusing it for the durable row would defeat the entire point of the row: the
+ * agent that ran at 03:00 and the person who approves at 09:00 are six hours
+ * apart, so an hour-old row is expired before anybody could possibly have seen
+ * it, and `loadPendingPlan` falls straight back to the silent re-plan this
+ * module exists to prevent.
+ *
+ * A durable proposal is kept for a working week. The Map still forgets it after
+ * an hour; the next read rehydrates.
+ */
+const DURABLE_PLAN_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * Marks the proposals this module owns.
+ *
+ * `proposals` is shared with agent-authored plans by design. "The newest
+ * pending row for this session" is therefore the wrong question — once a
+ * checker writes one, it would shadow a genuinely pending chat plan behind it,
+ * and `clearPendingPlan` would resolve somebody else's proposal as approved.
+ */
+const CHAT_ORIGIN_PREFIX = "chat:";
+function createdAtMs(plan) {
+    const parsed = Date.parse(plan.createdAt);
+    return Number.isFinite(parsed) ? parsed : Date.now();
+}
+function noteFailure(err, what) {
+    noteDurableFailure(`${what}: ${err instanceof Error ? err.message : String(err)}`);
+}
+function isChatProposal(record) {
+    return record.origin.startsWith(CHAT_ORIGIN_PREFIX);
+}
+async function findChatProposal(session) {
+    const rows = await getDurableStore().listProposals({ scopeKey: session, status: "pending" });
+    return rows.find(isChatProposal);
+}
+/**
+ * Map-only read. For call sites that only need to know whether a plan is live
+ * in this process and must not pay for a query.
+ */
+export function peekPendingPlan(session) {
+    return pendingApprovalPlanBySession.get(session);
+}
+/**
+ * Read the pending plan, rehydrating from the durable store on a Map miss.
+ *
+ * An expired row is treated as absent rather than deleted: eviction is the
+ * sweeper's job, and a read is not the place to discover that a plan the user
+ * is looking at right now has just aged out mid-request.
+ */
+export async function loadPendingPlan(session) {
+    const live = pendingApprovalPlanBySession.get(session);
+    if (live)
+        return live;
+    if (isDiscardInFlight(session))
+        return undefined;
+    try {
+        const record = await findChatProposal(session);
+        if (!record?.payload)
+            return undefined;
+        if (record.expiresAt != null && record.expiresAt <= Date.now())
+            return undefined;
+        const plan = record.payload;
+        // A payload that cannot be executed is worse than none: the approval path
+        // would hand a malformed plan to the ops engine on the user's click.
+        if (!plan?.id || !plan.plan || !Array.isArray(plan.plan.ops))
+            return undefined;
+        pendingApprovalPlanBySession.set(session, plan);
+        return plan;
+    }
+    catch (err) {
+        noteFailure(err, "read pending plan");
+        return undefined;
+    }
+}
+/** Set the plan in memory and mirror it to the durable store. */
+export async function savePendingPlan(session, plan) {
+    pendingApprovalPlanBySession.set(session, plan);
+    const createdAt = createdAtMs(plan);
+    try {
+        await getDurableStore().putProposal({
+            id: plan.id,
+            scopeKey: session,
+            origin: `${CHAT_ORIGIN_PREFIX}${plan.source}`,
+            summary: plan.summary,
+            ops: plan.plan.ops,
+            slugs: plan.effectiveSlug ? [plan.effectiveSlug] : [],
+            payload: plan,
+            createdAt,
+            expiresAt: createdAt + DURABLE_PLAN_TTL_MS
+        });
+    }
+    catch (err) {
+        noteFailure(err, "save pending plan");
+    }
+}
+/**
+ * Drop the plan from memory and resolve its durable row.
+ *
+ * `outcome` is recorded rather than deleted, so "how often does a human discard
+ * what we proposed" stays answerable — which is the same signal the corrections
+ * table is for, and the reason `expectedId` matters. A turn that applies
+ * something unrelated must not record a held plan as `approved`: it was never
+ * reviewed, and writing that down poisons the one number this is here to make
+ * available. Pass the id of the plan actually acted on; omit it only where the
+ * intent really is "whatever chat plan is pending, it is over".
+ */
+export async function clearPendingPlan(session, outcome, expectedId) {
+    const plan = pendingApprovalPlanBySession.get(session);
+    if (expectedId && plan && plan.id !== expectedId) {
+        // The live plan is not the one being resolved — leave both alone.
+        return;
+    }
+    pendingApprovalPlanBySession.delete(session);
+    try {
+        const store = getDurableStore();
+        const id = expectedId ?? plan?.id;
+        if (id) {
+            const record = await store.getProposal(id);
+            if (record && isChatProposal(record))
+                await store.setProposalStatus(id, outcome);
+            return;
+        }
+        // No live plan: a durable row may still be pending from a previous process.
+        const record = await findChatProposal(session);
+        if (record)
+            await store.setProposalStatus(record.id, outcome);
+    }
+    catch (err) {
+        noteFailure(err, "clear pending plan");
+    }
+}

package/dist/durable/sqlite-durable-store.d.ts

@@ -0,0 +1,71 @@
+import type { Database as BetterSqliteDatabase } from "better-sqlite3";
+import type { CheckRunInput, CheckRunPatch, CheckRunRecord, CorrectionInput, CorrectionQuery, CorrectionRecord, DurableStore, FindingInput, FindingQuery, FindingRecord, FindingStatus, MemoryInput, MemoryQuery, MemoryRecord, MemoryStatus, ProposalInput, ProposalQuery, ProposalRecord, ProposalStatus } from "./types.ts";
+export declare const PROPOSAL_CAP = 200;
+export declare const CORRECTION_CAP = 500;
+export declare const CHECK_RUN_CAP = 200;
+/**
+ * How long a snooze lasts.
+ *
+ * Seven days, because the button competes with Dismiss and has to mean
+ * something different from it: long enough to clear a finding out of the way
+ * for the week somebody is shipping a campaign, short enough that "I'll get to
+ * it" does not quietly become "never". Exported so both implementations, and
+ * the tests that hold them to the same behaviour, derive it from one number.
+ */
+export declare const SNOOZE_WINDOW_MS: number;
+export type SqliteDurableStoreOptions = {
+    /** Injectable clock, so tests can assert on ordering without sleeping. */
+    now?: () => number;
+};
+export declare class SqliteDurableStore implements DurableStore {
+    private readonly db;
+    private readonly now;
+    constructor(db: BetterSqliteDatabase, options?: SqliteDurableStoreOptions);
+    private ensureColumns;
+    private trim;
+    recordFindings(runId: string, findings: FindingInput[]): Promise<{
+        opened: number;
+        updated: number;
+    }>;
+    reconcileFindings(args: {
+        runId: string;
+        scopeKey: string;
+        slugs: string[];
+        agent?: string;
+        at?: number;
+    }): Promise<{
+        closed: number;
+    }>;
+    listFindings(query: FindingQuery): Promise<FindingRecord[]>;
+    getFinding(id: string): Promise<FindingRecord | null>;
+    setFindingStatus(id: string, status: FindingStatus, at?: number): Promise<void>;
+    wakeSnoozedFindings(scopeKey: string, now?: number): Promise<{
+        woken: number;
+    }>;
+    startCheckRun(run: CheckRunInput): Promise<{
+        pagesScanned: number;
+        findingsOpened: number;
+        findingsClosed: number;
+        costUsd: number;
+        id: string;
+        scopeKey: string;
+        agent: string;
+        trigger: import("./types.ts").CheckRunTrigger;
+        startedAt: number;
+    }>;
+    finishCheckRun(id: string, patch: CheckRunPatch): Promise<void>;
+    listCheckRuns(scopeKey: string, limit?: number): Promise<CheckRunRecord[]>;
+    putMemory(input: MemoryInput, at?: number): Promise<MemoryRecord>;
+    listMemory(query?: MemoryQuery): Promise<MemoryRecord[]>;
+    touchMemory(ids: string[], at?: number): Promise<void>;
+    setMemoryStatus(id: string, status: MemoryStatus): Promise<void>;
+    recordCorrection(input: CorrectionInput, at?: number): Promise<CorrectionRecord>;
+    listCorrections(query?: CorrectionQuery): Promise<CorrectionRecord[]>;
+    putProposal(input: ProposalInput): Promise<ProposalRecord>;
+    getProposal(id: string): Promise<ProposalRecord | null>;
+    listProposals(query: ProposalQuery): Promise<ProposalRecord[]>;
+    setProposalStatus(id: string, status: ProposalStatus, at?: number): Promise<void>;
+    expireProposals(now?: number): Promise<{
+        expired: number;
+    }>;
+}