omo-memory 0.1.11 → 0.1.12

package/dist/memory.js

@@ -9,32 +9,6 @@ export class PurgeConfirmationError extends Error {
         this.name = "PurgeConfirmationError";
     }
 }
-export function memoryPaths() {
-    return { dbPath: defaultDbPath() };
-}
-export function doctorReport(dbPath = defaultDbPath()) {
-    const db = openMemoryDb(dbPath);
-    try {
-        migrate(db);
-        const project = resolveStoredProject(db, resolveProjectContext());
-        const schemaVersion = Number(db.prepare("SELECT value FROM schema_meta WHERE key = 'schema_version'").pluck().get());
-        const count = (table) => Number(db.prepare(`SELECT COUNT(*) FROM ${table}`).pluck().get());
-        return {
-            paths: { dbPath },
-            schemaVersion,
-            project,
-            counts: {
-                projects: count("projects"),
-                sessions: count("sessions"),
-                events: count("events"),
-                handoffs: count("handoffs"),
-            },
-        };
-    }
-    finally {
-        db.close();
-    }
-}
 export function upsertProject(db, project) {
     const now = new Date().toISOString();
     db.prepare(`
@@ -64,8 +38,7 @@ export function startSession(input, dbPath = defaultDbPath()) {
     }
 }
 export function bootstrapSession(input, dbPath = defaultDbPath()) {
-    const session = startSession({ host: input.host, adapter: input.adapter }, dbPath);
-    return { ...session, recentEvents: recentEvents(input.limit, dbPath) };
+    return startSession({ host: input.host, adapter: input.adapter }, dbPath);
 }
 export function recordEvent(input, dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
@@ -141,6 +114,50 @@ export function exportMemory(dbPath = defaultDbPath()) {
             .prepare(`
       SELECT id, session_id AS sessionId, summary_md AS summaryMd, created_at AS createdAt FROM handoffs
       WHERE project_id = ? ORDER BY created_at ASC, id ASC
+    `)
+            .all(project.id);
+        const concepts = db
+            .prepare(`
+      SELECT id, kind, label, description, aliases_json AS aliasesJson, payload_json AS payloadJson,
+        valid_from AS validFrom, valid_to AS validTo, created_at AS createdAt, updated_at AS updatedAt,
+        COALESCE(score, 0) AS score,
+        COALESCE(retention_class, 'working') AS retentionClass,
+        COALESCE(manual_pin, 0) AS manualPin,
+        COALESCE(ref_count, 0) AS refCount,
+        COALESCE(project_spread, 1) AS projectSpread,
+        first_seen AS firstSeen, last_seen AS lastSeen
+      FROM concepts WHERE project_id = ? ORDER BY created_at ASC, id ASC
+    `)
+            .all(project.id);
+        const relations = db
+            .prepare(`
+      SELECT id, source_type AS sourceType, source_id AS sourceId, target_type AS targetType, target_id AS targetId,
+        relation, weight, payload_json AS payloadJson, valid_from AS validFrom, valid_to AS validTo,
+        created_at AS createdAt, updated_at AS updatedAt
+      FROM relations WHERE project_id = ? ORDER BY created_at ASC, id ASC
+    `)
+            .all(project.id);
+        const durableMemories = db
+            .prepare(`
+      SELECT id, type, summary, body, source_event_id AS sourceEventId, source_handoff_id AS sourceHandoffId,
+        confidence, status, COALESCE(retention_class, 'durable') AS retentionClass,
+        valid_from AS validFrom, valid_to AS validTo, created_at AS createdAt, updated_at AS updatedAt
+      FROM durable_memories WHERE project_id = ? ORDER BY created_at ASC, id ASC
+    `)
+            .all(project.id);
+        const decisionRecords = db
+            .prepare(`
+      SELECT id, title, rationale, alternatives_json AS alternativesJson, evidence_json AS evidenceJson,
+        status, reversible, source_event_id AS sourceEventId, supersedes_decision_id AS supersedesDecisionId,
+        valid_from AS validFrom, valid_to AS validTo, created_at AS createdAt, updated_at AS updatedAt
+      FROM decision_records WHERE project_id = ? ORDER BY created_at ASC, id ASC
+    `)
+            .all(project.id);
+        const memoryReferences = db
+            .prepare(`
+      SELECT id, source_type AS sourceType, source_id AS sourceId, target_type AS targetType, target_id AS targetId,
+        ref_kind AS refKind, weight, created_at AS createdAt
+      FROM memory_references WHERE project_id = ? ORDER BY created_at ASC, id ASC
     `)
             .all(project.id);
         return {
@@ -151,6 +168,11 @@ export function exportMemory(dbPath = defaultDbPath()) {
             sessions,
             events,
             handoffs,
+            concepts,
+            relations,
+            durableMemories,
+            decisionRecords,
+            memoryReferences,
         };
     }
     finally {
@@ -165,6 +187,18 @@ export function purgeMemory(input, dbPath = defaultDbPath()) {
         migrate(db);
         const project = resolveStoredProject(db, resolveProjectContext());
         const deleteProject = db.transaction(() => {
+            const relations = db
+                .prepare("DELETE FROM relations WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)")
+                .run(project.id, project.repoRoot).changes;
+            const decisionRecords = db
+                .prepare("DELETE FROM decision_records WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)")
+                .run(project.id, project.repoRoot).changes;
+            const durableMemories = db
+                .prepare("DELETE FROM durable_memories WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)")
+                .run(project.id, project.repoRoot).changes;
+            const concepts = db
+                .prepare("DELETE FROM concepts WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)")
+                .run(project.id, project.repoRoot).changes;
             const events = db
                 .prepare("DELETE FROM events WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)")
                 .run(project.id, project.repoRoot).changes;
@@ -174,8 +208,11 @@ export function purgeMemory(input, dbPath = defaultDbPath()) {
             const sessions = db
                 .prepare("DELETE FROM sessions WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)")
                 .run(project.id, project.repoRoot).changes;
+            const memoryReferences = db
+                .prepare("DELETE FROM memory_references WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)")
+                .run(project.id, project.repoRoot).changes;
             const projects = db.prepare("DELETE FROM projects WHERE id = ? OR repo_root = ?").run(project.id, project.repoRoot).changes;
-            return { events, handoffs, sessions, projects };
+            return { events, handoffs, sessions, projects, concepts, relations, durableMemories, decisionRecords, memoryReferences };
         });
         return { project, deleted: deleteProject() };
     }

package/dist/memoryDb.js

@@ -2,7 +2,7 @@ import { mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import Database from "better-sqlite3";
 import { defaultDbPath } from "./projectContext.js";
-export const SCHEMA_VERSION = 1;
+export const SCHEMA_VERSION = 3;
 export function openMemoryDb(dbPath = defaultDbPath()) {
     mkdirSync(dirname(dbPath), { recursive: true });
     const db = new Database(dbPath);
@@ -57,9 +57,153 @@ export function migrate(db) {
       FOREIGN KEY(project_id) REFERENCES projects(id),
       FOREIGN KEY(session_id) REFERENCES sessions(id)
     );
+
+    CREATE TABLE IF NOT EXISTS concepts (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      label TEXT NOT NULL,
+      description TEXT,
+      aliases_json TEXT NOT NULL DEFAULT '[]',
+      payload_json TEXT NOT NULL DEFAULT '{}',
+      valid_from TEXT,
+      valid_to TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY(project_id) REFERENCES projects(id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_concepts_project_kind ON concepts(project_id, kind);
+    CREATE INDEX IF NOT EXISTS idx_concepts_project_label ON concepts(project_id, label);
+    CREATE INDEX IF NOT EXISTS idx_concepts_valid_to ON concepts(project_id, valid_to);
+
+    CREATE TABLE IF NOT EXISTS durable_memories (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      body TEXT,
+      source_event_id TEXT,
+      source_handoff_id TEXT,
+      confidence REAL NOT NULL DEFAULT 0,
+      status TEXT NOT NULL,
+      valid_from TEXT,
+      valid_to TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY(project_id) REFERENCES projects(id),
+      FOREIGN KEY(source_event_id) REFERENCES events(id),
+      FOREIGN KEY(source_handoff_id) REFERENCES handoffs(id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_durable_memories_project_type ON durable_memories(project_id, type);
+    CREATE INDEX IF NOT EXISTS idx_durable_memories_project_status ON durable_memories(project_id, status);
+    CREATE INDEX IF NOT EXISTS idx_durable_memories_source_event ON durable_memories(source_event_id);
+
+    CREATE TABLE IF NOT EXISTS decision_records (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      rationale TEXT NOT NULL,
+      alternatives_json TEXT NOT NULL DEFAULT '[]',
+      evidence_json TEXT NOT NULL DEFAULT '[]',
+      status TEXT NOT NULL,
+      reversible INTEGER NOT NULL DEFAULT 1,
+      source_event_id TEXT,
+      supersedes_decision_id TEXT,
+      valid_from TEXT,
+      valid_to TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY(project_id) REFERENCES projects(id),
+      FOREIGN KEY(source_event_id) REFERENCES events(id),
+      FOREIGN KEY(supersedes_decision_id) REFERENCES decision_records(id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_decision_records_project_status ON decision_records(project_id, status);
+    CREATE INDEX IF NOT EXISTS idx_decision_records_source_event ON decision_records(source_event_id);
+
+    CREATE TABLE IF NOT EXISTS relations (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      source_type TEXT NOT NULL,
+      source_id TEXT NOT NULL,
+      target_type TEXT NOT NULL,
+      target_id TEXT NOT NULL,
+      relation TEXT NOT NULL,
+      weight REAL NOT NULL DEFAULT 1,
+      payload_json TEXT NOT NULL DEFAULT '{}',
+      valid_from TEXT,
+      valid_to TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY(project_id) REFERENCES projects(id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_relations_project_source ON relations(project_id, source_type, source_id);
+    CREATE INDEX IF NOT EXISTS idx_relations_project_target ON relations(project_id, target_type, target_id);
+    CREATE INDEX IF NOT EXISTS idx_relations_project_relation ON relations(project_id, relation);
+
+    CREATE TABLE IF NOT EXISTS memory_references (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      source_type TEXT NOT NULL,
+      source_id TEXT NOT NULL,
+      target_type TEXT NOT NULL,
+      target_id TEXT NOT NULL,
+      ref_kind TEXT NOT NULL DEFAULT 'mentions',
+      weight REAL NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY(project_id) REFERENCES projects(id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_memory_references_project_source ON memory_references(project_id, source_type, source_id);
   `);
+    // schema v3 upgrade: add retention/reference columns to existing v1/v2 DBs (idempotent)
+    const addCol = (sql) => {
+        try {
+            db.exec(sql);
+        }
+        catch (e) {
+            const m = String(e.message || e);
+            if (!/duplicate column name|already exists/i.test(m))
+                throw e;
+        }
+    };
+    addCol("ALTER TABLE concepts ADD COLUMN score REAL NOT NULL DEFAULT 0");
+    addCol("ALTER TABLE concepts ADD COLUMN retention_class TEXT NOT NULL DEFAULT 'working'");
+    addCol("ALTER TABLE concepts ADD COLUMN manual_pin INTEGER NOT NULL DEFAULT 0");
+    addCol("ALTER TABLE concepts ADD COLUMN ref_count INTEGER NOT NULL DEFAULT 0");
+    addCol("ALTER TABLE concepts ADD COLUMN project_spread INTEGER NOT NULL DEFAULT 1");
+    addCol("ALTER TABLE concepts ADD COLUMN first_seen TEXT");
+    addCol("ALTER TABLE concepts ADD COLUMN last_seen TEXT");
+    addCol("ALTER TABLE durable_memories ADD COLUMN retention_class TEXT NOT NULL DEFAULT 'durable'");
+    compactMemoryReferences(db);
+    db.exec(`
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_memory_references_unique_edge ON memory_references(
+      project_id, source_type, source_id, target_type, target_id, ref_kind
+    )
+  `);
+    recomputeConceptReferenceCounts(db);
     db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', ?)").run(String(SCHEMA_VERSION));
 }
+function compactMemoryReferences(db) {
+    db.exec(`
+    DELETE FROM memory_references
+    WHERE id NOT IN (
+      SELECT MIN(id)
+      FROM memory_references
+      GROUP BY project_id, source_type, source_id, target_type, target_id, ref_kind
+    )
+  `);
+}
+function recomputeConceptReferenceCounts(db) {
+    db.exec(`
+    UPDATE concepts
+       SET ref_count = (
+         SELECT COUNT(*)
+           FROM memory_references
+          WHERE memory_references.project_id = concepts.project_id
+            AND memory_references.target_type = 'concept'
+            AND memory_references.target_id = concepts.id
+       )
+  `);
+}
 export function initMemory(dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
     try {

package/dist/memoryRecall.js

@@ -0,0 +1,56 @@
+import { migrate, openMemoryDb } from "./memoryDb.js";
+import { defaultDbPath, resolveProjectContext } from "./projectContext.js";
+import { resolveStoredProject } from "./projectMigration.js";
+export function recallEvents(input, dbPath = defaultDbPath()) {
+    const terms = recallTerms(input.query);
+    if (terms.length === 0)
+        return [];
+    const db = openMemoryDb(dbPath);
+    try {
+        migrate(db);
+        const project = resolveStoredProject(db, resolveProjectContext());
+        const minimumMatches = Math.min(2, terms.length);
+        const score = terms.map(() => "CASE WHEN LOWER(summary) LIKE ? ESCAPE '\\' THEN 1 ELSE 0 END").join(" + ");
+        const patternArgs = terms.map((term) => `%${escapeLikeTerm(term)}%`);
+        return db
+            .prepare(`
+      SELECT id, type, summary, created_at AS createdAt, session_id AS sessionId
+      FROM events
+      WHERE project_id = ? AND (${score}) >= ?
+      ORDER BY created_at DESC
+      LIMIT ?
+    `)
+            .all(project.id, ...patternArgs, minimumMatches, input.limit);
+    }
+    finally {
+        db.close();
+    }
+}
+function recallTerms(query) {
+    return Array.from(new Set(query.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{3,}/gu) ?? []))
+        .filter((term) => !GENERIC_RECALL_TERMS.has(term))
+        .slice(0, 8);
+}
+function escapeLikeTerm(term) {
+    return term.replace(/[\\%_]/g, (char) => `\\${char}`);
+}
+const GENERIC_RECALL_TERMS = new Set([
+    "action",
+    "asked",
+    "current",
+    "help",
+    "memory",
+    "need",
+    "needs",
+    "omo",
+    "please",
+    "prompt",
+    "request",
+    "requested",
+    "session",
+    "user",
+    "want",
+    "wants",
+    "work",
+    "working",
+]);

package/dist/memoryReport.js

@@ -0,0 +1,33 @@
+import { migrate, openMemoryDb } from "./memoryDb.js";
+import { defaultDbPath, resolveProjectContext } from "./projectContext.js";
+import { resolveStoredProject } from "./projectMigration.js";
+export function memoryPaths() {
+    return { dbPath: defaultDbPath() };
+}
+export function doctorReport(dbPath = defaultDbPath()) {
+    const db = openMemoryDb(dbPath);
+    try {
+        migrate(db);
+        const project = resolveStoredProject(db, resolveProjectContext());
+        const schemaVersion = Number(db.prepare("SELECT value FROM schema_meta WHERE key = 'schema_version'").pluck().get());
+        const count = (table) => Number(db.prepare(`SELECT COUNT(*) FROM ${table}`).pluck().get());
+        return {
+            paths: { dbPath },
+            schemaVersion,
+            project,
+            counts: {
+                projects: count("projects"),
+                sessions: count("sessions"),
+                events: count("events"),
+                handoffs: count("handoffs"),
+                concepts: count("concepts"),
+                relations: count("relations"),
+                durableMemories: count("durable_memories"),
+                decisionRecords: count("decision_records"),
+            },
+        };
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/ontologyCore.js

@@ -0,0 +1,142 @@
+import { randomUUID } from "node:crypto";
+import { upsertProject } from "./memory.js";
+import { migrate, openMemoryDb } from "./memoryDb.js";
+import { redactSecrets } from "./privacy.js";
+export { listOntologyRows } from "./ontologyQueries.js";
+export { supersedeDurableMemory } from "./ontologySupersede.js";
+function nowIso() {
+    return new Date().toISOString();
+}
+function normalizeLabel(label) {
+    return label.trim().toLowerCase();
+}
+export function upsertConcept(dbPath, project, input) {
+    const db = openMemoryDb(dbPath);
+    try {
+        migrate(db);
+        upsertProject(db, project);
+        const label = normalizeLabel(input.label);
+        const now = nowIso();
+        const existing = db.prepare(`SELECT id FROM concepts WHERE project_id = ? AND label = ? LIMIT 1`).get(project.id, label);
+        if (existing?.id) {
+            db.prepare("UPDATE concepts SET last_seen = ?, updated_at = ? WHERE id = ? AND project_id = ?").run(now, now, existing.id, project.id);
+            const row = db
+                .prepare(`SELECT id, kind, label, description, aliases_json AS aliasesJson, payload_json AS payloadJson,
+             valid_from AS validFrom, valid_to AS validTo, created_at AS createdAt, updated_at AS updatedAt,
+             COALESCE(score, 0) AS score, COALESCE(retention_class, 'working') AS retentionClass,
+             COALESCE(manual_pin, 0) AS manualPin, COALESCE(ref_count, 0) AS refCount,
+             COALESCE(project_spread, 1) AS projectSpread, first_seen AS firstSeen, last_seen AS lastSeen
+            FROM concepts WHERE id = ?`)
+                .get(existing.id);
+            return row;
+        }
+        const id = randomUUID();
+        const score = input.score ?? 0;
+        const retentionClass = input.retentionClass ?? "working";
+        const manualPin = input.manualPin ?? 0;
+        const created = now;
+        db.prepare(`
+      INSERT INTO concepts (
+        id, project_id, kind, label, description, aliases_json, payload_json,
+        valid_from, valid_to, created_at, updated_at,
+        score, retention_class, manual_pin, ref_count, project_spread, first_seen, last_seen
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, project.id, input.kind, label, input.description ?? null, "[]", "{}", null, null, created, created, score, retentionClass, manualPin, 0, 1, created, created);
+        const row = db
+            .prepare(`SELECT id, kind, label, description, aliases_json AS aliasesJson, payload_json AS payloadJson,
+          valid_from AS validFrom, valid_to AS validTo, created_at AS createdAt, updated_at AS updatedAt,
+          COALESCE(score, 0) AS score, COALESCE(retention_class, 'working') AS retentionClass,
+          COALESCE(manual_pin, 0) AS manualPin, COALESCE(ref_count, 0) AS refCount,
+          COALESCE(project_spread, 1) AS projectSpread, first_seen AS firstSeen, last_seen AS lastSeen
+         FROM concepts WHERE id = ?`)
+            .get(id);
+        return row;
+    }
+    finally {
+        db.close();
+    }
+}
+export function createDurableMemory(dbPath, project, input) {
+    const db = openMemoryDb(dbPath);
+    try {
+        migrate(db);
+        upsertProject(db, project);
+        const id = randomUUID();
+        const created = nowIso();
+        const redactedSummary = redactSecrets(input.summary);
+        const redactedBody = input.body == null ? null : redactSecrets(input.body);
+        const status = input.status ?? "active";
+        const retentionClass = input.retentionClass ?? "durable";
+        const confidence = input.confidence ?? 0;
+        db.prepare(`
+      INSERT INTO durable_memories (
+        id, project_id, type, summary, body, source_event_id, source_handoff_id,
+        confidence, status, retention_class, valid_from, valid_to, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, project.id, input.type, redactedSummary, redactedBody, input.sourceEventId ?? null, input.sourceHandoffId ?? null, confidence, status, retentionClass, null, null, created, created);
+        const row = db
+            .prepare(`SELECT id, type, summary, body, source_event_id AS sourceEventId, source_handoff_id AS sourceHandoffId,
+          confidence, status, COALESCE(retention_class, 'durable') AS retentionClass,
+          valid_from AS validFrom, valid_to AS validTo, created_at AS createdAt, updated_at AS updatedAt
+         FROM durable_memories WHERE id = ?`)
+            .get(id);
+        return row;
+    }
+    finally {
+        db.close();
+    }
+}
+export function recordMemoryReference(dbPath, project, input) {
+    const db = openMemoryDb(dbPath);
+    try {
+        migrate(db);
+        upsertProject(db, project);
+        const id = randomUUID();
+        const created = nowIso();
+        const refKind = input.refKind ?? "mentions";
+        const weight = input.weight ?? 1;
+        const inserted = db
+            .prepare(`
+      INSERT INTO memory_references (
+        id, project_id, source_type, source_id, target_type, target_id, ref_kind, weight, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(project_id, source_type, source_id, target_type, target_id, ref_kind) DO NOTHING
+    `)
+            .run(id, project.id, input.sourceType, input.sourceId, input.targetType, input.targetId, refKind, weight, created);
+        if (inserted.changes > 0 && input.targetType === "concept") {
+            db.prepare("UPDATE concepts SET ref_count = COALESCE(ref_count, 0) + 1, last_seen = ?, updated_at = ? WHERE id = ? AND project_id = ?").run(created, created, input.targetId, project.id);
+        }
+        const row = db
+            .prepare(`SELECT id, source_type AS sourceType, source_id AS sourceId, target_type AS targetType, target_id AS targetId,
+          ref_kind AS refKind, weight, created_at AS createdAt
+         FROM memory_references
+         WHERE project_id = ? AND source_type = ? AND source_id = ? AND target_type = ? AND target_id = ? AND ref_kind = ?`)
+            .get(project.id, input.sourceType, input.sourceId, input.targetType, input.targetId, refKind);
+        return row;
+    }
+    finally {
+        db.close();
+    }
+}
+export function updateDurableRetention(dbPath, project, durableId, update) {
+    const db = openMemoryDb(dbPath);
+    try {
+        migrate(db);
+        const existing = db.prepare("SELECT retention_class FROM durable_memories WHERE id = ? AND project_id = ?").get(durableId, project.id);
+        if (!existing) {
+            throw new Error("durable memory not found for project");
+        }
+        const now = nowIso();
+        db.prepare("UPDATE durable_memories SET retention_class = COALESCE(?, retention_class), updated_at = ? WHERE id = ? AND project_id = ?").run(update.retentionClass ?? null, now, durableId, project.id);
+        const row = db
+            .prepare(`SELECT id, type, summary, body, source_event_id AS sourceEventId, source_handoff_id AS sourceHandoffId,
+          confidence, status, COALESCE(retention_class, 'durable') AS retentionClass,
+          valid_from AS validFrom, valid_to AS validTo, created_at AS createdAt, updated_at AS updatedAt
+         FROM durable_memories WHERE id = ?`)
+            .get(durableId);
+        return row;
+    }
+    finally {
+        db.close();
+    }
+}