hippo-memory 1.60.0 → 1.61.0

package/dist/db/meta.d.ts

@@ -0,0 +1,8 @@
+import type { DatabaseSyncLike } from './sqlite.js';
+export declare function ensureMetaTable(db: DatabaseSyncLike): void;
+export declare function getSchemaVersion(db: DatabaseSyncLike): number;
+export declare function setSchemaVersion(db: DatabaseSyncLike, version: number): void;
+export declare function getMeta(db: DatabaseSyncLike, key: string, fallback?: string): string;
+export declare function setMeta(db: DatabaseSyncLike, key: string, value: string): void;
+export declare function isFtsAvailable(db: DatabaseSyncLike): boolean;
+//# sourceMappingURL=meta.d.ts.map

package/dist/db/meta.js

@@ -0,0 +1,35 @@
+import { tableExists } from './tables.js';
+export function ensureMetaTable(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+}
+export function getSchemaVersion(db) {
+    if (!tableExists(db, 'meta'))
+        return 0;
+    // SAFETY: row's shape matches the single `value` column named in the
+    // SELECT above.
+    const row = db.prepare(`SELECT value FROM meta WHERE key = 'schema_version'`).get();
+    const version = Number(row?.value ?? 0);
+    return Number.isFinite(version) ? version : 0;
+}
+export function setSchemaVersion(db, version) {
+    db.prepare(`INSERT INTO meta(key, value) VALUES('schema_version', ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`).run(String(version));
+    db.exec(`PRAGMA user_version = ${Math.max(0, Math.trunc(version))}`);
+}
+export function getMeta(db, key, fallback = '') {
+    // SAFETY: row's shape matches the single `value` column named in the
+    // SELECT above.
+    const row = db.prepare(`SELECT value FROM meta WHERE key = ?`).get(key);
+    return row?.value ?? fallback;
+}
+export function setMeta(db, key, value) {
+    db.prepare(`INSERT INTO meta(key, value) VALUES(?, ?) ON CONFLICT(key) DO UPDATE SET value=excluded.value`).run(key, value);
+}
+export function isFtsAvailable(db) {
+    return getMeta(db, 'fts5_available', '0') === '1';
+}
+//# sourceMappingURL=meta.js.map

package/dist/db/migrate.d.ts

@@ -0,0 +1,9 @@
+import type { DatabaseSyncLike } from './sqlite.js';
+export declare function getCurrentSchemaVersion(): number;
+/** Thrown by {@link assertBinaryCompatible}; doctor uses it to pick the upgrade fix over a generic permissions fix. */
+export declare class IncompatibleBinaryError extends Error {
+}
+/** Refuse a store stamped for a newer binary. Fails closed: runMigrations creates meta first, so a failed read is a real error. */
+export declare function assertBinaryCompatible(db: DatabaseSyncLike): void;
+export declare function runMigrations(db: DatabaseSyncLike, hippoRoot?: string, busyWaitMs?: number): void;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/db/migrate.js

@@ -0,0 +1,138 @@
+import { PACKAGE_VERSION, compareSemver } from '../version.js';
+import { log } from '../log.js';
+import { importLegacyEmbeddingIndex } from '../vector-store.js';
+import { execWithBusyRetry } from './busy.js';
+import { tableExists } from './tables.js';
+import { ensureMetaTable, getMeta, getSchemaVersion, setMeta, setSchemaVersion } from './meta.js';
+import { ensureContinuityIndexes, ensureContinuityTables } from './continuity.js';
+import { CURRENT_SCHEMA_VERSION, MIGRATIONS } from './migrations/index.js';
+export function getCurrentSchemaVersion() {
+    return CURRENT_SCHEMA_VERSION;
+}
+/** Thrown by {@link assertBinaryCompatible}; doctor uses it to pick the upgrade fix over a generic permissions fix. */
+export class IncompatibleBinaryError extends Error {
+}
+/** Refuse a store stamped for a newer binary. Fails closed: runMigrations creates meta first, so a failed read is a real error. */
+export function assertBinaryCompatible(db) {
+    const minRequired = getMeta(db, 'min_compatible_binary');
+    if (minRequired && compareSemver(minRequired, PACKAGE_VERSION) > 0) {
+        throw new IncompatibleBinaryError(`hippo-memory: this database requires hippo-memory >= ${minRequired}, but the running binary is ${PACKAGE_VERSION}. ` +
+            `Upgrade hippo-memory to open it; an older binary does not know this schema and could expose private rows or damage the store.`);
+    }
+}
+export function runMigrations(db, hippoRoot, busyWaitMs) {
+    ensureMetaTable(db);
+    // Before anything writes, so a stale binary never repairs or migrates a store it does not understand.
+    assertBinaryCompatible(db);
+    let currentVersion = getSchemaVersion(db);
+    if (currentVersion > 0)
+        ensureContinuityTables(db);
+    for (const migration of MIGRATIONS) {
+        if (migration.version <= currentVersion)
+            continue;
+        execWithBusyRetry(db, 'BEGIN IMMEDIATE', busyWaitMs);
+        try {
+            // A newer binary may have migrated and raised the minimum while we waited for the lock.
+            assertBinaryCompatible(db);
+            // Re-read under the write lock: another process may have applied this
+            // migration while we waited, and re-running one is not idempotent.
+            const applied = getSchemaVersion(db);
+            if (applied >= migration.version) {
+                db.exec('COMMIT');
+                currentVersion = applied;
+                continue;
+            }
+            migration.up(db, { hippoRoot });
+            setSchemaVersion(db, migration.version);
+            db.exec('COMMIT');
+            currentVersion = migration.version;
+        }
+        catch (error) {
+            try {
+                db.exec('ROLLBACK');
+            }
+            catch { /* already rolled back; keep the original error */ }
+            throw error;
+        }
+    }
+    ensureContinuityIndexes(db);
+    ensureMetaDefaults(db);
+    ensureOptionalFts(db);
+    if (hippoRoot)
+        importLegacyVectors(db, hippoRoot);
+}
+// A failed import leaves embeddings.json in place for the next open to retry; the store still opens.
+function importLegacyVectors(db, hippoRoot) {
+    try {
+        importLegacyEmbeddingIndex(db, hippoRoot);
+    }
+    catch (err) {
+        log.warn(`embeddings.json import failed; the next open retries it (${err instanceof Error ? err.message : String(err)})`, { hippoRoot });
+    }
+}
+function ensureMetaDefaults(db) {
+    const defaults = [
+        ['schema_version', String(CURRENT_SCHEMA_VERSION)],
+        ['last_retrieval_ids', '[]'],
+        ['last_trace_id', ''],
+        ['total_remembered', '0'],
+        ['total_recalled', '0'],
+        ['total_forgotten', '0'],
+        ['fts5_available', '0'],
+    ];
+    // Read-first: an already-current store has all 7 keys, so this is one
+    // SELECT and zero writes instead of 7 no-op INSERT OR IGNOREs, each of
+    // which takes a RESERVED lock even when nothing changes.
+    const keys = defaults.map(([key]) => key);
+    const present = new Set(db
+        .prepare(`SELECT key FROM meta WHERE key IN (${keys.map(() => '?').join(',')})`)
+        .all(...keys)
+        .map((r) => r.key));
+    if (present.size === defaults.length)
+        return;
+    const stmt = db.prepare(`INSERT OR IGNORE INTO meta(key, value) VALUES (?, ?)`);
+    for (const [key, value] of defaults) {
+        if (!present.has(key))
+            stmt.run(key, value);
+    }
+}
+function ensureOptionalFts(db) {
+    let available = false;
+    try {
+        db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(id UNINDEXED, content, tags)`);
+        backfillFtsIndex(db);
+        available = true;
+    }
+    catch (err) {
+        log.warn(`full-text index unavailable (${err instanceof Error ? err.message : String(err)}); search falls back to slower LIKE matching`);
+    }
+    // Read-first: only write when the flag actually changed, so a healthy
+    // store's open doesn't take a write lock for a same-value upsert.
+    const flag = available ? '1' : '0';
+    if (getMeta(db, 'fts5_available') !== flag)
+        setMeta(db, 'fts5_available', flag);
+}
+function backfillFtsIndex(db) {
+    // SAFETY: this get() result's shape matches the single aliased `c` column
+    // named in the SELECT above.
+    const memCount = db.prepare(`SELECT COUNT(*) AS c FROM memories`).get()?.c ?? 0;
+    // SAFETY: this get() result's shape matches the single aliased `c` column named in the SELECT above.
+    // memories_fts_docsize is FTS5's cheaper one-row-per-document shadow table; fall back for a foreign-built index.
+    const ftsTable = tableExists(db, 'memories_fts_docsize') ? 'memories_fts_docsize' : 'memories_fts';
+    const ftsCount = db.prepare(`SELECT COUNT(*) AS c FROM ${ftsTable}`).get()?.c ?? 0;
+    if (memCount === ftsCount)
+        return;
+    db.exec(`
+    INSERT INTO memories_fts(id, content, tags)
+    SELECT m.id, m.content, m.tags_json
+    FROM memories m
+    WHERE NOT EXISTS (
+      SELECT 1 FROM memories_fts f WHERE f.id = m.id
+    )
+  `);
+    db.exec(`
+    DELETE FROM memories_fts
+    WHERE id NOT IN (SELECT id FROM memories)
+  `);
+}
+//# sourceMappingURL=migrate.js.map

package/dist/db/migrations/index.d.ts

@@ -0,0 +1,5 @@
+import type { Migration } from './types.js';
+export declare const CURRENT_SCHEMA_VERSION = 52;
+/** Every schema migration in version order; runMigrations applies each one above the stored version. */
+export declare const MIGRATIONS: Migration[];
+//# sourceMappingURL=index.d.ts.map

package/dist/db/migrations/index.js

@@ -0,0 +1,109 @@
+import { v01 } from './v01.js';
+import { v02 } from './v02.js';
+import { v03 } from './v03.js';
+import { v04 } from './v04.js';
+import { v05 } from './v05.js';
+import { v06 } from './v06.js';
+import { v07 } from './v07.js';
+import { v08 } from './v08.js';
+import { v09 } from './v09.js';
+import { v10 } from './v10.js';
+import { v11 } from './v11.js';
+import { v12 } from './v12.js';
+import { v13 } from './v13.js';
+import { v14 } from './v14.js';
+import { v15 } from './v15.js';
+import { v16 } from './v16.js';
+import { v17 } from './v17.js';
+import { v18 } from './v18.js';
+import { v19 } from './v19.js';
+import { v20 } from './v20.js';
+import { v21 } from './v21.js';
+import { v22 } from './v22.js';
+import { v23 } from './v23.js';
+import { v24 } from './v24.js';
+import { v25 } from './v25.js';
+import { v26 } from './v26.js';
+import { v27 } from './v27.js';
+import { v28 } from './v28.js';
+import { v29 } from './v29.js';
+import { v30 } from './v30.js';
+import { v31 } from './v31.js';
+import { v32 } from './v32.js';
+import { v33 } from './v33.js';
+import { v34 } from './v34.js';
+import { v35 } from './v35.js';
+import { v36 } from './v36.js';
+import { v37 } from './v37.js';
+import { v38 } from './v38.js';
+import { v39 } from './v39.js';
+import { v40 } from './v40.js';
+import { v41 } from './v41.js';
+import { v42 } from './v42.js';
+import { v43 } from './v43.js';
+import { v44 } from './v44.js';
+import { v45 } from './v45.js';
+import { v46 } from './v46.js';
+import { v47 } from './v47.js';
+import { v48 } from './v48.js';
+import { v49 } from './v49.js';
+import { v50 } from './v50.js';
+import { v51 } from './v51.js';
+import { v52 } from './v52.js';
+export const CURRENT_SCHEMA_VERSION = 52;
+/** Every schema migration in version order; runMigrations applies each one above the stored version. */
+export const MIGRATIONS = [
+    v01,
+    v02,
+    v03,
+    v04,
+    v05,
+    v06,
+    v07,
+    v08,
+    v09,
+    v10,
+    v11,
+    v12,
+    v13,
+    v14,
+    v15,
+    v16,
+    v17,
+    v18,
+    v19,
+    v20,
+    v21,
+    v22,
+    v23,
+    v24,
+    v25,
+    v26,
+    v27,
+    v28,
+    v29,
+    v30,
+    v31,
+    v32,
+    v33,
+    v34,
+    v35,
+    v36,
+    v37,
+    v38,
+    v39,
+    v40,
+    v41,
+    v42,
+    v43,
+    v44,
+    v45,
+    v46,
+    v47,
+    v48,
+    v49,
+    v50,
+    v51,
+    v52,
+];
+//# sourceMappingURL=index.js.map

package/dist/db/migrations/types.d.ts

@@ -0,0 +1,14 @@
+import type { DatabaseSyncLike } from '../sqlite.js';
+/**
+ * Context passed to migrations that need to know WHERE the store lives.
+ * hippoRoot is the store directory (e.g. `<project>/.hippo`); undefined only
+ * for callers that open a DB without a filesystem store notion (none today).
+ */
+export type MigrationContext = {
+    hippoRoot?: string;
+};
+export type Migration = {
+    version: number;
+    up: (db: DatabaseSyncLike, ctx?: MigrationContext) => void;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/db/migrations/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/db/migrations/v01.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v01: Migration;
+//# sourceMappingURL=v01.d.ts.map

package/dist/db/migrations/v01.js

@@ -0,0 +1,38 @@
+export const v01 = {
+    version: 1,
+    up: (db) => {
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS memories (
+          id TEXT PRIMARY KEY,
+          created TEXT NOT NULL,
+          last_retrieved TEXT NOT NULL,
+          retrieval_count INTEGER NOT NULL,
+          strength REAL NOT NULL,
+          half_life_days REAL NOT NULL,
+          layer TEXT NOT NULL,
+          tags_json TEXT NOT NULL,
+          emotional_valence TEXT NOT NULL,
+          schema_fit REAL NOT NULL,
+          source TEXT NOT NULL,
+          outcome_score REAL,
+          conflicts_with_json TEXT NOT NULL,
+          pinned INTEGER NOT NULL,
+          confidence TEXT NOT NULL,
+          content TEXT NOT NULL,
+          updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_memories_layer_created ON memories(layer, created);
+        CREATE INDEX IF NOT EXISTS idx_memories_last_retrieved ON memories(last_retrieved);
+
+        CREATE TABLE IF NOT EXISTS consolidation_runs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          timestamp TEXT NOT NULL,
+          decayed INTEGER NOT NULL,
+          merged INTEGER NOT NULL,
+          removed INTEGER NOT NULL
+        );
+      `);
+    },
+};
+//# sourceMappingURL=v01.js.map

package/dist/db/migrations/v02.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v02: Migration;
+//# sourceMappingURL=v02.d.ts.map

package/dist/db/migrations/v02.js

@@ -0,0 +1,21 @@
+export const v02 = {
+    version: 2,
+    up: (db) => {
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS task_snapshots (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          task TEXT NOT NULL,
+          summary TEXT NOT NULL,
+          next_step TEXT NOT NULL,
+          status TEXT NOT NULL,
+          source TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_task_snapshots_status_updated
+        ON task_snapshots(status, updated_at DESC, id DESC);
+      `);
+    },
+};
+//# sourceMappingURL=v02.js.map

package/dist/db/migrations/v03.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v03: Migration;
+//# sourceMappingURL=v03.d.ts.map

package/dist/db/migrations/v03.js

@@ -0,0 +1,22 @@
+export const v03 = {
+    version: 3,
+    up: (db) => {
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS memory_conflicts (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          memory_a_id TEXT NOT NULL,
+          memory_b_id TEXT NOT NULL,
+          reason TEXT NOT NULL,
+          score REAL NOT NULL DEFAULT 0,
+          status TEXT NOT NULL,
+          detected_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL,
+          UNIQUE(memory_a_id, memory_b_id)
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_memory_conflicts_status_updated
+        ON memory_conflicts(status, updated_at DESC, id DESC);
+      `);
+    },
+};
+//# sourceMappingURL=v03.js.map

package/dist/db/migrations/v04.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v04: Migration;
+//# sourceMappingURL=v04.d.ts.map

package/dist/db/migrations/v04.js

@@ -0,0 +1,28 @@
+import { tableHasColumn } from '../tables.js';
+export const v04 = {
+    version: 4,
+    up: (db) => {
+        if (!tableHasColumn(db, 'task_snapshots', 'session_id')) {
+            db.exec(`ALTER TABLE task_snapshots ADD COLUMN session_id TEXT`);
+        }
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS session_events (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL,
+          task TEXT,
+          event_type TEXT NOT NULL,
+          content TEXT NOT NULL,
+          source TEXT NOT NULL,
+          metadata_json TEXT NOT NULL,
+          created_at TEXT NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_session_events_session_created
+        ON session_events(session_id, created_at DESC, id DESC);
+
+        CREATE INDEX IF NOT EXISTS idx_session_events_task_created
+        ON session_events(task, created_at DESC, id DESC);
+      `);
+    },
+};
+//# sourceMappingURL=v04.js.map

package/dist/db/migrations/v05.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v05: Migration;
+//# sourceMappingURL=v05.d.ts.map

package/dist/db/migrations/v05.js

@@ -0,0 +1,21 @@
+export const v05 = {
+    version: 5,
+    up: (db) => {
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS session_handoffs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL,
+          repo_root TEXT,
+          task_id TEXT,
+          summary TEXT NOT NULL,
+          next_action TEXT,
+          artifacts_json TEXT NOT NULL DEFAULT '[]',
+          created_at TEXT NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_session_handoffs_session
+        ON session_handoffs(session_id, created_at DESC);
+      `);
+    },
+};
+//# sourceMappingURL=v05.js.map

package/dist/db/migrations/v06.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v06: Migration;
+//# sourceMappingURL=v06.d.ts.map

package/dist/db/migrations/v06.js

@@ -0,0 +1,25 @@
+export const v06 = {
+    version: 6,
+    up: (db) => {
+        db.exec(`
+        CREATE TABLE IF NOT EXISTS working_memory (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          scope TEXT NOT NULL,
+          session_id TEXT,
+          task_id TEXT,
+          importance REAL NOT NULL DEFAULT 0,
+          content TEXT NOT NULL,
+          metadata_json TEXT NOT NULL DEFAULT '{}',
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_working_memory_scope
+        ON working_memory(scope, importance DESC, created_at DESC);
+
+        CREATE INDEX IF NOT EXISTS idx_working_memory_session
+        ON working_memory(session_id, created_at DESC);
+      `);
+    },
+};
+//# sourceMappingURL=v06.js.map

package/dist/db/migrations/v07.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v07: Migration;
+//# sourceMappingURL=v07.d.ts.map

package/dist/db/migrations/v07.js

@@ -0,0 +1,13 @@
+import { tableHasColumn } from '../tables.js';
+export const v07 = {
+    version: 7,
+    up: (db) => {
+        if (!tableHasColumn(db, 'memories', 'outcome_positive')) {
+            db.exec(`ALTER TABLE memories ADD COLUMN outcome_positive INTEGER NOT NULL DEFAULT 0`);
+        }
+        if (!tableHasColumn(db, 'memories', 'outcome_negative')) {
+            db.exec(`ALTER TABLE memories ADD COLUMN outcome_negative INTEGER NOT NULL DEFAULT 0`);
+        }
+    },
+};
+//# sourceMappingURL=v07.js.map

package/dist/db/migrations/v08.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v08: Migration;
+//# sourceMappingURL=v08.d.ts.map

package/dist/db/migrations/v08.js

@@ -0,0 +1,8 @@
+import { createPhysicsTable } from '../../physics-state.js';
+export const v08 = {
+    version: 8,
+    up: (db) => {
+        createPhysicsTable(db);
+    },
+};
+//# sourceMappingURL=v08.js.map

package/dist/db/migrations/v09.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v09: Migration;
+//# sourceMappingURL=v09.d.ts.map

package/dist/db/migrations/v09.js

@@ -0,0 +1,13 @@
+import { tableHasColumn } from '../tables.js';
+export const v09 = {
+    version: 9,
+    up: (db) => {
+        if (!tableHasColumn(db, 'memories', 'parents_json')) {
+            db.exec(`ALTER TABLE memories ADD COLUMN parents_json TEXT NOT NULL DEFAULT '[]'`);
+        }
+        if (!tableHasColumn(db, 'memories', 'starred')) {
+            db.exec(`ALTER TABLE memories ADD COLUMN starred INTEGER NOT NULL DEFAULT 0`);
+        }
+    },
+};
+//# sourceMappingURL=v09.js.map

package/dist/db/migrations/v10.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v10: Migration;
+//# sourceMappingURL=v10.d.ts.map

package/dist/db/migrations/v10.js

@@ -0,0 +1,17 @@
+import { tableHasColumn } from '../tables.js';
+export const v10 = {
+    version: 10,
+    up: (db) => {
+        if (!tableHasColumn(db, 'memories', 'trace_outcome')) {
+            db.exec(`ALTER TABLE memories ADD COLUMN trace_outcome TEXT`);
+        }
+        if (!tableHasColumn(db, 'memories', 'source_session_id')) {
+            db.exec(`ALTER TABLE memories ADD COLUMN source_session_id TEXT`);
+        }
+        db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_memories_source_session_id
+        ON memories(source_session_id) WHERE source_session_id IS NOT NULL
+      `);
+    },
+};
+//# sourceMappingURL=v10.js.map

package/dist/db/migrations/v11.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v11: Migration;
+//# sourceMappingURL=v11.d.ts.map

package/dist/db/migrations/v11.js

@@ -0,0 +1,15 @@
+import { tableHasColumn } from '../tables.js';
+export const v11 = {
+    version: 11,
+    up: (db) => {
+        if (!tableHasColumn(db, 'memories', 'valid_from')) {
+            db.exec(`ALTER TABLE memories ADD COLUMN valid_from TEXT`);
+            db.exec(`UPDATE memories SET valid_from = created WHERE valid_from IS NULL`);
+        }
+        if (!tableHasColumn(db, 'memories', 'superseded_by')) {
+            db.exec(`ALTER TABLE memories ADD COLUMN superseded_by TEXT`);
+        }
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_current ON memories(layer, created) WHERE superseded_by IS NULL`);
+    },
+};
+//# sourceMappingURL=v11.js.map

package/dist/db/migrations/v12.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v12: Migration;
+//# sourceMappingURL=v12.d.ts.map

package/dist/db/migrations/v12.js

@@ -0,0 +1,11 @@
+import { tableHasColumn } from '../tables.js';
+export const v12 = {
+    version: 12,
+    up: (db) => {
+        if (!tableHasColumn(db, 'memories', 'extracted_from')) {
+            db.exec(`ALTER TABLE memories ADD COLUMN extracted_from TEXT`);
+        }
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_extracted_from ON memories(extracted_from) WHERE extracted_from IS NOT NULL`);
+    },
+};
+//# sourceMappingURL=v12.js.map

package/dist/db/migrations/v13.d.ts

@@ -0,0 +1,3 @@
+import type { Migration } from './types.js';
+export declare const v13: Migration;
+//# sourceMappingURL=v13.d.ts.map

package/dist/db/migrations/v13.js

@@ -0,0 +1,15 @@
+import { tableHasColumn } from '../tables.js';
+export const v13 = {
+    version: 13,
+    up: (db) => {
+        if (!tableHasColumn(db, 'memories', 'dag_level')) {
+            db.exec(`ALTER TABLE memories ADD COLUMN dag_level INTEGER NOT NULL DEFAULT 0`);
+        }
+        if (!tableHasColumn(db, 'memories', 'dag_parent_id')) {
+            db.exec(`ALTER TABLE memories ADD COLUMN dag_parent_id TEXT`);
+        }
+        db.exec(`UPDATE memories SET dag_level = 1 WHERE extracted_from IS NOT NULL AND dag_level = 0`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_memories_dag_parent ON memories(dag_parent_id) WHERE dag_parent_id IS NOT NULL`);
+    },
+};
+//# sourceMappingURL=v13.js.map