omo-memory 0.1.10 → 0.1.12

package/dist/globalMemoryCanonical.js

@@ -0,0 +1,32 @@
+export function upsertAggregateProject(db, project) {
+    const now = new Date().toISOString();
+    db.prepare(`
+    INSERT INTO projects (id, repo_root, git_remote, created_at, last_seen_at)
+    VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET repo_root = excluded.repo_root, git_remote = excluded.git_remote, last_seen_at = excluded.last_seen_at
+  `).run(project.id, project.repoRoot, project.gitRemote, now, now);
+}
+export function upsertCanonicalSession(db, sourceId, aggregateProjectId, row) {
+    db.prepare(`
+    INSERT INTO sessions (id, project_id, host, adapter, started_at, ended_at, git_branch, git_head)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET host = excluded.host, adapter = excluded.adapter, ended_at = excluded.ended_at, git_branch = excluded.git_branch, git_head = excluded.git_head
+  `).run(globalRowId(sourceId, row.id), aggregateProjectId, row.host, row.adapter, row.startedAt, row.endedAt, row.gitBranch, row.gitHead);
+}
+export function upsertCanonicalEvent(db, sourceId, aggregateProjectId, row) {
+    db.prepare(`
+    INSERT INTO events (id, session_id, project_id, type, summary, payload_json, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET session_id = excluded.session_id, type = excluded.type, summary = excluded.summary, payload_json = excluded.payload_json, created_at = excluded.created_at
+  `).run(globalRowId(sourceId, row.id), row.sessionId === null ? null : globalRowId(sourceId, row.sessionId), aggregateProjectId, row.type, row.summary, row.payloadJson, row.createdAt);
+}
+export function upsertCanonicalHandoff(db, sourceId, aggregateProjectId, row) {
+    db.prepare(`
+    INSERT INTO handoffs (id, project_id, session_id, summary_md, created_at)
+    VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET session_id = excluded.session_id, summary_md = excluded.summary_md, created_at = excluded.created_at
+  `).run(globalRowId(sourceId, row.id), aggregateProjectId, row.sessionId === null ? null : globalRowId(sourceId, row.sessionId), row.summaryMd, row.createdAt);
+}
+function globalRowId(sourceId, sourceRowId) {
+    return `${sourceId}:${sourceRowId}`;
+}

package/dist/globalMemoryImport.js

@@ -0,0 +1,194 @@
+import { createHash } from "node:crypto";
+import Database from "better-sqlite3";
+import { upsertAggregateProject, upsertCanonicalEvent, upsertCanonicalHandoff, upsertCanonicalSession, } from "./globalMemoryCanonical.js";
+import { redactSecrets, sanitizeGitRemote } from "./privacy.js";
+const GLOBAL_TABLES = ["sources", "global_projects", "global_sessions", "global_events", "global_handoffs"];
+export function importCandidates(globalDbPath, scan, aggregateProject) {
+    const global = new Database(globalDbPath);
+    const skipped = [...scan.skipped];
+    try {
+        const before = readGlobalCounts(global);
+        const imported = { sources: 0, projects: 0, sessions: 0, events: 0, handoffs: 0 };
+        for (const candidate of scan.candidates) {
+            const result = importCandidate(global, candidate, aggregateProject);
+            if (result.kind === "skipped") {
+                skipped.push({ dbPath: candidate.dbPath, reason: result.reason });
+            }
+            else {
+                imported.sources += result.imported.sources;
+                imported.projects += result.imported.projects;
+                imported.sessions += result.imported.sessions;
+                imported.events += result.imported.events;
+                imported.handoffs += result.imported.handoffs;
+            }
+        }
+        return { sources: scan.candidates.length - (skipped.length - scan.skipped.length), imported, before, after: readGlobalCounts(global), skipped };
+    }
+    finally {
+        global.close();
+    }
+}
+export function listGlobalMemoryFromDb(globalDbPath) {
+    const db = new Database(globalDbPath, { readonly: true, fileMustExist: true });
+    try {
+        return {
+            sources: db
+                .prepare("SELECT id, db_path AS dbPath, schema_version AS schemaVersion, imported_at AS importedAt, last_seen_at AS lastSeenAt FROM sources ORDER BY db_path ASC")
+                .all(),
+            counts: readGlobalCounts(db),
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+function importCandidate(global, candidate, aggregateProject) {
+    let source;
+    try {
+        source = new Database(candidate.dbPath, { readonly: true, fileMustExist: true });
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return { kind: "skipped", reason: error.message };
+        throw error;
+    }
+    try {
+        const sourceId = sourceIdForPath(candidate.dbPath);
+        const now = new Date().toISOString();
+        const rows = {
+            projects: readProjects(source).map(redactProjectRow),
+            sessions: readSessions(source),
+            events: readEvents(source).map(redactEventRow),
+            handoffs: readHandoffs(source).map(redactHandoffRow),
+        };
+        const write = global.transaction(() => {
+            const counts = { sources: 0, projects: 0, sessions: 0, events: 0, handoffs: 0 };
+            upsertAggregateProject(global, aggregateProject);
+            counts.sources += global
+                .prepare("INSERT INTO sources (id, db_path, schema_version, imported_at, last_seen_at) VALUES (?, ?, ?, ?, ?) ON CONFLICT(db_path) DO UPDATE SET schema_version = excluded.schema_version, last_seen_at = excluded.last_seen_at")
+                .run(sourceId, candidate.dbPath, candidate.schemaVersion, now, now).changes;
+            for (const row of rows.projects)
+                counts.projects += upsertProject(global, sourceId, row);
+            for (const row of rows.sessions)
+                counts.sessions += upsertSession(global, sourceId, row);
+            for (const row of rows.events)
+                counts.events += upsertEvent(global, sourceId, row);
+            for (const row of rows.handoffs)
+                counts.handoffs += upsertHandoff(global, sourceId, row);
+            for (const row of rows.sessions)
+                upsertCanonicalSession(global, sourceId, aggregateProject.id, row);
+            for (const row of rows.events)
+                upsertCanonicalEvent(global, sourceId, aggregateProject.id, row);
+            for (const row of rows.handoffs)
+                upsertCanonicalHandoff(global, sourceId, aggregateProject.id, row);
+            return counts;
+        });
+        return { kind: "imported", imported: write() };
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return { kind: "skipped", reason: error.message };
+        throw error;
+    }
+    finally {
+        source.close();
+    }
+}
+function readProjects(db) {
+    return db
+        .prepare("SELECT id, repo_root AS repoRoot, git_remote AS gitRemote, created_at AS createdAt, last_seen_at AS lastSeenAt FROM projects ORDER BY id ASC")
+        .all();
+}
+function readSessions(db) {
+    if (!tableExists(db, "sessions"))
+        return [];
+    return db
+        .prepare("SELECT id, project_id AS projectId, host, adapter, started_at AS startedAt, ended_at AS endedAt, git_branch AS gitBranch, git_head AS gitHead FROM sessions ORDER BY id ASC")
+        .all();
+}
+function readEvents(db) {
+    return db
+        .prepare("SELECT id, session_id AS sessionId, project_id AS projectId, type, summary, payload_json AS payloadJson, created_at AS createdAt FROM events ORDER BY id ASC")
+        .all();
+}
+function readHandoffs(db) {
+    if (!tableExists(db, "handoffs"))
+        return [];
+    return db
+        .prepare("SELECT id, project_id AS projectId, session_id AS sessionId, summary_md AS summaryMd, created_at AS createdAt FROM handoffs ORDER BY id ASC")
+        .all();
+}
+function upsertProject(db, sourceId, row) {
+    return db
+        .prepare(`
+      INSERT INTO global_projects (id, source_id, source_project_id, repo_root, git_remote, created_at, last_seen_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(source_id, source_project_id) DO UPDATE SET repo_root = excluded.repo_root, git_remote = excluded.git_remote, last_seen_at = excluded.last_seen_at
+    `)
+        .run(globalRowId(sourceId, row.id), sourceId, row.id, row.repoRoot, row.gitRemote ?? "", row.createdAt, row.lastSeenAt).changes;
+}
+function redactProjectRow(row) {
+    return { ...row, gitRemote: sanitizeGitRemote(row.gitRemote) };
+}
+function redactEventRow(row) {
+    return {
+        ...row,
+        summary: redactSecrets(row.summary),
+        payloadJson: row.payloadJson === null ? null : redactSecrets(row.payloadJson),
+    };
+}
+function redactHandoffRow(row) {
+    return { ...row, summaryMd: redactSecrets(row.summaryMd) };
+}
+function upsertSession(db, sourceId, row) {
+    return db
+        .prepare(`
+      INSERT INTO global_sessions (id, source_id, source_session_id, source_project_id, host, adapter, started_at, ended_at, git_branch, git_head)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(source_id, source_session_id) DO UPDATE SET source_project_id = excluded.source_project_id, host = excluded.host, adapter = excluded.adapter, ended_at = excluded.ended_at, git_branch = excluded.git_branch, git_head = excluded.git_head
+    `)
+        .run(globalRowId(sourceId, row.id), sourceId, row.id, row.projectId, row.host, row.adapter, row.startedAt, row.endedAt, row.gitBranch, row.gitHead).changes;
+}
+function upsertEvent(db, sourceId, row) {
+    return db
+        .prepare(`
+      INSERT INTO global_events (id, source_id, source_event_id, source_session_id, source_project_id, type, summary, payload_json, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(source_id, source_event_id) DO UPDATE SET source_session_id = excluded.source_session_id, source_project_id = excluded.source_project_id, type = excluded.type, summary = excluded.summary, payload_json = excluded.payload_json, created_at = excluded.created_at
+    `)
+        .run(globalRowId(sourceId, row.id), sourceId, row.id, row.sessionId ?? "", row.projectId, row.type, row.summary, row.payloadJson, row.createdAt).changes;
+}
+function upsertHandoff(db, sourceId, row) {
+    return db
+        .prepare(`
+      INSERT INTO global_handoffs (id, source_id, source_handoff_id, source_project_id, source_session_id, summary_md, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(source_id, source_handoff_id) DO UPDATE SET source_project_id = excluded.source_project_id, source_session_id = excluded.source_session_id, summary_md = excluded.summary_md, created_at = excluded.created_at
+    `)
+        .run(globalRowId(sourceId, row.id), sourceId, row.id, row.projectId, row.sessionId, row.summaryMd, row.createdAt).changes;
+}
+function readGlobalCounts(db) {
+    if (!GLOBAL_TABLES.every((tableName) => tableExists(db, tableName)))
+        return { sources: 0, projects: 0, sessions: 0, events: 0, handoffs: 0 };
+    return {
+        sources: readGlobalCount(db, "sources"),
+        projects: readGlobalCount(db, "global_projects"),
+        sessions: readGlobalCount(db, "global_sessions"),
+        events: readGlobalCount(db, "global_events"),
+        handoffs: readGlobalCount(db, "global_handoffs"),
+    };
+}
+function readGlobalCount(db, tableName) {
+    const row = db.prepare(`SELECT COUNT(*) AS count FROM ${tableName}`).get();
+    return row?.count ?? 0;
+}
+function tableExists(db, tableName) {
+    const row = db.prepare("SELECT COUNT(*) AS count FROM sqlite_master WHERE type = 'table' AND name = ?").get(tableName);
+    return row !== undefined && row.count === 1;
+}
+function sourceIdForPath(dbPath) {
+    return `src_${createHash("sha256").update(dbPath).digest("hex").slice(0, 24)}`;
+}
+function globalRowId(sourceId, sourceRowId) {
+    return `${sourceId}:${sourceRowId}`;
+}

package/dist/graphTui.js

@@ -0,0 +1,239 @@
+import { spawn } from "node:child_process";
+import { BoxRenderable, createCliRenderer, TextRenderable } from "@opentui/core";
+const SNAPSHOT_ENV = "OMO_MEMORY_GRAPH_TUI_SNAPSHOT";
+const COLORS = {
+    background: "#101419",
+    border: "#516071",
+    detail: "#17212b",
+    text: "#d8dee9",
+    muted: "#94a3b8",
+    accent: "#7dd3fc",
+};
+export async function runGraphTui(options) {
+    const existingSnapshot = parseSnapshot(process.env[SNAPSHOT_ENV]);
+    if (process.versions["bun"] === undefined) {
+        const graphSnapshot = existingSnapshot ?? (await createGraphSnapshot(options));
+        await runWithBun(options, graphSnapshot);
+        return;
+    }
+    if (existingSnapshot === null) {
+        throw new Error("graph tui OpenTUI renderer requires a graph snapshot");
+    }
+    const renderer = await createCliRenderer({
+        targetFps: 12,
+        maxFps: 12,
+        screenMode: "main-screen",
+        consoleMode: "disabled",
+        clearOnShutdown: false,
+    });
+    renderer.setTerminalTitle("OMO Ontology Graph");
+    let state = { options, selectedId: null, snapshot: existingSnapshot };
+    let graph = loadGraph(state);
+    state = { ...state, selectedId: graph.detail?.id ?? null };
+    const root = new BoxRenderable(renderer, {
+        id: "graph-root",
+        width: "100%",
+        height: "100%",
+        flexDirection: "column",
+        backgroundColor: COLORS.background,
+        padding: 1,
+        gap: 1,
+    });
+    const title = new TextRenderable(renderer, { id: "graph-title", content: "", fg: COLORS.accent, height: 1, truncate: true });
+    const body = new BoxRenderable(renderer, { id: "graph-body", flexGrow: 1, flexDirection: "row", gap: 1 });
+    const nodesPane = new BoxRenderable(renderer, {
+        id: "graph-nodes-pane",
+        width: "50%",
+        height: "100%",
+        border: true,
+        borderColor: COLORS.border,
+        title: "Nodes",
+        padding: 1,
+        backgroundColor: COLORS.background,
+    });
+    const detailPane = new BoxRenderable(renderer, {
+        id: "graph-detail-pane",
+        flexGrow: 1,
+        height: "100%",
+        border: true,
+        borderColor: COLORS.border,
+        title: "Detail Pane",
+        padding: 1,
+        backgroundColor: COLORS.detail,
+    });
+    const nodesText = new TextRenderable(renderer, { id: "graph-nodes", content: "", fg: COLORS.text, wrapMode: "word" });
+    const detailText = new TextRenderable(renderer, { id: "graph-detail", content: "", fg: COLORS.text, wrapMode: "word" });
+    const footer = new TextRenderable(renderer, { id: "graph-footer", content: "", fg: COLORS.muted, height: 1, truncate: true });
+    nodesPane.add(nodesText);
+    detailPane.add(detailText);
+    body.add(nodesPane);
+    body.add(detailPane);
+    root.add(title);
+    root.add(body);
+    root.add(footer);
+    renderer.root.add(root);
+    const render = () => {
+        graph = loadGraph(state);
+        state = { ...state, selectedId: graph.detail?.id ?? null };
+        title.content = titleText(graph, state.options.query);
+        nodesText.content = nodesContent(graph);
+        detailText.content = detailContent(graph);
+        footer.content = "q quit | ArrowUp/ArrowDown/Tab select | Legend: D durable, W working, T temporary, E ephemeral";
+        renderer.requestRender();
+    };
+    await new Promise((resolve) => {
+        const quit = () => {
+            renderer.keyInput.removeAllListeners("keypress");
+            renderer.destroy();
+            resolve();
+        };
+        renderer.keyInput.on("keypress", (key) => {
+            if (key.name === "q" || (key.name === "c" && key.ctrl)) {
+                quit();
+                return;
+            }
+            const nextId = nextSelectedId(graph.nodes, state.selectedId, key.name);
+            if (nextId !== state.selectedId) {
+                state = { ...state, selectedId: nextId };
+                render();
+            }
+        });
+        writeCaptureFrame(graph, state.options.query);
+        renderer.start();
+        render();
+    });
+}
+async function runWithBun(options, snapshot) {
+    const scriptPath = process.argv[1];
+    if (scriptPath === undefined)
+        throw new Error("graph tui requires a CLI script path");
+    const args = [scriptPath, "graph", "tui", "--db", options.dbPath];
+    if (options.query !== undefined)
+        args.push("--query", options.query);
+    await new Promise((resolve, reject) => {
+        const child = spawn("bun", args, {
+            stdio: "inherit",
+            env: { ...process.env, [SNAPSHOT_ENV]: JSON.stringify(snapshot) },
+        });
+        child.once("error", (error) => {
+            reject(new Error(`graph tui requires Bun for OpenTUI native FFI: ${error.message}`));
+        });
+        child.once("exit", (code, signal) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`graph tui OpenTUI runtime exited with ${signal ?? code ?? "unknown status"}`));
+        });
+    });
+}
+async function createGraphSnapshot(options) {
+    const { projectOntologyGraph } = await import("./ontologyGraph.js");
+    const graph = projectOntologyGraph({
+        dbPath: options.dbPath,
+        ...(options.query === undefined ? {} : { query: options.query }),
+    });
+    const details = graph.nodes
+        .map((node) => projectOntologyGraph({
+        dbPath: options.dbPath,
+        ...(options.query === undefined ? {} : { query: options.query }),
+        selectedId: node.id,
+    }).detail)
+        .filter((detail) => detail !== null);
+    return { graph, details };
+}
+function parseSnapshot(raw) {
+    if (raw === undefined)
+        return null;
+    const parsed = JSON.parse(raw);
+    if (!isGraphSnapshot(parsed))
+        throw new Error("invalid graph tui snapshot");
+    return parsed;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object";
+}
+function isGraphSnapshot(value) {
+    if (!isRecord(value))
+        return false;
+    return isRecord(value["graph"]) && Array.isArray(value["details"]);
+}
+function loadGraph(state) {
+    const selectedId = state.selectedId ?? state.snapshot.graph.detail?.id ?? state.snapshot.graph.nodes[0]?.id ?? null;
+    const detail = selectedId === null ? state.snapshot.graph.detail : (state.snapshot.details.find((item) => item.id === selectedId) ?? null);
+    return {
+        ...state.snapshot.graph,
+        nodes: state.snapshot.graph.nodes.map((node) => ({ ...node, selected: node.id === selectedId })),
+        detail,
+    };
+}
+function titleText(graph, query) {
+    const queryLabel = query === undefined ? "all concepts" : `query "${query}"`;
+    return `OMO Ontology Graph - ${queryLabel} - ${graph.nodes.length} nodes / ${graph.edges.length} edges`;
+}
+function nodesContent(graph) {
+    if (graph.nodes.length === 0)
+        return graph.message ?? "No ontology graph data is available yet.";
+    const edges = graph.edges.map((edge) => `  ${edge.sourceId} -> ${edge.targetId} [${edge.label}]`);
+    return [...graph.nodes.map((node) => nodeLine(node)), "", "Relations", ...(edges.length === 0 ? ["  none in current filter"] : edges)].join("\n");
+}
+function detailContent(graph) {
+    if (graph.detail === null)
+        return graph.message ?? "No ontology graph data is available yet.";
+    const detail = graph.detail;
+    return [
+        `Label: ${detail.label}`,
+        `Kind: ${detail.kind}`,
+        `Retention: ${classCode(detail.retentionClass)} ${detail.retentionClass}`,
+        `Score: ${detail.scoreLabel}`,
+        `Refs: ${detail.refCount}`,
+        `Projects: ${detail.projectSpread}`,
+        `First seen: ${detail.firstSeen ?? "unknown"}`,
+        `Last seen: ${detail.lastSeen ?? "unknown"}`,
+        `Project: ${detail.project.repoRoot}`,
+        `Remote: ${detail.project.gitRemote ?? "none"}`,
+        "",
+        "Description:",
+        detail.description ?? "none",
+        "",
+        `Aliases: ${detail.aliases.length === 0 ? "none" : detail.aliases.join(", ")}`,
+    ].join("\n");
+}
+function writeCaptureFrame(graph, query) {
+    process.stdout.write([
+        titleText(graph, query),
+        "",
+        "Nodes",
+        nodesContent(graph),
+        "",
+        "Detail",
+        detailContent(graph),
+        "",
+        "Legend: D durable, W working, T temporary, E ephemeral",
+        "",
+    ].join("\n"));
+}
+function nodeLine(node) {
+    const marker = node.selected ? ">" : " ";
+    return `${marker} ${classCode(node.retentionClass)} ${node.label} (${node.kind}, ${node.scoreLabel}, refs ${node.refCount})`;
+}
+function classCode(retentionClass) {
+    const normalized = retentionClass.toLowerCase();
+    if (normalized === "durable")
+        return "D";
+    if (normalized === "temporary")
+        return "T";
+    if (normalized === "ephemeral")
+        return "E";
+    return "W";
+}
+function nextSelectedId(nodes, selectedId, keyName) {
+    if (nodes.length === 0)
+        return null;
+    const currentIndex = Math.max(0, nodes.findIndex((node) => node.id === selectedId));
+    const delta = keyName === "up" ? -1 : keyName === "down" || keyName === "tab" ? 1 : 0;
+    if (delta === 0)
+        return selectedId;
+    const nextIndex = (currentIndex + delta + nodes.length) % nodes.length;
+    return nodes[nextIndex]?.id ?? selectedId;
+}

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