omo-memory 0.1.14 → 0.1.16

package/dist/graphTui.js

@@ -1,234 +0,0 @@
-import { spawn } from "node:child_process";
-import { BoxRenderable, createCliRenderer, TextRenderable } from "@opentui/core";
-import { classCode, graphContent } from "./graphTuiCanvas.js";
-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 = graphContent(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.detail === null ? [] : [graph.detail];
-    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 selectedNode = selectedId === null ? undefined : state.snapshot.graph.nodes.find((node) => node.id === selectedId);
-    const detail = selectedId === null ? state.snapshot.graph.detail : (state.snapshot.details.find((item) => item.id === selectedId) ?? nodeDetail(selectedNode) ?? null);
-    return {
-        ...state.snapshot.graph,
-        nodes: state.snapshot.graph.nodes.map((node) => ({ ...node, selected: node.id === selectedId })),
-        detail,
-    };
-}
-function nodeDetail(node) {
-    if (node === undefined)
-        return null;
-    return {
-        id: node.id,
-        label: node.label,
-        kind: node.kind,
-        description: node.description,
-        aliases: node.aliases,
-        retentionClass: node.retentionClass,
-        score: node.score,
-        scoreLabel: node.scoreLabel,
-        refCount: node.refCount,
-        projectSpread: node.projectSpread,
-        firstSeen: node.firstSeen,
-        lastSeen: node.lastSeen,
-        project: node.project,
-    };
-}
-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 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),
-        "",
-        "Graph",
-        graphContent(graph),
-        "",
-        "Detail",
-        detailContent(graph),
-        "",
-        "Legend: D durable, W working, T temporary, E ephemeral",
-        "",
-    ].join("\n"));
-}
-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/graphTuiCanvas.js

@@ -1,104 +0,0 @@
-const GRAPH_WIDTH = 66;
-const GRAPH_HEIGHT = 24;
-const NODE_LIMIT = 28;
-export function graphContent(graph) {
-    if (graph.nodes.length === 0)
-        return graph.message ?? "No ontology graph data is available yet.";
-    const drawnNodes = graph.nodes.slice(0, NODE_LIMIT);
-    const positions = layoutNodes(drawnNodes);
-    const rows = Array.from({ length: GRAPH_HEIGHT }, () => Array.from({ length: GRAPH_WIDTH }, () => " "));
-    for (const edge of graph.edges) {
-        const source = positions.get(edge.sourceId);
-        const target = positions.get(edge.targetId);
-        if (source === undefined || target === undefined)
-            continue;
-        drawEdge(rows, source, target);
-    }
-    for (const node of drawnNodes) {
-        const position = positions.get(node.id);
-        if (position === undefined)
-            continue;
-        drawNode(rows, node, position);
-    }
-    const graphLines = rows.map((row) => row.join("").trimEnd());
-    const legend = drawnNodes.map((node) => nodeLine(node));
-    return [...graphLines, "", "Nodes", ...legend, "", "Relations", ...relationLines(graph, positions)].join("\n");
-}
-export function nodeLine(node) {
-    const marker = node.selected ? ">" : " ";
-    return `${marker} ${classCode(node.retentionClass)} ${node.label} (${node.kind}, ${node.scoreLabel}, refs ${node.refCount})`;
-}
-export 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 layoutNodes(nodes) {
-    const centerX = Math.floor(GRAPH_WIDTH / 2);
-    const centerY = Math.floor(GRAPH_HEIGHT / 2);
-    const radiusX = Math.max(8, Math.floor(GRAPH_WIDTH / 2) - 8);
-    const radiusY = Math.max(4, Math.floor(GRAPH_HEIGHT / 2) - 3);
-    const positions = new Map();
-    nodes.forEach((node, index) => {
-        const angle = (2 * Math.PI * index) / Math.max(1, nodes.length);
-        const scorePull = Math.max(0.55, 1 - Math.min(90, node.score) / 220);
-        positions.set(node.id, {
-            x: clamp(Math.round(centerX + Math.cos(angle) * radiusX * scorePull), 2, GRAPH_WIDTH - 3),
-            y: clamp(Math.round(centerY + Math.sin(angle) * radiusY * scorePull), 1, GRAPH_HEIGHT - 2),
-        });
-    });
-    return positions;
-}
-function drawEdge(rows, source, target) {
-    const steps = Math.max(Math.abs(target.x - source.x), Math.abs(target.y - source.y), 1);
-    for (let index = 1; index < steps; index += 1) {
-        const x = Math.round(source.x + ((target.x - source.x) * index) / steps);
-        const y = Math.round(source.y + ((target.y - source.y) * index) / steps);
-        const row = rows[y];
-        const current = row?.[x];
-        if (row === undefined || current === undefined || current !== " ")
-            continue;
-        row[x] = edgeGlyph(source, target);
-    }
-}
-function edgeGlyph(source, target) {
-    const dx = target.x - source.x;
-    const dy = target.y - source.y;
-    if (Math.abs(dx) > Math.abs(dy) * 2)
-        return "-";
-    if (Math.abs(dy) > Math.abs(dx) * 2)
-        return "|";
-    return dx * dy > 0 ? "\\" : "/";
-}
-function drawNode(rows, node, point) {
-    const glyph = node.selected ? "●" : classCode(node.retentionClass);
-    const label = `${glyph}${shortLabel(node.label)}`;
-    const startX = clamp(point.x - Math.floor(label.length / 2), 0, Math.max(0, GRAPH_WIDTH - label.length));
-    for (let index = 0; index < label.length; index += 1) {
-        const row = rows[point.y];
-        if (row === undefined)
-            continue;
-        row[startX + index] = label[index] ?? " ";
-    }
-}
-function shortLabel(label) {
-    const compact = label.replace(/\s+/g, " ").trim();
-    return compact.length <= 11 ? compact : compact.slice(0, 10);
-}
-function relationLines(graph, positions) {
-    const visible = graph.edges.filter((edge) => positions.has(edge.sourceId) && positions.has(edge.targetId)).slice(0, 12);
-    if (visible.length === 0)
-        return ["  none in current filter"];
-    return visible.map((edge) => `  ${nodeLabel(graph, edge.sourceId)} -> ${nodeLabel(graph, edge.targetId)} [${edge.label}]`);
-}
-function nodeLabel(graph, nodeId) {
-    return graph.nodes.find((node) => node.id === nodeId)?.label ?? nodeId;
-}
-function clamp(value, min, max) {
-    return Math.min(max, Math.max(min, value));
-}

package/dist/mcpOntologyTools.js

@@ -1,117 +0,0 @@
-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/ontologyCore.js

@@ -1,142 +0,0 @@
-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();
-    }
-}