@jbarket/loomai 0.5.0

package/dist/backends/migrations.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Schema migration registry for memories.db.
+ *
+ * Each Migration is idempotent: the `pending` predicate checks current DB
+ * state before `run` is called, so migrations are safe to re-run on every
+ * backend connect.
+ *
+ * Add new migrations at the bottom of MIGRATIONS — never reorder or remove
+ * existing entries (future migrations may depend on prior state).
+ */
+import type { Database } from 'better-sqlite3';
+export interface Migration {
+    readonly id: string;
+    readonly description: string;
+    pending(db: Database): boolean;
+    run(db: Database): void;
+}
+export interface MigrationResult {
+    id: string;
+    description: string;
+    status: 'applied' | 'skipped' | 'failed';
+    error?: string;
+}
+export declare const MIGRATIONS: readonly Migration[];
+/**
+ * Apply pending migrations to a database.
+ *
+ * With strict: true (default), throws immediately on the first migration
+ * failure — the database is in an unknown state and startup should abort.
+ *
+ * With strict: false, records the error and continues — useful for the CLI
+ * migrate subcommand which wants to report all results before exiting.
+ */
+export declare function runMigrations(db: Database, opts?: {
+    strict?: boolean;
+}): MigrationResult[];
+/** Return migrations that have not yet been applied, without touching the DB. */
+export declare function pendingMigrations(db: Database): readonly Migration[];

package/dist/backends/migrations.js

@@ -0,0 +1,157 @@
+function hasColumn(db, table, column) {
+    const info = db.pragma(`table_info(${table})`);
+    return info.some((c) => c.name === column);
+}
+function hasIndex(db, table, name) {
+    const info = db.pragma(`index_list(${table})`);
+    return info.some((i) => i.name === name);
+}
+function hasTable(db, table) {
+    const row = db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
+        .get(table);
+    return row !== undefined;
+}
+export const MIGRATIONS = [
+    {
+        id: 'add_archived',
+        description: 'Add archived column for soft-delete/archive tier (SLE-90)',
+        pending: (db) => !hasColumn(db, 'memories', 'archived'),
+        run: (db) => {
+            db.prepare('ALTER TABLE memories ADD COLUMN archived INTEGER NOT NULL DEFAULT 0').run();
+        },
+    },
+    {
+        id: 'add_archive_note',
+        description: 'Add archive_note column for tombstone data (SLE-90)',
+        pending: (db) => !hasColumn(db, 'memories', 'archive_note'),
+        run: (db) => {
+            db.prepare('ALTER TABLE memories ADD COLUMN archive_note TEXT').run();
+        },
+    },
+    {
+        id: 'idx_memories_archived',
+        description: 'Index memories.archived for query performance',
+        pending: (db) => !hasIndex(db, 'memories', 'idx_memories_archived'),
+        run: (db) => {
+            db.prepare('CREATE INDEX idx_memories_archived ON memories(archived)').run();
+        },
+    },
+    {
+        id: 'add_salience',
+        description: 'Add salience temperature for the tiered boot digest (it-loom-salience)',
+        pending: (db) => !hasColumn(db, 'memories', 'salience'),
+        run: (db) => {
+            // Fresh column; new writes set 1.0 (hot), the consolidation lane recomputes
+            // existing rows from their timestamps. Default 0 = cold until first refresh.
+            db.prepare('ALTER TABLE memories ADD COLUMN salience REAL NOT NULL DEFAULT 0').run();
+        },
+    },
+    {
+        id: 'add_proposals',
+        description: 'Add proposals staging table for the capture-propose queue — drafts a ' +
+            'background lane stages for ratification; NOT authored canon until ratified',
+        pending: (db) => !hasTable(db, 'proposals'),
+        run: (db) => {
+            // The staging area for the capture-propose queue. A proposal is NOT an
+            // authored memory: it lives in its own table, invisible to recall / list /
+            // salience / find_similar, and only becomes a real memory via an explicit
+            // ratify (which routes through remember() so it is validated like any write).
+            db.prepare(`
+        CREATE TABLE proposals (
+          id        INTEGER PRIMARY KEY AUTOINCREMENT,
+          uuid      TEXT NOT NULL UNIQUE,
+          category  TEXT,
+          title     TEXT,
+          content   TEXT,
+          project   TEXT,
+          ttl       TEXT,
+          metadata  TEXT DEFAULT '{}',
+          source    TEXT,
+          created   TEXT,
+          status    TEXT NOT NULL DEFAULT 'pending'
+        )
+      `).run();
+        },
+    },
+    {
+        id: 'add_memory_revisions',
+        description: 'Add memory_revisions table — snapshots displaced body on every update(), ' +
+            'capped at 10 per memory (parity with knowledge wing page_revisions, t-327)',
+        pending: (db) => !hasTable(db, 'memory_revisions'),
+        run: (db) => {
+            // Body snapshots retained per memory; oldest pruned beyond this cap.
+            // op codes: 'update' (displaced by update()) | 'revision-restore' (displaced
+            // by a rollback to a prior snapshot).
+            db.prepare(`
+        CREATE TABLE memory_revisions (
+          id          INTEGER PRIMARY KEY AUTOINCREMENT,
+          memory_id   INTEGER NOT NULL REFERENCES memories(id) ON DELETE CASCADE,
+          ref         TEXT NOT NULL,
+          content     TEXT NOT NULL,
+          op          TEXT NOT NULL,
+          replaced_at TEXT NOT NULL
+        )
+      `).run();
+            db.prepare('CREATE INDEX idx_memory_revisions_memory ON memory_revisions(memory_id)').run();
+        },
+    },
+    {
+        id: 'add_memory_supersessions',
+        description: 'Add memory_supersessions table — records that new_ref replaced old_ref, ' +
+            'so the supersession edge survives archive (parity with knowledge wing, t-327)',
+        pending: (db) => !hasTable(db, 'memory_supersessions'),
+        run: (db) => {
+            // A supersession is an explicit durable link: old_ref was retired because
+            // new_ref is the canonical replacement. old_ref is archived by the supersede()
+            // call; this table is the record that B replaced A (survives forever, refs
+            // are strings so they outlive archive/restore cycles).
+            db.prepare(`
+        CREATE TABLE memory_supersessions (
+          id        INTEGER PRIMARY KEY AUTOINCREMENT,
+          old_ref   TEXT NOT NULL,
+          new_ref   TEXT NOT NULL,
+          note      TEXT,
+          created   TEXT NOT NULL
+        )
+      `).run();
+            db.prepare('CREATE INDEX idx_memory_supersessions_old ON memory_supersessions(old_ref)').run();
+            db.prepare('CREATE INDEX idx_memory_supersessions_new ON memory_supersessions(new_ref)').run();
+        },
+    },
+];
+/**
+ * Apply pending migrations to a database.
+ *
+ * With strict: true (default), throws immediately on the first migration
+ * failure — the database is in an unknown state and startup should abort.
+ *
+ * With strict: false, records the error and continues — useful for the CLI
+ * migrate subcommand which wants to report all results before exiting.
+ */
+export function runMigrations(db, opts = {}) {
+    const strict = opts.strict ?? true;
+    const results = [];
+    for (const m of MIGRATIONS) {
+        if (!m.pending(db)) {
+            results.push({ id: m.id, description: m.description, status: 'skipped' });
+            continue;
+        }
+        try {
+            m.run(db);
+            results.push({ id: m.id, description: m.description, status: 'applied' });
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            if (strict) {
+                throw new Error(`Migration '${m.id}' failed: ${error}`);
+            }
+            results.push({ id: m.id, description: m.description, status: 'failed', error });
+        }
+    }
+    return results;
+}
+/** Return migrations that have not yet been applied, without touching the DB. */
+export function pendingMigrations(db) {
+    return MIGRATIONS.filter((m) => m.pending(db));
+}

package/dist/backends/mmr.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Maximal Marginal Relevance (MMR) re-ranking for recall.
+ *
+ * A well-covered topic in a store of hundreds of memories yields a top-k
+ * that is mostly the same fact restated. MMR trades a little relevance for
+ * coverage: each pick maximises
+ *
+ *   score(c) = λ·relevance(c) − (1−λ)·max_{s ∈ selected} sim(c, s)
+ *
+ * greedily until `limit` results are chosen. `sim` is cosine similarity
+ * between the candidates' stored embedding vectors, so "near-duplicate" is
+ * judged in the same space the search ranked in — not by text overlap.
+ *
+ * The knob exposed to callers is `diversity = 1 − λ` (0..1). At 0 the
+ * candidates come back in their original relevance order, untouched. The
+ * idea is borrowed from xai-org/grok-build's memory search (Apache-2.0;
+ * idea only, no code).
+ */
+export interface MmrCandidate {
+    /** Search relevance, higher is better (loom uses 1 − cosine distance). */
+    relevance: number;
+    /** The candidate's embedding, used for pairwise similarity. */
+    vector: ArrayLike<number>;
+}
+export interface MmrResult<T> {
+    /** Chosen candidates in selection order (first pick = most relevant). */
+    selected: T[];
+    /**
+     * How many of the top-`limit` candidates by relevance were displaced by
+     * a less-relevant-but-different one. 0 means MMR changed nothing.
+     */
+    diversityDrops: number;
+}
+/** Default `diversity` (1 − λ) for recall: λ = 0.7. */
+export declare const DEFAULT_DIVERSITY = 0.3;
+export declare function cosineSimilarity(a: ArrayLike<number>, b: ArrayLike<number>): number;
+/**
+ * Greedy MMR selection over a relevance-ordered candidate pool.
+ *
+ * Leaves the pool untouched (returns the first `limit` as-is) when
+ * `diversity` is 0 or there are no more candidates than `limit` — there is
+ * nothing to trade off in either case, and callers rely on the old
+ * ordering surviving both.
+ */
+export declare function mmrSelect<T extends MmrCandidate>(candidates: readonly T[], limit: number, diversity?: number): MmrResult<T>;

package/dist/backends/mmr.js

@@ -0,0 +1,82 @@
+/**
+ * Maximal Marginal Relevance (MMR) re-ranking for recall.
+ *
+ * A well-covered topic in a store of hundreds of memories yields a top-k
+ * that is mostly the same fact restated. MMR trades a little relevance for
+ * coverage: each pick maximises
+ *
+ *   score(c) = λ·relevance(c) − (1−λ)·max_{s ∈ selected} sim(c, s)
+ *
+ * greedily until `limit` results are chosen. `sim` is cosine similarity
+ * between the candidates' stored embedding vectors, so "near-duplicate" is
+ * judged in the same space the search ranked in — not by text overlap.
+ *
+ * The knob exposed to callers is `diversity = 1 − λ` (0..1). At 0 the
+ * candidates come back in their original relevance order, untouched. The
+ * idea is borrowed from xai-org/grok-build's memory search (Apache-2.0;
+ * idea only, no code).
+ */
+/** Default `diversity` (1 − λ) for recall: λ = 0.7. */
+export const DEFAULT_DIVERSITY = 0.3;
+export function cosineSimilarity(a, b) {
+    const n = Math.min(a.length, b.length);
+    let dot = 0;
+    let na = 0;
+    let nb = 0;
+    for (let i = 0; i < n; i++) {
+        dot += a[i] * b[i];
+        na += a[i] * a[i];
+        nb += b[i] * b[i];
+    }
+    if (na === 0 || nb === 0)
+        return 0;
+    return dot / Math.sqrt(na * nb);
+}
+/**
+ * Greedy MMR selection over a relevance-ordered candidate pool.
+ *
+ * Leaves the pool untouched (returns the first `limit` as-is) when
+ * `diversity` is 0 or there are no more candidates than `limit` — there is
+ * nothing to trade off in either case, and callers rely on the old
+ * ordering surviving both.
+ */
+export function mmrSelect(candidates, limit, diversity = DEFAULT_DIVERSITY) {
+    if (!(limit > 0))
+        return { selected: [], diversityDrops: 0 };
+    if (!(diversity > 0) || candidates.length <= limit) {
+        return { selected: candidates.slice(0, limit), diversityDrops: 0 };
+    }
+    const lambda = 1 - Math.min(diversity, 1);
+    const remaining = candidates.map((_, i) => i);
+    const chosen = [];
+    // maxSim[i]: similarity of candidate i to the closest already-selected item.
+    const maxSim = new Float64Array(candidates.length);
+    while (chosen.length < limit && remaining.length > 0) {
+        let best = -1;
+        let bestScore = Number.NEGATIVE_INFINITY;
+        for (const i of remaining) {
+            const penalty = chosen.length === 0 ? 0 : maxSim[i];
+            const score = lambda * candidates[i].relevance - (1 - lambda) * penalty;
+            // Strict > keeps the earlier (more relevant) candidate on ties.
+            if (score > bestScore) {
+                bestScore = score;
+                best = i;
+            }
+        }
+        chosen.push(best);
+        remaining.splice(remaining.indexOf(best), 1);
+        const pickedVec = candidates[best].vector;
+        for (const i of remaining) {
+            const s = cosineSimilarity(candidates[i].vector, pickedVec);
+            if (s > maxSim[i])
+                maxSim[i] = s;
+        }
+    }
+    const topByRelevance = candidates
+        .map((_, i) => i)
+        .sort((a, b) => candidates[b].relevance - candidates[a].relevance || a - b)
+        .slice(0, limit);
+    const chosenSet = new Set(chosen);
+    const diversityDrops = topByRelevance.filter((i) => !chosenSet.has(i)).length;
+    return { selected: chosen.map((i) => candidates[i]), diversityDrops };
+}

package/dist/backends/proposals.d.ts

@@ -0,0 +1,65 @@
+import type { MemoryRef } from './types.js';
+export interface ProposalInput {
+    category: string;
+    title: string;
+    content: string;
+    project?: string;
+    ttl?: string;
+    metadata?: Record<string, unknown>;
+    /** Where the proposal came from, e.g. a lane name. */
+    source?: string;
+}
+export interface ProposalRow {
+    id: number;
+    uuid: string;
+    category: string | null;
+    title: string | null;
+    content: string | null;
+    project: string | null;
+    ttl: string | null;
+    metadata: string;
+    source: string | null;
+    created: string;
+    status: string;
+}
+export interface ProposalRef {
+    id: number;
+    uuid: string;
+}
+/** Optional Art-on-accept edits applied at ratify time. */
+export interface ProposalOverrides {
+    title?: string;
+    content?: string;
+    category?: string;
+    project?: string;
+    ttl?: string;
+}
+/** Thrown when a proposal id can't be found in the queue. */
+export declare class UnknownProposalError extends Error {
+    constructor(id: number);
+}
+/**
+ * Stage a pending proposal. A draft can be rough, so this does NOT run the
+ * full validateMemoryInput gate — but it DOES require a non-empty
+ * title + content + category so the row is at least shaped like a memory.
+ * Hard validation is deferred to ratify.
+ */
+export declare function propose(contextDir: string, input: ProposalInput): ProposalRef;
+/** All pending proposals, newest first. */
+export declare function listProposals(contextDir: string): ProposalRow[];
+/** Fetch a single proposal by id (any status), or null if not found. */
+export declare function getProposal(contextDir: string, id: number): ProposalRow | null;
+/** Delete a pending proposal. Returns false if no pending row with that id. */
+export declare function rejectProposal(contextDir: string, id: number): boolean;
+/**
+ * Ratify a pending proposal into a REAL memory.
+ *
+ * Loads the proposal, applies optional Art-on-accept overrides, then commits it
+ * via the existing remember() path — so validateMemoryInput runs. If the
+ * resulting memory is invalid, remember() throws its typed reason, NOTHING is
+ * committed, and the proposal row STAYS pending (the throw propagates before the
+ * delete). On success the memory is authored and the proposal row is removed.
+ *
+ * Throws UnknownProposalError if the id isn't in the queue.
+ */
+export declare function ratifyProposal(contextDir: string, id: number, overrides?: ProposalOverrides): Promise<MemoryRef>;

package/dist/backends/proposals.js

@@ -0,0 +1,182 @@
+/**
+ * Capture-propose queue — the loom-side staging area for drafted memory writes.
+ *
+ * THE INTEGRITY INVARIANT: a proposal is NOT authored canon. Proposals live in
+ * a SEPARATE table (`proposals`) and are INVISIBLE to recall / memory_list / the
+ * salience digest / find_similar. A background lane drafts memory writes here;
+ * Art ratifies them before they become real memories. There is no auto-commit —
+ * a proposal becomes canon only via an explicit `ratifyProposal`, which routes
+ * through the existing remember() tool path so it is validated like any write.
+ *
+ * This keeps loom's "one writer, authored" model intact while getting
+ * auto-capture ergonomics: drafts can be rough; ratification is the gate.
+ *
+ * The store is opened raw (like salience.ts) — no embedder needed for the
+ * staging table itself. Embedding happens at ratify-time, through remember().
+ */
+import { randomUUID } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import BetterSqlite3 from 'better-sqlite3';
+import { resolveSqliteDbPath } from '../config.js';
+import { runMigrations } from './migrations.js';
+import { remember } from '../tools/remember.js';
+import { retryWrite } from './retry.js';
+/** Thrown when a proposal id can't be found in the queue. */
+export class UnknownProposalError extends Error {
+    constructor(id) {
+        super(`proposal not found: ${id}`);
+        this.name = 'UnknownProposalError';
+    }
+}
+// ─── DB plumbing ──────────────────────────────────────────────────────────────
+function hasTable(db, table) {
+    const row = db
+        .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
+        .get(table);
+    return row !== undefined;
+}
+/**
+ * Open memories.db raw (no vector/embedder stack) and ensure the proposals
+ * table exists. Self-heals a store that predates the proposals migration —
+ * migrations are idempotent, so this is safe on any store.
+ */
+function openProposalsDb(contextDir) {
+    const dbPath = resolveSqliteDbPath(contextDir);
+    const db = new BetterSqlite3(dbPath);
+    db.pragma('busy_timeout = 0');
+    if (!hasTable(db, 'proposals'))
+        runMigrations(db, { strict: false });
+    return db;
+}
+// ─── Queue operations ─────────────────────────────────────────────────────────
+/**
+ * Stage a pending proposal. A draft can be rough, so this does NOT run the
+ * full validateMemoryInput gate — but it DOES require a non-empty
+ * title + content + category so the row is at least shaped like a memory.
+ * Hard validation is deferred to ratify.
+ */
+export function propose(contextDir, input) {
+    if (typeof input.title !== 'string' || input.title.trim() === '') {
+        throw new Error('proposal title is required and cannot be empty');
+    }
+    if (typeof input.content !== 'string' || input.content.trim() === '') {
+        throw new Error('proposal content is required and cannot be empty');
+    }
+    if (typeof input.category !== 'string' || input.category.trim() === '') {
+        throw new Error('proposal category is required and cannot be empty');
+    }
+    const db = openProposalsDb(contextDir);
+    try {
+        const uuid = randomUUID();
+        const created = new Date().toISOString();
+        const result = retryWrite(() => db
+            .prepare(`
+          INSERT INTO proposals (
+            uuid, category, title, content, project, ttl, metadata, source, created, status
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'pending')
+        `)
+            .run(uuid, input.category, input.title, input.content, input.project ?? null, input.ttl ?? null, JSON.stringify(input.metadata ?? {}), input.source ?? null, created));
+        return { id: Number(result.lastInsertRowid), uuid };
+    }
+    finally {
+        db.close();
+    }
+}
+/** All pending proposals, newest first. */
+export function listProposals(contextDir) {
+    const dbPath = resolveSqliteDbPath(contextDir);
+    if (!existsSync(dbPath))
+        return [];
+    const db = openProposalsDb(contextDir);
+    try {
+        return db
+            .prepare(`SELECT id, uuid, category, title, content, project, ttl, metadata, source, created, status
+         FROM proposals WHERE status = 'pending' ORDER BY id DESC`)
+            .all();
+    }
+    finally {
+        db.close();
+    }
+}
+/** Fetch a single proposal by id (any status), or null if not found. */
+export function getProposal(contextDir, id) {
+    const dbPath = resolveSqliteDbPath(contextDir);
+    if (!existsSync(dbPath))
+        return null;
+    const db = openProposalsDb(contextDir);
+    try {
+        const row = db
+            .prepare(`SELECT id, uuid, category, title, content, project, ttl, metadata, source, created, status
+         FROM proposals WHERE id = ?`)
+            .get(id);
+        return row ?? null;
+    }
+    finally {
+        db.close();
+    }
+}
+/** Delete a pending proposal. Returns false if no pending row with that id. */
+export function rejectProposal(contextDir, id) {
+    const dbPath = resolveSqliteDbPath(contextDir);
+    if (!existsSync(dbPath))
+        return false;
+    const db = openProposalsDb(contextDir);
+    try {
+        const result = retryWrite(() => db
+            .prepare("DELETE FROM proposals WHERE id = ? AND status = 'pending'")
+            .run(id));
+        return result.changes > 0;
+    }
+    finally {
+        db.close();
+    }
+}
+/**
+ * Ratify a pending proposal into a REAL memory.
+ *
+ * Loads the proposal, applies optional Art-on-accept overrides, then commits it
+ * via the existing remember() path — so validateMemoryInput runs. If the
+ * resulting memory is invalid, remember() throws its typed reason, NOTHING is
+ * committed, and the proposal row STAYS pending (the throw propagates before the
+ * delete). On success the memory is authored and the proposal row is removed.
+ *
+ * Throws UnknownProposalError if the id isn't in the queue.
+ */
+export async function ratifyProposal(contextDir, id, overrides = {}) {
+    const proposal = getProposal(contextDir, id);
+    if (!proposal)
+        throw new UnknownProposalError(id);
+    const metadata = parseMetadata(proposal.metadata);
+    // remember() validates (validateMemoryInput) and throws on an invalid write
+    // BEFORE anything is committed — so an invalid proposal is refused with its
+    // typed reason and, because the throw happens before the delete below, the
+    // proposal stays pending for a later fix.
+    const ref = await remember(contextDir, {
+        category: overrides.category ?? proposal.category ?? '',
+        title: overrides.title ?? proposal.title ?? '',
+        content: overrides.content ?? proposal.content ?? '',
+        project: overrides.project ?? proposal.project ?? undefined,
+        ttl: overrides.ttl ?? proposal.ttl ?? undefined,
+        metadata,
+    });
+    // Committed as canon — drop the staging row.
+    const db = openProposalsDb(contextDir);
+    try {
+        retryWrite(() => db.prepare('DELETE FROM proposals WHERE id = ?').run(id));
+    }
+    finally {
+        db.close();
+    }
+    return ref;
+}
+function parseMetadata(raw) {
+    if (!raw)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}

package/dist/backends/recall-log.d.ts

@@ -0,0 +1,42 @@
+import type { RecallObservation } from './types.js';
+export declare const RECALL_LOG_FILE = "recall.jsonl";
+export declare const QUERY_MAX_CHARS = 120;
+export declare function recallLogPath(contextDir: string): string;
+/** `LOOM_RECALL_LOG=0|off|false|no` disables the log; anything else (or unset) keeps it on. */
+export declare function isRecallLogEnabled(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Append one observation. Synchronous and cheap (one appendFileSync);
+ * creates the telemetry dir on first write; swallows every error.
+ */
+export declare function appendRecallObservation(contextDir: string, obs: RecallObservation, env?: NodeJS.ProcessEnv): void;
+/** Read observations, oldest first. Malformed lines are skipped. */
+export declare function readRecallObservations(contextDir: string, opts?: {
+    since?: Date;
+}): RecallObservation[];
+/** Parse a `--since` window like "30m", "24h", "7d", "2w" into milliseconds. */
+export declare function parseSinceDuration(spec: string): number;
+export interface RecallMiss {
+    ts: string;
+    tool: RecallObservation['tool'];
+    query: string;
+    category?: string;
+    project?: string;
+    candidates: number;
+}
+export interface RecallStats {
+    searches: number;
+    hits: number;
+    misses: number;
+    /** hits / searches, or null when there were no searches. */
+    hitRate: number | null;
+    medianLatencyMs: number | null;
+    /** Median of topScore over hits, or null when there were none. */
+    medianTopScore: number | null;
+    diversityDrops: number;
+    /** Newest first, capped at `recentMisses` (default 10). */
+    recentMisses: RecallMiss[];
+}
+export declare function summarizeRecallObservations(rows: RecallObservation[], opts?: {
+    recentMisses?: number;
+}): RecallStats;
+export declare function formatRecallStats(stats: RecallStats, windowLabel: string): string;