omo-memory 0.1.11 → 0.1.13

package/dist/mcp.js

@@ -1,11 +1,15 @@
+import { readFileSync } from "node:fs";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { bootstrapSession, exportMemory, memoryPaths, PurgeConfirmationError, purgeMemory, recentEvents, recordEvent, startSession, writeHandoff, } from "./memory.js";
+import { registerGlobalOntologyTools } from "./mcpOntologyTools.js";
+import { bootstrapSession, exportMemory, PurgeConfirmationError, purgeMemory, recentEvents, recordEvent, startSession, writeHandoff } from "./memory.js";
 import { initMemory } from "./memoryDb.js";
+import { recallEvents } from "./memoryRecall.js";
+import { memoryPaths } from "./memoryReport.js";
 import { resolveProjectContext } from "./projectContext.js";
 export async function runMcpServer() {
-    const server = new McpServer({ name: "omo-memory", version: "0.1.2" });
+    const server = new McpServer({ name: "omo-memory", version: readPackageVersion() });
     server.registerTool("memory_init", {
         title: "Initialize OMO Memory",
         description: "Create or migrate the local OMO memory SQLite database.",
@@ -38,6 +42,7 @@ export async function runMcpServer() {
             throw error;
         }
     });
+    registerGlobalOntologyTools(server);
     server.registerTool("memory_start_session", {
         title: "Start OMO Session",
         description: "Record a new OMO adapter session for the current project.",
@@ -48,13 +53,21 @@ export async function runMcpServer() {
     }, async ({ host, adapter }) => jsonResult(startSession({ host, adapter })));
     server.registerTool("memory_bootstrap_session", {
         title: "Bootstrap OMO Session",
-        description: "Start a host adapter session and return recent project memory in one call. Call this at the beginning of each Codex, OpenCode, or Grok session.",
+        description: "Start a host adapter session without reading or injecting recent memory.",
         inputSchema: {
             host: z.enum(["codex", "opencode", "grok", "unknown"]),
             adapter: z.string().min(1),
             limit: z.number().int().positive().max(100).default(5),
         },
     }, async ({ host, adapter, limit }) => jsonResult(bootstrapSession({ host, adapter, limit })));
+    server.registerTool("memory_recall_events", {
+        title: "Recall OMO Memory Events",
+        description: "Return recorded events only when the query text matches stored intent or content.",
+        inputSchema: {
+            query: z.string().min(1),
+            limit: z.number().int().positive().max(100).default(10),
+        },
+    }, async ({ query, limit }) => jsonResult({ events: recallEvents({ query, limit }) }));
     server.registerTool("memory_record_event", {
         title: "Record OMO Memory Event",
         description: "Append a summarized event to the current project's OMO memory ledger.",
@@ -82,6 +95,16 @@ export async function runMcpServer() {
     }, async ({ summaryMd, sessionId }) => jsonResult(writeHandoff(summaryMd, sessionId)));
     await server.connect(new StdioServerTransport());
 }
+function readPackageVersion() {
+    const rawPackage = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    if (!isObject(rawPackage))
+        return "0.0.0";
+    const version = rawPackage["version"];
+    return typeof version === "string" && version.length > 0 ? version : "0.0.0";
+}
+function isObject(value) {
+    return value !== null && typeof value === "object";
+}
 function jsonResult(value) {
     return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
 }

package/dist/mcpOntologyTools.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import { applyConceptExtraction, extractConceptCandidates } from "./conceptExtraction.js";
+import { listGlobalMemory, migrateToGlobalMemory, scanForMemoryDbs } from "./globalMemory.js";
+import { memoryPaths } from "./memoryReport.js";
+import { createDurableMemory, listOntologyRows, supersedeDurableMemory, updateDurableRetention } from "./ontologyCore.js";
+import { resolveProjectContext } from "./projectContext.js";
+import { recomputeRetentionScores } from "./retentionRecompute.js";
+const retentionClassSchema = z.enum(["forget", "temporary", "working", "durable", "permanent"]);
+const nonBlankStringSchema = z.string().trim().min(1);
+export function registerGlobalOntologyTools(server) {
+    server.registerTool("memory_global_scan", {
+        title: "Scan Global OMO Memory Sources",
+        description: "Explicitly scan a filesystem root for local OMO memory SQLite databases without importing them.",
+        inputSchema: { rootPath: nonBlankStringSchema },
+    }, async ({ rootPath }) => jsonResult(scanForMemoryDbs(rootPath)));
+    server.registerTool("memory_global_migrate", {
+        title: "Migrate OMO Memory To Global SQLite",
+        description: "Explicitly create or update a global OMO memory SQLite database from discovered local memory databases.",
+        inputSchema: { rootPath: nonBlankStringSchema, globalDbPath: nonBlankStringSchema },
+    }, async ({ rootPath, globalDbPath }) => jsonResult(migrateToGlobalMemory({ rootPath, globalDbPath })));
+    server.registerTool("memory_global_list", {
+        title: "List Global OMO Memory",
+        description: "List sources and counts from an explicit global OMO memory SQLite database.",
+        inputSchema: { globalDbPath: nonBlankStringSchema },
+    }, async ({ globalDbPath }) => jsonResult(listGlobalMemory(globalDbPath)));
+    registerOntologyTools(server);
+}
+function registerOntologyTools(server) {
+    server.registerTool("memory_ontology_candidates", {
+        title: "Extract OMO Ontology Candidates",
+        description: "Return deterministic ontology candidate labels from a short event summary without writing rows.",
+        inputSchema: { summary: nonBlankStringSchema, eventType: nonBlankStringSchema.optional() },
+    }, async ({ summary, eventType }) => jsonResult({ candidates: extractConceptCandidates(summary, eventType) }));
+    server.registerTool("memory_ontology_extract", {
+        title: "Write OMO Ontology Extraction",
+        description: "Explicitly extract concepts from a short event summary and write event-to-concept references.",
+        inputSchema: {
+            sourceEventId: nonBlankStringSchema,
+            summary: nonBlankStringSchema,
+            eventType: nonBlankStringSchema.optional(),
+        },
+    }, async ({ sourceEventId, summary, eventType }) => jsonResult(applyConceptExtraction(memoryPaths().dbPath, resolveProjectContext(), sourceEventId, summary, eventType)));
+    server.registerTool("memory_ontology_score", {
+        title: "Recompute OMO Ontology Scores",
+        description: "Explicitly recompute ontology retention scores for the local OMO memory SQLite database.",
+        inputSchema: { nowIso: z.string().datetime().optional() },
+    }, async ({ nowIso }) => jsonResult(recomputeRetentionScores({ dbPath: memoryPaths().dbPath, nowIso: nowIso ?? new Date().toISOString() })));
+    server.registerTool("memory_ontology_promote", {
+        title: "Promote OMO Durable Memory",
+        description: "Explicitly promote a summarized memory into durable ontology storage.",
+        inputSchema: {
+            type: nonBlankStringSchema,
+            summary: nonBlankStringSchema,
+            body: nonBlankStringSchema.optional(),
+            sourceEventId: nonBlankStringSchema.optional(),
+            sourceHandoffId: nonBlankStringSchema.optional(),
+            confidence: z.number().min(0).max(1).optional(),
+            status: nonBlankStringSchema.optional(),
+            retentionClass: retentionClassSchema.optional(),
+        },
+    }, async ({ type, summary, body, sourceEventId, sourceHandoffId, confidence, status, retentionClass }) => jsonResult(createDurableMemory(memoryPaths().dbPath, resolveProjectContext(), {
+        type,
+        summary,
+        ...(body === undefined ? {} : { body }),
+        ...(sourceEventId === undefined ? {} : { sourceEventId }),
+        ...(sourceHandoffId === undefined ? {} : { sourceHandoffId }),
+        ...(confidence === undefined ? {} : { confidence }),
+        ...(status === undefined ? {} : { status }),
+        ...(retentionClass === undefined ? {} : { retentionClass }),
+    })));
+    server.registerTool("memory_ontology_demote", {
+        title: "Demote OMO Durable Memory",
+        description: "Explicitly change the retention class for a durable ontology memory.",
+        inputSchema: { durableId: nonBlankStringSchema, retentionClass: retentionClassSchema.default("temporary") },
+    }, async ({ durableId, retentionClass }) => jsonResult(updateDurableRetention(memoryPaths().dbPath, resolveProjectContext(), durableId, { retentionClass })));
+    server.registerTool("memory_ontology_supersede", {
+        title: "Supersede OMO Durable Memory",
+        description: "Explicitly mark a durable memory superseded and create a successor memory.",
+        inputSchema: {
+            durableId: nonBlankStringSchema,
+            reason: nonBlankStringSchema.optional(),
+            newSummary: nonBlankStringSchema.optional(),
+        },
+    }, async ({ durableId, reason, newSummary }) => jsonResult(supersedeDurableMemory(memoryPaths().dbPath, resolveProjectContext(), durableId, {
+        ...(reason === undefined ? {} : { reason }),
+        ...(newSummary === undefined ? {} : { newSummary }),
+    })));
+    server.registerTool("memory_ontology_recall", {
+        title: "Recall OMO Ontology Rows",
+        description: "Explicitly recall ontology concepts and durable memories matching a query.",
+        inputSchema: { query: nonBlankStringSchema, limit: z.number().int().positive().max(100).default(10) },
+    }, async ({ query, limit }) => jsonResult(recallOntology(query, limit)));
+}
+function jsonResult(value) {
+    return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
+}
+function recallOntology(query, limit) {
+    const rows = listOntologyRows(memoryPaths().dbPath, resolveProjectContext());
+    const normalizedQuery = query.toLowerCase();
+    const queryTerms = normalizedQuery.split(/[^a-z0-9_-]+/).filter((term) => term.length >= 3);
+    return {
+        concepts: rows.concepts.filter((concept) => matchesConcept(concept, normalizedQuery, queryTerms)).slice(0, limit),
+        durableMemories: rows.durableMemories.filter((memory) => matchesDurableMemory(memory, normalizedQuery, queryTerms)).slice(0, limit),
+    };
+}
+function matchesConcept(concept, normalizedQuery, queryTerms) {
+    return matchesText([concept.label, concept.description ?? "", concept.aliasesJson], normalizedQuery, queryTerms);
+}
+function matchesDurableMemory(memory, normalizedQuery, queryTerms) {
+    return matchesText([memory.type, memory.summary, memory.body ?? ""], normalizedQuery, queryTerms);
+}
+function matchesText(values, normalizedQuery, queryTerms) {
+    const normalizedValues = values.map((value) => value.toLowerCase());
+    if (normalizedValues.some((value) => value.includes(normalizedQuery)))
+        return true;
+    return queryTerms.length > 0 && queryTerms.every((term) => normalizedValues.some((value) => value.includes(term)));
+}

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();
+    }
+}