omo-memory 0.1.12 → 0.1.14

package/README.md

@@ -39,6 +39,7 @@ After the package is published to npm, use the same package for CLI and MCP:
 
 ```sh
 npx -y omo-memory init
+npx -y omo-memory update
 npx -y omo-memory global scan --root .
 npx -y omo-memory global migrate --root . --global-db ~/.omo/memory/global.sqlite
 npx -y omo-memory session bootstrap --host codex --adapter lazycodex --limit 5
@@ -105,6 +106,7 @@ The response contains a new `sessionId` and project metadata only. It deliberate
 ```
 
 This is local routing, not transcript scraping. OMO Memory does not automatically read full Codex or Grok transcripts. Hooks should record concise user actions, decisions, QA evidence, and handoffs; they should retrieve memory only when the user explicitly asks for OMO Memory or when the current user input can be matched to recorded intent.
+The packaged `scripts/omo-memory-user-prompt.mjs` helper is the supported UserPromptSubmit hook target for adapters that can invoke a command with the hook payload on stdin. It records only the current user prompt as a redacted `user_prompt` event, ignores assistant output, and exits successfully without blocking the host when OMO Memory is unavailable.
 
 Use explicit retrieval for memory reads:
 
@@ -140,6 +142,22 @@ Initial stdio MCP tools:
 - `memory_ontology_supersede`
 - `memory_ontology_recall`
 
+## Updates
+
+Installed CLI commands automatically launch a quiet background `npm install -g omo-memory@latest` at most once per day. MCP startup does not run the updater, so stdio handshakes stay clean.
+
+Manual update:
+
+```sh
+omo-memory update
+```
+
+Disable automatic update for pinned environments:
+
+```sh
+OMO_MEMORY_AUTO_UPDATE=0 omo-memory doctor
+```
+
 ## Second-brain layer
 
 The base ledger remains project-local and chronological: sessions, events, handoffs, and explicit recall. The second-brain layer adds deterministic ontology tables and lifecycle commands:

package/dist/autoUpdate.js

@@ -0,0 +1,84 @@
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const PACKAGE_NAME = "omo-memory";
+const DEFAULT_INTERVAL_MS = 86_400_000;
+const STATE_PATH = join(homedir(), ".omo", "memory", "auto-update.json");
+export function maybeRunAutoUpdate(currentVersion, nowMs = Date.now()) {
+    const statePath = process.env["OMO_MEMORY_UPDATE_STATE"] ?? STATE_PATH;
+    if (!shouldAttemptAutoUpdate({ nowMs, statePath }))
+        return;
+    writeAttemptStamp(statePath, nowMs);
+    const child = spawn(npmCommand(), installArgs(), {
+        detached: true,
+        stdio: "ignore",
+        env: updateEnv(currentVersion),
+    });
+    child.unref();
+}
+export function runAutoUpdate(currentVersion) {
+    const command = npmCommand();
+    const args = installArgs();
+    const result = spawnSync(command, args, { encoding: "utf8", env: updateEnv(currentVersion) });
+    return {
+        ok: result.status === 0,
+        packageName: PACKAGE_NAME,
+        currentVersion,
+        command: [command, ...args],
+        status: result.status,
+        stdout: result.stdout,
+        stderr: result.stderr,
+    };
+}
+function shouldAttemptAutoUpdate(input) {
+    if (process.env["OMO_MEMORY_AUTO_UPDATE"] === "0")
+        return false;
+    if (process.env["OMO_MEMORY_AUTO_UPDATE"] === "false")
+        return false;
+    if (process.env["OMO_MEMORY_AUTO_UPDATE_CHILD"] === "1")
+        return false;
+    const intervalMs = updateIntervalMs();
+    if (!existsSync(input.statePath))
+        return true;
+    const lastAttemptMs = readLastAttemptMs(input.statePath);
+    return lastAttemptMs === null || input.nowMs - lastAttemptMs >= intervalMs;
+}
+function updateIntervalMs() {
+    const raw = process.env["OMO_MEMORY_AUTO_UPDATE_INTERVAL_MS"];
+    if (raw === undefined)
+        return DEFAULT_INTERVAL_MS;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_INTERVAL_MS;
+}
+function readLastAttemptMs(statePath) {
+    try {
+        const parsed = JSON.parse(readFileSync(statePath, "utf8"));
+        if (!isRecord(parsed))
+            return null;
+        const value = parsed["lastAttemptMs"];
+        return typeof value === "number" && Number.isFinite(value) ? value : null;
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return null;
+        throw error;
+    }
+}
+function writeAttemptStamp(statePath, nowMs) {
+    mkdirSync(dirname(statePath), { recursive: true });
+    writeFileSync(statePath, `${JSON.stringify({ lastAttemptMs: nowMs })}\n`);
+}
+function npmCommand() {
+    return process.env["OMO_MEMORY_NPM_COMMAND"] ?? "npm";
+}
+function installArgs() {
+    const target = process.env["OMO_MEMORY_UPDATE_TARGET"] ?? `${PACKAGE_NAME}@latest`;
+    return ["install", "-g", target];
+}
+function updateEnv(currentVersion) {
+    return { ...process.env, OMO_MEMORY_AUTO_UPDATE_CHILD: "1", OMO_MEMORY_CURRENT_VERSION: currentVersion };
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object";
+}

package/dist/cli.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { readFileSync } from "node:fs";
+import { maybeRunAutoUpdate, runAutoUpdate } from "./autoUpdate.js";
 import { applyConceptExtraction } from "./conceptExtraction.js";
 import { migrateToGlobalMemory, scanForMemoryDbs } from "./globalMemory.js";
 import { runGraphTui } from "./graphTui.js";
@@ -21,6 +22,12 @@ async function main(argv) {
         await runMcpServer();
         return;
     }
+    const currentVersion = readPackageVersion();
+    if (command === "update") {
+        process.stdout.write(`${JSON.stringify(runAutoUpdate(currentVersion), null, 2)}\n`);
+        return;
+    }
+    maybeRunAutoUpdate(currentVersion);
     if (command === "graph" && subcommand === "tui") {
         const query = readFlag(rest, "--query");
         await runGraphTui({ dbPath: readFlag(rest, "--db") ?? defaultDbPath(), ...(query === undefined ? {} : { query }) });
@@ -200,7 +207,17 @@ function fail(message) {
     throw new Error(message);
 }
 function printHelp() {
-    process.stdout.write(`OMO Memory\n\nCommands:\n  omo-memory init\n  omo-memory doctor\n  omo-memory export\n  omo-memory purge --yes\n  omo-memory global scan --root <path> [--json]\n  omo-memory global migrate --root <path> --global-db <path> [--json]\n  omo-memory ontology candidates\n  omo-memory ontology score\n  omo-memory ontology promote --concept <label|id> [--summary <text>] [--body <text>]\n  omo-memory ontology demote --id <durable-id>\n  omo-memory ontology supersede --id <durable-id> [--summary <text>]\n  omo-memory ontology recall --query <text> [--limit <n>]\n  omo-memory session start --host <codex|opencode|grok|unknown> --adapter <name>\n  omo-memory session bootstrap --host <codex|opencode|grok|unknown> --adapter <name> [--limit <n>]\n  omo-memory event record --type <type> --summary <text> [--session-id <id>]\n  omo-memory recent [--limit <n>]\n  omo-memory recall --query <text> [--limit <n>]\n  omo-memory handoff write (--summary <text> | --summary-file <path>) [--session-id <id>]\n  omo-memory graph tui [--db <path>] [--query <text>]  (requires Bun on PATH)\n  omo-memory mcp\n`);
+    process.stdout.write(`OMO Memory\n\nCommands:\n  omo-memory init\n  omo-memory doctor\n  omo-memory update\n  omo-memory export\n  omo-memory purge --yes\n  omo-memory global scan --root <path> [--json]\n  omo-memory global migrate --root <path> --global-db <path> [--json]\n  omo-memory ontology candidates\n  omo-memory ontology score\n  omo-memory ontology promote --concept <label|id> [--summary <text>] [--body <text>]\n  omo-memory ontology demote --id <durable-id>\n  omo-memory ontology supersede --id <durable-id> [--summary <text>]\n  omo-memory ontology recall --query <text> [--limit <n>]\n  omo-memory session start --host <codex|opencode|grok|unknown> --adapter <name>\n  omo-memory session bootstrap --host <codex|opencode|grok|unknown> --adapter <name> [--limit <n>]\n  omo-memory event record --type <type> --summary <text> [--session-id <id>]\n  omo-memory recent [--limit <n>]\n  omo-memory recall --query <text> [--limit <n>]\n  omo-memory handoff write (--summary <text> | --summary-file <path>) [--session-id <id>]\n  omo-memory graph tui [--db <path>] [--query <text>]  (requires Bun on PATH)\n  omo-memory mcp\n`);
+}
+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";
 }
 main(process.argv.slice(2)).catch((error) => {
     const message = error instanceof Error ? error.message : String(error);

package/dist/globalMemory.js

@@ -6,6 +6,22 @@ import { migrate } from "./memoryDb.js";
 import { resolveProjectContext } from "./projectContext.js";
 const STATE_DB_SUFFIX = join(".omo", "memory", "state.sqlite");
 const REQUIRED_TABLES = ["schema_meta", "projects", "events"];
+const PRUNED_DIR_NAMES = new Set([
+    ".cache",
+    ".git",
+    ".hg",
+    ".next",
+    ".pnpm-store",
+    ".turbo",
+    ".venv",
+    ".yarn",
+    "Library",
+    "build",
+    "dist",
+    "node_modules",
+    "target",
+    "vendor",
+]);
 export function initGlobalMemory(globalDbPath) {
     mkdirSync(dirname(globalDbPath), { recursive: true });
     const db = new Database(globalDbPath);
@@ -105,7 +121,7 @@ function findStateDbs(rootPath) {
         }
         for (const entry of entries) {
             const entryPath = join(path, entry.name);
-            if (entry.isDirectory())
+            if (entry.isDirectory() && shouldVisitDirectory(entry.name, entryPath))
                 visit(entryPath);
             else if (entry.isFile() && entryPath.endsWith(STATE_DB_SUFFIX))
                 dbPaths.push(entryPath);
@@ -114,6 +130,11 @@ function findStateDbs(rootPath) {
     visit(rootPath);
     return dbPaths.sort();
 }
+function shouldVisitDirectory(name, path) {
+    if (path.endsWith(join(".omo", "memory")))
+        return true;
+    return !PRUNED_DIR_NAMES.has(name);
+}
 function scanSourceDb(dbPath) {
     let db;
     try {

package/dist/graphTui.js

@@ -1,5 +1,6 @@
 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",
@@ -76,7 +77,7 @@ export async function runGraphTui(options) {
         graph = loadGraph(state);
         state = { ...state, selectedId: graph.detail?.id ?? null };
         title.content = titleText(graph, state.options.query);
-        nodesText.content = nodesContent(graph);
+        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();
@@ -133,13 +134,7 @@ async function createGraphSnapshot(options) {
         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);
+    const details = graph.detail === null ? [] : [graph.detail];
     return { graph, details };
 }
 function parseSnapshot(raw) {
@@ -160,23 +155,37 @@ function isGraphSnapshot(value) {
 }
 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);
+    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 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.";
@@ -203,8 +212,8 @@ function writeCaptureFrame(graph, query) {
     process.stdout.write([
         titleText(graph, query),
         "",
-        "Nodes",
-        nodesContent(graph),
+        "Graph",
+        graphContent(graph),
         "",
         "Detail",
         detailContent(graph),
@@ -213,20 +222,6 @@ function writeCaptureFrame(graph, query) {
         "",
     ].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;

package/dist/graphTuiCanvas.js

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

@@ -1,4 +1,5 @@
 import { migrate, openMemoryDb } from "./memoryDb.js";
+import { readGraphEdges } from "./ontologyGraphEdges.js";
 import { redactSecrets, sanitizeGitRemote } from "./privacy.js";
 function isRecord(value) {
     return value !== null && typeof value === "object";
@@ -55,21 +56,6 @@ function parseConceptRow(value) {
         gitRemote: nullableText(value["gitRemote"]),
     };
 }
-function parseRelationRow(value) {
-    if (!isRecord(value)) {
-        throw new Error("invalid relation row");
-    }
-    return {
-        id: text(value["id"]),
-        projectId: text(value["projectId"]),
-        sourceId: text(value["sourceId"]),
-        targetId: text(value["targetId"]),
-        relation: text(value["relation"]),
-        weight: numberValue(value["weight"]),
-        repoRoot: text(value["repoRoot"]),
-        gitRemote: nullableText(value["gitRemote"]),
-    };
-}
 function matchesQuery(row, query) {
     const haystack = `${row.label}\n${row.description ?? ""}\n${row.aliases.join("\n")}`.toLowerCase();
     return haystack.includes(query);
@@ -88,6 +74,8 @@ function toNode(row, selectedId) {
         scoreLabel: `${score} ${retentionClass}`,
         refCount: Math.round(row.refCount),
         projectSpread: Math.round(row.projectSpread),
+        firstSeen: row.firstSeen,
+        lastSeen: row.lastSeen,
         project: projectFrom(row),
         selected: selectedId === row.id,
     };
@@ -111,19 +99,6 @@ function toDetail(row) {
         project: projectFrom(row),
     };
 }
-function toEdge(row) {
-    const weight = Number(row.weight.toFixed(2));
-    const relation = redactSecrets(row.relation);
-    return {
-        id: row.id,
-        sourceId: row.sourceId,
-        targetId: row.targetId,
-        relation,
-        label: `${relation} ${weight.toFixed(2)}`,
-        weight,
-        project: projectFrom(row),
-    };
-}
 export function projectOntologyGraph(options) {
     const db = openMemoryDb(options.dbPath);
     try {
@@ -148,21 +123,9 @@ export function projectOntologyGraph(options) {
         const selectedId = options.selectedId && conceptIds.has(options.selectedId) ? options.selectedId : (conceptRows[0]?.id ?? null);
         const nodes = conceptRows.map((row) => toNode(row, selectedId));
         const selectedRow = selectedId === null ? undefined : conceptRows.find((row) => row.id === selectedId);
-        const relationRows = db
-            .prepare(`
-        SELECT r.id, r.project_id AS projectId, r.source_id AS sourceId, r.target_id AS targetId,
-          r.relation, COALESCE(r.weight, 1) AS weight, p.repo_root AS repoRoot, p.git_remote AS gitRemote
-        FROM relations r
-        JOIN projects p ON p.id = r.project_id
-        WHERE r.source_type = 'concept' AND r.target_type = 'concept' AND r.valid_to IS NULL
-        ORDER BY lower(r.relation) ASC, r.id ASC
-      `)
-            .all()
-            .map(parseRelationRow)
-            .filter((row) => conceptIds.has(row.sourceId) && conceptIds.has(row.targetId));
         return {
             nodes,
-            edges: relationRows.map(toEdge),
+            edges: readGraphEdges(db, conceptIds),
             detail: selectedRow === undefined ? null : toDetail(selectedRow),
             message: nodes.length === 0 ? "No ontology graph data is available yet." : null,
         };

package/dist/ontologyGraphEdges.js

@@ -0,0 +1,86 @@
+import { redactSecrets, sanitizeGitRemote } from "./privacy.js";
+export function readGraphEdges(db, conceptIds) {
+    const relationRows = db
+        .prepare(`
+      SELECT r.id, r.project_id AS projectId, r.source_id AS sourceId, r.target_id AS targetId,
+        r.relation, COALESCE(r.weight, 1) AS weight, p.repo_root AS repoRoot, p.git_remote AS gitRemote
+      FROM relations r
+      JOIN projects p ON p.id = r.project_id
+      WHERE r.source_type = 'concept' AND r.target_type = 'concept' AND r.valid_to IS NULL
+      ORDER BY lower(r.relation) ASC, r.id ASC
+    `)
+        .all()
+        .map(parseRelationRow)
+        .filter((row) => conceptIds.has(row.sourceId) && conceptIds.has(row.targetId));
+    const edgeRows = relationRows.length === 0 ? readCoOccurrenceRows(db, conceptIds) : relationRows;
+    return edgeRows.map(toEdge);
+}
+function readCoOccurrenceRows(db, conceptIds) {
+    return db
+        .prepare(`
+      SELECT 'co:' || a.target_id || ':' || b.target_id AS id,
+        a.project_id AS projectId, a.target_id AS sourceId, b.target_id AS targetId,
+        'co_occurs' AS relation, COUNT(*) AS weight, p.repo_root AS repoRoot, p.git_remote AS gitRemote
+      FROM memory_references a
+      JOIN memory_references b
+        ON b.project_id = a.project_id
+        AND b.source_type = a.source_type
+        AND b.source_id = a.source_id
+        AND b.target_type = 'concept'
+        AND a.target_id < b.target_id
+      JOIN projects p ON p.id = a.project_id
+      WHERE a.source_type = 'event' AND a.target_type = 'concept'
+      GROUP BY a.project_id, a.target_id, b.target_id
+      ORDER BY COUNT(*) DESC, a.target_id ASC, b.target_id ASC
+      LIMIT 160
+    `)
+        .all()
+        .map(parseRelationRow)
+        .filter((row) => conceptIds.has(row.sourceId) && conceptIds.has(row.targetId));
+}
+function parseRelationRow(value) {
+    if (!isRecord(value))
+        throw new Error("invalid relation row");
+    return {
+        id: text(value["id"]),
+        projectId: text(value["projectId"]),
+        sourceId: text(value["sourceId"]),
+        targetId: text(value["targetId"]),
+        relation: text(value["relation"]),
+        weight: numberValue(value["weight"]),
+        repoRoot: text(value["repoRoot"]),
+        gitRemote: nullableText(value["gitRemote"]),
+    };
+}
+function toEdge(row) {
+    const weight = Number(row.weight.toFixed(2));
+    const relation = redactSecrets(row.relation);
+    return {
+        id: row.id,
+        sourceId: row.sourceId,
+        targetId: row.targetId,
+        relation,
+        label: `${relation} ${weight.toFixed(2)}`,
+        weight,
+        project: projectFrom(row),
+    };
+}
+function projectFrom(row) {
+    return {
+        id: row.projectId,
+        repoRoot: redactSecrets(row.repoRoot),
+        gitRemote: sanitizeGitRemote(row.gitRemote),
+    };
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object";
+}
+function text(value) {
+    return typeof value === "string" ? value : String(value ?? "");
+}
+function nullableText(value) {
+    return value === null || value === undefined ? null : text(value);
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : Number(value ?? 0);
+}

package/docs/adapter-integration.md

@@ -118,14 +118,14 @@ During the session, hooks should write concise user-action summaries, task state
 }
 ```
 
-This package is the local MCP-to-SQLite router. It does not scrape host transcripts or centralize cloud state. Hosts and adapters must call the MCP tools at their own lifecycle points.
+This package is the local MCP-to-SQLite router. It does not scrape host transcripts, store assistant output, or centralize cloud state. Hosts and adapters must call the MCP tools at their own lifecycle points.
 
 Retrieval is opt-in or intent-gated:
 
 - Use `memory_recent_events` only when the user explicitly asks for recent OMO Memory context.
 - Use `memory_recall_events` when the current user input has a concrete query that can be matched to recorded summaries, decisions, or evidence.
 - Do not automatically attach the last session to every user prompt.
-- Do not store raw user prompts by default; record concise, redacted action summaries.
+- To preserve user intent across sessions, adapters may invoke the packaged `scripts/omo-memory-user-prompt.mjs` UserPromptSubmit helper with the hook payload on stdin. The helper records only the current user prompt as a redacted `user_prompt` event and ignores assistant output.
 
 Use these tools:
 
@@ -150,6 +150,8 @@ Use these tools:
 - `memory_ontology_supersede`
 - `memory_ontology_recall`
 
+CLI updates: normal CLI commands automatically launch a quiet background `npm install -g omo-memory@latest` at most once per day. MCP startup intentionally does not auto-update because stdout/stderr must remain reserved for the protocol. Hosts that need pinned installs should set `OMO_MEMORY_AUTO_UPDATE=0` in the CLI environment.
+
 Global migration is copy/import only. Adapters may scan for existing project-local `.omo/memory/state.sqlite` databases and import them into a user-selected global SQLite file, but they must preserve source DBs and retain source provenance in the global store.
 
 Global migration also materializes an aggregate OMO schema view inside the global SQLite file. This lets existing ontology extraction, retention scoring, recall, and OpenTUI graph code operate on integrated cross-project events while `global_*` tables retain source database provenance.

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "omo-memory",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Host-neutral local SQLite memory and session ledger for OMO adapters, exposed through CLI and MCP.",
   "type": "module",
   "files": [
     "dist",
     "docs",
+    "scripts/omo-memory-user-prompt.mjs",
     "README.md"
   ],
   "bin": {
@@ -32,9 +33,10 @@
     "start": "node dist/cli.js",
     "prepack": "npm run build",
     "presmoke": "npm run build",
-    "smoke": "npm run smoke:cli && npm run smoke:mcp",
+    "smoke": "npm run smoke:cli && npm run smoke:mcp && npm run smoke:hook",
     "smoke:cli": "node scripts/smoke-cli.mjs",
     "smoke:mcp": "node scripts/smoke-mcp.mjs",
+    "smoke:hook": "node scripts/verify-user-prompt-hook.mjs",
     "mcp": "node dist/cli.js mcp",
     "issue:epic": "node scripts/create-epic-issue.mjs"
   },

package/scripts/omo-memory-user-prompt.mjs

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+
+const MAX_SUMMARY_CHARS = 4000;
+
+const host = process.env["OMO_MEMORY_HOST"] ?? "unknown";
+const adapter = process.env["OMO_MEMORY_ADAPTER"] ?? "unknown";
+
+const input = readStdin();
+const payload = parseJson(input);
+const prompt = extractPrompt(payload);
+
+if (prompt === null) process.exit(0);
+
+const summary = truncate(prompt.replace(/\s+/g, " ").trim(), MAX_SUMMARY_CHARS);
+if (summary.length === 0) process.exit(0);
+
+const hookSessionId = readString(payload, "sessionId") ?? readString(payload, "session_id");
+const workspaceRoot = readString(payload, "workspaceRoot") ?? readString(payload, "cwd");
+const metadata = {
+  source: "hook",
+  hookEventName: readString(payload, "hookEventName") ?? process.env["GROK_HOOK_EVENT"] ?? process.env["CODEX_HOOK_EVENT"] ?? "UserPromptSubmit",
+  host,
+  adapter,
+  ...(hookSessionId === null ? {} : { hookSessionId }),
+  ...(workspaceRoot === null ? {} : { workspaceRoot }),
+};
+
+const args = ["event", "record", "--type", "user_prompt", "--summary", summary, "--payload-json", JSON.stringify(metadata)];
+
+const result = runOmoMemory(args) ?? runNpx(args);
+if (result === undefined || result.status !== 0) process.exit(0);
+
+function readStdin() {
+  try {
+    return readFileSync(0, "utf8");
+  } catch (error) {
+    if (error instanceof Error) process.exit(0);
+    throw error;
+  }
+}
+
+function parseJson(raw) {
+  if (raw.trim().length === 0) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return isRecord(parsed) ? parsed : {};
+  } catch (error) {
+    if (error instanceof SyntaxError) return {};
+    throw error;
+  }
+}
+
+function extractPrompt(value) {
+  if (!isRecord(value)) return null;
+  for (const key of ["prompt", "userPrompt", "user_prompt", "message", "text", "input"]) {
+    const direct = readString(value, key);
+    if (direct !== null) return direct;
+  }
+  const nestedPrompt =
+    readNestedString(value, ["toolInput", "prompt"]) ?? readNestedString(value, ["payload", "prompt"]) ?? readNestedString(value, ["data", "prompt"]);
+  if (nestedPrompt !== null) return nestedPrompt;
+  return null;
+}
+
+function readNestedString(value, path) {
+  let cursor = value;
+  for (const key of path) {
+    if (!isRecord(cursor)) return null;
+    cursor = cursor[key];
+  }
+  return typeof cursor === "string" ? cursor : null;
+}
+
+function readString(value, key) {
+  const item = value[key];
+  return typeof item === "string" ? item : null;
+}
+
+function truncate(value, maxLength) {
+  if (value.length <= maxLength) return value;
+  return `${value.slice(0, maxLength - 15)} [TRUNCATED]`;
+}
+
+function runOmoMemory(args) {
+  const command = process.env["OMO_MEMORY_CLI"] ?? "omo-memory";
+  return run(command, args);
+}
+
+function runNpx(args) {
+  return run("npx", ["-y", "omo-memory", ...args]);
+}
+
+function run(command, args) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 5000,
+  });
+  if (result.error?.code === "ENOENT") return undefined;
+  return result;
+}
+
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}