@melra/storage-sqlite 0.3.0-alpha.10

package/dist/index.js

@@ -0,0 +1,735 @@
+// Copyright 2026 XAGI Labs Private Limited
+// SPDX-License-Identifier: Apache-2.0
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { EncryptedPayloadSchema, WorkflowDefinitionSchema, WorkflowEventSchema, WorkflowRunSchema, WorkflowSnapshotSchema, } from "@melra/protocol";
+function toMemoryRecord(row) {
+    return {
+        id: row.id,
+        scope: row.scope,
+        key: row.key,
+        value: row.value,
+        source: row.source,
+        confidence: row.confidence,
+        tags: JSON.parse(row.tags),
+        ...(row.speaker === null ? {} : { speaker: row.speaker }),
+        ...(row.episodeId === null ? {} : { episodeId: row.episodeId }),
+        ...(row.sequence === null ? {} : { sequence: row.sequence }),
+        ...(row.expiresAt === null ? {} : { expiresAt: row.expiresAt }),
+        ...(row.supersedesId === null ? {} : { supersedesId: row.supersedesId }),
+        ...(row.supersededBy === null ? {} : { supersededBy: row.supersededBy }),
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+    };
+}
+function parseStored(data, schema, error) {
+    try {
+        return schema.parse(JSON.parse(data));
+    }
+    catch {
+        throw new Error(error);
+    }
+}
+export class SqliteStore {
+    path;
+    database;
+    constructor(path) {
+        this.path = path;
+        if (path !== ":memory:")
+            mkdirSync(dirname(path), { recursive: true });
+        this.database = new DatabaseSync(path);
+        this.database.exec("PRAGMA busy_timeout = 5000");
+        this.database.exec("PRAGMA journal_mode = WAL");
+        this.database.exec("PRAGMA foreign_keys = ON");
+        this.migrate();
+    }
+    migrate() {
+        this.database.exec(`
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        data TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS receipts (
+        id TEXT PRIMARY KEY,
+        task_id TEXT NOT NULL,
+        data TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS receipts_task_id ON receipts(task_id);
+      CREATE TABLE IF NOT EXISTS certificates (
+        id TEXT PRIMARY KEY,
+        task_id TEXT NOT NULL UNIQUE,
+        data TEXT NOT NULL,
+        created_at TEXT NOT NULL
+      );
+      CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        scope TEXT NOT NULL,
+        key TEXT NOT NULL,
+        value TEXT NOT NULL,
+        source TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        tags TEXT NOT NULL DEFAULT '[]',
+        speaker TEXT,
+        episode_id TEXT,
+        sequence INTEGER,
+        expires_at TEXT,
+        supersedes_id TEXT,
+        superseded_by TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS memories_scope ON memories(scope);
+      CREATE INDEX IF NOT EXISTS memories_key ON memories(key);
+    `);
+        this.addColumnIfMissing("memories", "tags", "TEXT NOT NULL DEFAULT '[]'");
+        this.addColumnIfMissing("memories", "speaker", "TEXT");
+        this.addColumnIfMissing("memories", "episode_id", "TEXT");
+        this.addColumnIfMissing("memories", "sequence", "INTEGER");
+        this.addColumnIfMissing("memories", "expires_at", "TEXT");
+        this.addColumnIfMissing("memories", "supersedes_id", "TEXT");
+        this.addColumnIfMissing("memories", "superseded_by", "TEXT");
+        this.database.exec(`
+      CREATE INDEX IF NOT EXISTS memories_expiry ON memories(expires_at);
+      CREATE INDEX IF NOT EXISTS memories_superseded_by ON memories(superseded_by);
+      CREATE INDEX IF NOT EXISTS memories_episode_sequence
+        ON memories(episode_id, sequence);
+    `);
+        this.transaction(() => {
+            this.database.exec(`
+        CREATE TABLE IF NOT EXISTS schema_migrations (
+          version INTEGER PRIMARY KEY,
+          applied_at TEXT NOT NULL
+        );
+      `);
+            const applied = this.database
+                .prepare("SELECT version FROM schema_migrations WHERE version = 1")
+                .get();
+            if (applied !== undefined)
+                return;
+            this.database.exec(`
+        CREATE TABLE IF NOT EXISTS task_payloads (
+          task_id TEXT PRIMARY KEY,
+          request_payload TEXT NOT NULL,
+          result_payload TEXT,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+        CREATE TABLE IF NOT EXISTS workflow_payloads (
+          workflow_id TEXT NOT NULL,
+          workflow_version INTEGER NOT NULL,
+          payload TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          PRIMARY KEY(workflow_id, workflow_version)
+        );
+        CREATE TABLE IF NOT EXISTS workflow_definitions (
+          id TEXT NOT NULL,
+          version INTEGER NOT NULL,
+          data TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          PRIMARY KEY(id, version)
+        );
+        CREATE TABLE IF NOT EXISTS workflow_runs (
+          id TEXT PRIMARY KEY,
+          definition_id TEXT NOT NULL,
+          definition_version INTEGER NOT NULL,
+          state_version INTEGER NOT NULL,
+          data TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+        CREATE TABLE IF NOT EXISTS workflow_events (
+          id TEXT PRIMARY KEY,
+          aggregate_id TEXT NOT NULL,
+          sequence INTEGER NOT NULL,
+          trace_id TEXT NOT NULL,
+          type TEXT NOT NULL,
+          data TEXT NOT NULL,
+          occurred_at TEXT NOT NULL,
+          UNIQUE(aggregate_id, sequence)
+        );
+        CREATE INDEX IF NOT EXISTS workflow_events_aggregate
+          ON workflow_events(aggregate_id, sequence);
+        CREATE TABLE IF NOT EXISTS workflow_snapshots (
+          workflow_id TEXT NOT NULL,
+          sequence INTEGER NOT NULL,
+          data TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          PRIMARY KEY(workflow_id, sequence)
+        );
+        CREATE TABLE IF NOT EXISTS idempotency_commits (
+          idempotency_key TEXT PRIMARY KEY,
+          task_id TEXT NOT NULL,
+          attempt INTEGER NOT NULL,
+          committed_at TEXT NOT NULL
+        );
+      `);
+            this.database
+                .prepare("INSERT INTO schema_migrations(version, applied_at) VALUES (1, ?)")
+                .run(new Date().toISOString());
+        });
+        // Migration 2 adds cross-process advance leases. Schema changes get a new
+        // migration rather than an edit to the version-1 statements above.
+        this.applyMigration(2, `
+      CREATE TABLE IF NOT EXISTS workflow_leases (
+        workflow_id TEXT PRIMARY KEY,
+        owner TEXT NOT NULL,
+        acquired_at TEXT NOT NULL,
+        expires_at TEXT NOT NULL
+      );
+    `);
+    }
+    applyMigration(version, statements) {
+        this.transaction(() => {
+            const applied = this.database
+                .prepare("SELECT version FROM schema_migrations WHERE version = ?")
+                .get(version);
+            if (applied !== undefined)
+                return;
+            this.database.exec(statements);
+            this.database
+                .prepare("INSERT INTO schema_migrations(version, applied_at) VALUES (?, ?)")
+                .run(version, new Date().toISOString());
+        });
+    }
+    transaction(action) {
+        this.database.exec("BEGIN IMMEDIATE");
+        try {
+            const result = action();
+            this.database.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            this.database.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    addColumnIfMissing(table, column, definition) {
+        const columns = this.database
+            .prepare(`PRAGMA table_info(${table})`)
+            .all();
+        if (!columns.some((entry) => entry.name === column)) {
+            this.database.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+        }
+    }
+    saveTask(task) {
+        this.database
+            .prepare(`
+        INSERT INTO tasks(id, data, created_at, updated_at)
+        VALUES (?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET data = excluded.data, updated_at = excluded.updated_at
+      `)
+            .run(task.id, JSON.stringify(task), task.createdAt, task.updatedAt);
+    }
+    getTask(id) {
+        const row = this.database
+            .prepare("SELECT data FROM tasks WHERE id = ?")
+            .get(id);
+        return row === undefined ? undefined : JSON.parse(row.data);
+    }
+    listTasks(limit = 50) {
+        const rows = this.database
+            .prepare("SELECT data FROM tasks ORDER BY updated_at DESC LIMIT ?")
+            .all(limit);
+        return rows.map((row) => JSON.parse(row.data));
+    }
+    saveTaskPayload(taskId, payload, at) {
+        const parsed = EncryptedPayloadSchema.parse(payload);
+        this.database
+            .prepare(`
+        INSERT INTO task_payloads(
+          task_id, request_payload, result_payload, created_at, updated_at
+        )
+        VALUES (?, ?, NULL, ?, ?)
+        ON CONFLICT(task_id) DO UPDATE SET
+          request_payload = excluded.request_payload,
+          updated_at = excluded.updated_at
+      `)
+            .run(taskId, JSON.stringify(parsed), at, at);
+    }
+    getTaskPayload(taskId) {
+        const row = this.database
+            .prepare("SELECT request_payload AS data FROM task_payloads WHERE task_id = ?")
+            .get(taskId);
+        return row === undefined
+            ? undefined
+            : parseStored(row.data, EncryptedPayloadSchema, "stored_task_payload_invalid");
+    }
+    saveTaskExecutionResult(task, payload) {
+        const parsed = EncryptedPayloadSchema.parse(payload);
+        this.transaction(() => {
+            this.saveTask(task);
+            const result = this.database
+                .prepare(`
+          UPDATE task_payloads
+          SET result_payload = ?, updated_at = ?
+          WHERE task_id = ?
+        `)
+                .run(JSON.stringify(parsed), task.updatedAt, task.id);
+            if (Number(result.changes) !== 1) {
+                throw new Error("task_payload_not_found");
+            }
+        });
+    }
+    getTaskResult(taskId) {
+        const row = this.database
+            .prepare("SELECT result_payload AS data FROM task_payloads WHERE task_id = ?")
+            .get(taskId);
+        return row === undefined || row.data === null
+            ? undefined
+            : parseStored(row.data, EncryptedPayloadSchema, "stored_task_result_invalid");
+    }
+    deleteTaskPayload(taskId) {
+        this.database
+            .prepare("DELETE FROM task_payloads WHERE task_id = ?")
+            .run(taskId);
+    }
+    listInterruptedTasks() {
+        const rows = this.database
+            .prepare(`
+        SELECT data FROM tasks
+        WHERE json_extract(data, '$.status') IN ('running', 'verifying')
+        ORDER BY updated_at
+      `)
+            .all();
+        return rows.map((row) => JSON.parse(row.data));
+    }
+    getWorkflowPayload(id, version) {
+        const row = this.database
+            .prepare(`
+        SELECT payload AS data FROM workflow_payloads
+        WHERE workflow_id = ? AND workflow_version = ?
+      `)
+            .get(id, version);
+        return row === undefined
+            ? undefined
+            : parseStored(row.data, EncryptedPayloadSchema, "stored_workflow_payload_invalid");
+    }
+    createWorkflow(redactedDefinition, payload, run, events) {
+        const definition = WorkflowDefinitionSchema.parse(redactedDefinition);
+        const sealed = EncryptedPayloadSchema.parse(payload);
+        const projection = WorkflowRunSchema.parse(run);
+        const parsedEvents = events.map((item) => WorkflowEventSchema.parse(item));
+        if (definition.id !== projection.definitionId ||
+            definition.version !== projection.definitionVersion) {
+            throw new Error("workflow_definition_mismatch");
+        }
+        this.assertWorkflowEvents(projection.id, projection.traceId, 0, projection.stateVersion, parsedEvents);
+        this.transaction(() => {
+            this.database
+                .prepare(`
+          INSERT INTO workflow_definitions(id, version, data, created_at)
+          VALUES (?, ?, ?, ?)
+        `)
+                .run(definition.id, definition.version, JSON.stringify(definition), projection.createdAt);
+            this.database
+                .prepare(`
+          INSERT INTO workflow_payloads(
+            workflow_id, workflow_version, payload, created_at
+          )
+          VALUES (?, ?, ?, ?)
+        `)
+                .run(definition.id, definition.version, JSON.stringify(sealed), projection.createdAt);
+            this.database
+                .prepare(`
+          INSERT INTO workflow_runs(
+            id, definition_id, definition_version, state_version, data,
+            created_at, updated_at
+          )
+          VALUES (?, ?, ?, ?, ?, ?, ?)
+        `)
+                .run(projection.id, projection.definitionId, projection.definitionVersion, projection.stateVersion, JSON.stringify(projection), projection.createdAt, projection.updatedAt);
+            for (const item of parsedEvents)
+                this.insertWorkflowEvent(item);
+        });
+    }
+    getWorkflowDefinition(id, version) {
+        const row = this.database
+            .prepare(`
+        SELECT data FROM workflow_definitions WHERE id = ? AND version = ?
+      `)
+            .get(id, version);
+        return row === undefined
+            ? undefined
+            : parseStored(row.data, WorkflowDefinitionSchema, "stored_workflow_definition_invalid");
+    }
+    getWorkflowRun(id) {
+        const row = this.database
+            .prepare("SELECT data FROM workflow_runs WHERE id = ?")
+            .get(id);
+        return row === undefined
+            ? undefined
+            : parseStored(row.data, WorkflowRunSchema, "stored_workflow_run_invalid");
+    }
+    listWorkflowRuns(statuses = []) {
+        const rows = statuses.length === 0
+            ? this.database
+                .prepare("SELECT data FROM workflow_runs ORDER BY updated_at")
+                .all()
+            : this.database
+                .prepare(`
+              SELECT data FROM workflow_runs
+              WHERE json_extract(data, '$.status') IN (
+                ${statuses.map(() => "?").join(", ")}
+              )
+              ORDER BY updated_at
+            `)
+                .all(...statuses);
+        return rows.map((row) => parseStored(row.data, WorkflowRunSchema, "stored_workflow_run_invalid"));
+    }
+    listWorkflowEvents(id, afterSequence = 0) {
+        const rows = this.database
+            .prepare(`
+        SELECT data FROM workflow_events
+        WHERE aggregate_id = ? AND sequence > ?
+        ORDER BY sequence
+      `)
+            .all(id, afterSequence);
+        return rows.map((row) => parseStored(row.data, WorkflowEventSchema, "stored_workflow_event_invalid"));
+    }
+    saveWorkflowSnapshot(snapshot) {
+        const parsed = WorkflowSnapshotSchema.parse(snapshot);
+        this.database
+            .prepare(`
+        INSERT INTO workflow_snapshots(
+          workflow_id, sequence, data, created_at
+        )
+        VALUES (?, ?, ?, ?)
+      `)
+            .run(parsed.workflowId, parsed.sequence, JSON.stringify(parsed), parsed.createdAt);
+    }
+    getLatestWorkflowSnapshot(id) {
+        const row = this.database
+            .prepare(`
+        SELECT data FROM workflow_snapshots
+        WHERE workflow_id = ?
+        ORDER BY sequence DESC
+        LIMIT 1
+      `)
+            .get(id);
+        return row === undefined
+            ? undefined
+            : parseStored(row.data, WorkflowSnapshotSchema, "stored_workflow_snapshot_invalid");
+    }
+    transitionWorkflow(id, expectedStateVersion, run, events) {
+        const projection = WorkflowRunSchema.parse(run);
+        const parsedEvents = events.map((item) => WorkflowEventSchema.parse(item));
+        this.assertWorkflowEvents(id, projection.traceId, expectedStateVersion, projection.stateVersion, parsedEvents);
+        if (projection.id !== id)
+            throw new Error("workflow_projection_id_mismatch");
+        this.transaction(() => {
+            const current = this.database
+                .prepare(`SELECT state_version AS stateVersion, data
+           FROM workflow_runs WHERE id = ?`)
+                .get(id);
+            if (current === undefined)
+                throw new Error("workflow_not_found");
+            if (current.stateVersion !== expectedStateVersion) {
+                throw new Error("workflow_state_conflict");
+            }
+            const stored = parseStored(current.data, WorkflowRunSchema, "stored_workflow_run_invalid");
+            if (projection.definitionId !== stored.definitionId ||
+                projection.definitionVersion !== stored.definitionVersion ||
+                projection.traceId !== stored.traceId) {
+                throw new Error("workflow_projection_identity_mismatch");
+            }
+            for (const item of parsedEvents)
+                this.insertWorkflowEvent(item);
+            const updated = this.database
+                .prepare(`
+          UPDATE workflow_runs
+          SET state_version = ?, data = ?, updated_at = ?
+          WHERE id = ? AND state_version = ?
+        `)
+                .run(projection.stateVersion, JSON.stringify(projection), projection.updatedAt, id, expectedStateVersion);
+            if (Number(updated.changes) !== 1) {
+                throw new Error("workflow_state_conflict");
+            }
+        });
+    }
+    // Cross-process mutual exclusion for one workflow. `BEGIN IMMEDIATE` in
+    // `transaction` takes SQLite's write lock, so two server processes sharing a
+    // data directory serialize here and exactly one wins the row. Leases expire
+    // so a killed process cannot strand a workflow forever.
+    acquireWorkflowLease(workflowId, owner, now, expiresAt) {
+        return this.transaction(() => {
+            const existing = this.database
+                .prepare(`SELECT owner, expires_at AS expiresAt
+           FROM workflow_leases WHERE workflow_id = ?`)
+                .get(workflowId);
+            if (existing !== undefined &&
+                existing.owner !== owner &&
+                existing.expiresAt > now) {
+                return false;
+            }
+            this.database
+                .prepare(`
+          INSERT INTO workflow_leases(
+            workflow_id, owner, acquired_at, expires_at
+          )
+          VALUES (?, ?, ?, ?)
+          ON CONFLICT(workflow_id) DO UPDATE SET
+            owner = excluded.owner,
+            acquired_at = excluded.acquired_at,
+            expires_at = excluded.expires_at
+        `)
+                .run(workflowId, owner, now, expiresAt);
+            return true;
+        });
+    }
+    renewWorkflowLease(workflowId, owner, expiresAt) {
+        const result = this.database
+            .prepare(`UPDATE workflow_leases SET expires_at = ?
+         WHERE workflow_id = ? AND owner = ?`)
+            .run(expiresAt, workflowId, owner);
+        return Number(result.changes) === 1;
+    }
+    releaseWorkflowLease(workflowId, owner) {
+        this.database
+            .prepare("DELETE FROM workflow_leases WHERE workflow_id = ? AND owner = ?")
+            .run(workflowId, owner);
+    }
+    getWorkflowLease(workflowId) {
+        return this.database
+            .prepare(`
+        SELECT owner, acquired_at AS acquiredAt, expires_at AS expiresAt
+        FROM workflow_leases WHERE workflow_id = ?
+      `)
+            .get(workflowId);
+    }
+    commitIdempotency(key, taskId, attempt, at) {
+        const result = this.database
+            .prepare(`
+        INSERT OR IGNORE INTO idempotency_commits(
+          idempotency_key, task_id, attempt, committed_at
+        )
+        VALUES (?, ?, ?, ?)
+      `)
+            .run(key, taskId, attempt, at);
+        return Number(result.changes) === 1;
+    }
+    getIdempotencyCommit(key) {
+        return this.database
+            .prepare(`
+        SELECT task_id AS taskId, attempt, committed_at AS committedAt
+        FROM idempotency_commits
+        WHERE idempotency_key = ?
+      `)
+            .get(key);
+    }
+    assertWorkflowEvents(workflowId, traceId, previousStateVersion, nextStateVersion, events) {
+        if (events.some((item) => item.aggregateId !== workflowId || item.traceId !== traceId)) {
+            throw new Error("workflow_event_identity_invalid");
+        }
+        if (events.length === 0 ||
+            nextStateVersion !== previousStateVersion + events.length ||
+            events.some((item, index) => item.sequence !== previousStateVersion + index + 1)) {
+            throw new Error("workflow_event_sequence_invalid");
+        }
+    }
+    insertWorkflowEvent(event) {
+        this.database
+            .prepare(`
+        INSERT INTO workflow_events(
+          id, aggregate_id, sequence, trace_id, type, data, occurred_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `)
+            .run(event.id, event.aggregateId, event.sequence, event.traceId, event.type, JSON.stringify(event), event.occurredAt);
+    }
+    saveReceipt(receipt) {
+        this.database
+            .prepare(`
+        INSERT INTO receipts(id, task_id, data, created_at)
+        VALUES (?, ?, ?, ?)
+      `)
+            .run(receipt.receiptId, receipt.taskId, JSON.stringify(receipt), receipt.endedAt);
+    }
+    getReceipt(id) {
+        const row = this.database
+            .prepare("SELECT data FROM receipts WHERE id = ?")
+            .get(id);
+        return row === undefined ? undefined : JSON.parse(row.data);
+    }
+    getReceiptsForTask(taskId) {
+        const rows = this.database
+            .prepare("SELECT data FROM receipts WHERE task_id = ? ORDER BY created_at")
+            .all(taskId);
+        return rows.map((row) => JSON.parse(row.data));
+    }
+    saveCertificate(certificate) {
+        this.database
+            .prepare(`
+        INSERT INTO certificates(id, task_id, data, created_at)
+        VALUES (?, ?, ?, ?)
+        ON CONFLICT(task_id) DO UPDATE SET
+          id = excluded.id,
+          data = excluded.data,
+          created_at = excluded.created_at
+      `)
+            .run(certificate.certificateId, certificate.taskId, JSON.stringify(certificate), certificate.createdAt);
+    }
+    getCertificateForTask(taskId) {
+        const row = this.database
+            .prepare("SELECT data FROM certificates WHERE task_id = ?")
+            .get(taskId);
+        return row === undefined
+            ? undefined
+            : JSON.parse(row.data);
+    }
+    putMemory(memory) {
+        this.database
+            .prepare(`
+        INSERT INTO memories(
+          id, scope, key, value, source, confidence, tags, speaker, episode_id,
+          sequence, expires_at, supersedes_id, superseded_by, created_at,
+          updated_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(id) DO UPDATE SET
+          scope = excluded.scope,
+          key = excluded.key,
+          value = excluded.value,
+          source = excluded.source,
+          confidence = excluded.confidence,
+          tags = excluded.tags,
+          speaker = excluded.speaker,
+          episode_id = excluded.episode_id,
+          sequence = excluded.sequence,
+          expires_at = excluded.expires_at,
+          supersedes_id = excluded.supersedes_id,
+          superseded_by = excluded.superseded_by,
+          updated_at = excluded.updated_at
+      `)
+            .run(memory.id, memory.scope, memory.key, memory.value, memory.source, memory.confidence, JSON.stringify(memory.tags), memory.speaker ?? null, memory.episodeId ?? null, memory.sequence ?? null, memory.expiresAt ?? null, memory.supersedesId ?? null, memory.supersededBy ?? null, memory.createdAt, memory.updatedAt);
+    }
+    getMemory(id) {
+        const row = this.database
+            .prepare(`
+        SELECT id, scope, key, value, source, confidence, tags, speaker,
+               episode_id AS episodeId, sequence,
+               expires_at AS expiresAt, supersedes_id AS supersedesId,
+               superseded_by AS supersededBy,
+               created_at AS createdAt, updated_at AS updatedAt
+        FROM memories WHERE id = ?
+      `)
+            .get(id);
+        return row === undefined ? undefined : toMemoryRecord(row);
+    }
+    listMemories(scope, limit, includeSuperseded = false) {
+        const rows = this.database
+            .prepare(`
+        SELECT id, scope, key, value, source, confidence, tags, speaker,
+               episode_id AS episodeId, sequence,
+               expires_at AS expiresAt, supersedes_id AS supersedesId,
+               superseded_by AS supersededBy,
+               created_at AS createdAt, updated_at AS updatedAt
+        FROM memories
+        WHERE scope = ?
+          AND (expires_at IS NULL OR expires_at > ?)
+          AND (? = 1 OR superseded_by IS NULL)
+        ORDER BY updated_at DESC
+        LIMIT ?
+      `)
+            .all(scope, new Date().toISOString(), includeSuperseded ? 1 : 0, limit);
+        return rows.map(toMemoryRecord);
+    }
+    memoryCandidates(scope, limit, includeSuperseded = false) {
+        const rows = this.database
+            .prepare(`
+        SELECT id, scope, key, value, source, confidence, tags, speaker,
+               episode_id AS episodeId, sequence,
+               expires_at AS expiresAt, supersedes_id AS supersedesId,
+               superseded_by AS supersededBy,
+               created_at AS createdAt, updated_at AS updatedAt
+        FROM memories
+        WHERE scope = ?
+          AND (expires_at IS NULL OR expires_at > ?)
+          AND (? = 1 OR superseded_by IS NULL)
+        ORDER BY updated_at DESC
+        LIMIT ?
+      `)
+            .all(scope, new Date().toISOString(), includeSuperseded ? 1 : 0, limit);
+        return rows.map(toMemoryRecord);
+    }
+    supersedeMemory(id, scope, supersededBy) {
+        const result = this.database
+            .prepare(`
+        UPDATE memories
+        SET superseded_by = ?, updated_at = ?
+        WHERE id = ? AND scope = ? AND superseded_by IS NULL
+      `)
+            .run(supersededBy, new Date().toISOString(), id, scope);
+        return Number(result.changes) > 0;
+    }
+    deleteMemory(id, scope) {
+        const result = this.database
+            .prepare("DELETE FROM memories WHERE id = ? AND scope = ?")
+            .run(id, scope);
+        return Number(result.changes) > 0;
+    }
+    clearMemories(scope) {
+        const result = this.database
+            .prepare("DELETE FROM memories WHERE scope = ?")
+            .run(scope);
+        return Number(result.changes);
+    }
+    /**
+     * Reclaim memory rows that no read path can return.
+     *
+     * `listMemories` and `memoryCandidates` both filter out expired rows, and
+     * filter out superseded ones unless asked for them, but nothing ever deleted
+     * either — so a long-lived install grew forever while the searchable set
+     * stayed the same size. This deletes what is already unreachable.
+     *
+     * `maxPerScope` is different in kind and defaults to off: it evicts *live*
+     * memories, which is data the caller stored and can still read. An operator
+     * who wants a hard ceiling opts into one.
+     *
+     * A superseded row is only dropped once nothing live points at it, so
+     * `supersedes_id` never dangles and a chain is removed from its tail
+     * inwards across successive compactions.
+     */
+    compactMemories(scope, retention, now = new Date()) {
+        const nowIso = now.toISOString();
+        const cutoff = new Date(now.getTime() - retention.maxAgeDays * 86_400_000).toISOString();
+        return this.transaction(() => {
+            const expired = Number(this.database
+                .prepare("DELETE FROM memories WHERE scope = ? AND expires_at IS NOT NULL AND expires_at <= ?")
+                .run(scope, nowIso).changes);
+            const superseded = Number(this.database
+                .prepare(`
+            DELETE FROM memories
+            WHERE scope = ?
+              AND superseded_by IS NOT NULL
+              AND updated_at <= ?
+              AND id NOT IN (
+                SELECT supersedes_id FROM memories
+                WHERE scope = ? AND supersedes_id IS NOT NULL AND superseded_by IS NULL
+              )
+          `)
+                .run(scope, cutoff, scope).changes);
+            const evicted = retention.maxPerScope <= 0
+                ? 0
+                : Number(this.database
+                    .prepare(`
+                  DELETE FROM memories
+                  WHERE scope = ? AND superseded_by IS NULL AND id NOT IN (
+                    SELECT id FROM memories
+                    WHERE scope = ? AND superseded_by IS NULL
+                    ORDER BY updated_at DESC, id DESC
+                    LIMIT ?
+                  )
+                `)
+                    .run(scope, scope, retention.maxPerScope).changes);
+            return { expired, superseded, evicted };
+        });
+    }
+    close() {
+        this.database.close();
+    }
+}
+//# sourceMappingURL=index.js.map