omo-memory 0.1.7 → 0.1.9

package/README.md

@@ -11,6 +11,7 @@ It gives lazycodex, omo-on-opencode, lfg, and future OMO adapters a shared local
 
 - Project-local DB: `<project-root>/.omo/memory/state.sqlite`
 - Project namespacing: by git remote + project root hash
+- Move handling: if a project directory moves with its `.omo` ledger, existing rows are migrated to the new root automatically.
 - Privacy default: local-only, no network sync, no secrets by design
 - Intended adapters: Codex/lazycodex, OpenCode/OMO, GrokBuild/lfg
 

package/dist/cli.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { readFileSync } from "node:fs";
 import { installHooks } from "./hooks.js";
-import { bootstrapSession, doctorReport, exportMemory, initMemory, purgeMemory, recentEvents, recordEvent, startSession, writeHandoff } from "./memory.js";
 import { runMcpServer } from "./mcp.js";
+import { bootstrapSession, doctorReport, exportMemory, purgeMemory, recentEvents, recordEvent, startSession, writeHandoff } from "./memory.js";
+import { initMemory } from "./memoryDb.js";
 async function main(argv) {
     const [command, subcommand, ...rest] = argv;
     if (command === undefined || command === "help" || command === "--help" || command === "-h") {
@@ -48,7 +49,10 @@ function runCommand(command, subcommand, rest) {
         const summary = readFlag(rest, "--summary") ?? fail("event record requires --summary");
         const payloadJson = readFlag(rest, "--payload-json");
         const sessionId = readFlag(rest, "--session-id");
-        return { ok: true, ...recordEvent({ type, summary, ...(payloadJson === undefined ? {} : { payloadJson }), ...(sessionId === undefined ? {} : { sessionId }) }) };
+        return {
+            ok: true,
+            ...recordEvent({ type, summary, ...(payloadJson === undefined ? {} : { payloadJson }), ...(sessionId === undefined ? {} : { sessionId }) }),
+        };
     }
     if (command === "recent") {
         const limitRaw = readFlag([subcommand, ...rest].filter((value) => value !== undefined), "--limit");

package/dist/hookTemplates.js

@@ -2,64 +2,46 @@ export const CODEX_MARKETPLACE = "islee23520";
 export const CODEX_PLUGIN = "omo-memory";
 export const CODEX_SKILL = `---
 name: omo-memory
-description: Use OMO Memory as the shared local memory ledger across Codex, Grok, and OpenCode. Trigger when starting non-trivial workspace work, needing prior session context, recording decisions, QA evidence, task state, handoffs, or using the omo-memory MCP tools.
+description: Use OMO Memory for concise local project memory: bootstrap recent events, record decisions, QA evidence, blockers, and handoffs without secrets.
 ---
 
 # OMO Memory
 
-Use the \`omo-memory\` MCP server as the shared local memory ledger across Codex, Grok, and OpenCode.
-
-## Session Start
-
-At the beginning of non-trivial workspace work, call \`memory_bootstrap_session\` with:
+For non-trivial workspace work, call \`memory_bootstrap_session\` before edits:
 
 - \`host\`: \`codex\`
 - \`adapter\`: \`lazycodex\`
-- \`limit\`: \`5\`
-
-Read \`recentEvents\` before changing files. Keep the returned \`sessionId\` for the turn/session.
-
-## During Work
-
-Record durable, concise facts with \`memory_record_event\` and the active \`sessionId\`: decisions, QA evidence, task state, blockers, and handoff-worthy facts.
+- \`limit\`: \`2\`
 
-Use \`memory_write_handoff\` for explicit handoff summaries.
+Read \`recentEvents\`, keep the returned \`sessionId\`, and record only durable summaries with \`memory_record_event\`: decisions, QA evidence, task state, blockers, and handoffs.
 
-## Privacy
-
-Never store full transcripts, API keys, tokens, \`.env\` contents, auth files, cookies, bearer headers, or raw secret-bearing logs. Store summaries and evidence references only.
+Use \`memory_write_handoff\` only for explicit handoff summaries. Never store transcripts, secrets, \`.env\`, auth files, cookies, bearer headers, or raw secret-bearing logs.
 `;
 export const GROK_SKILL = CODEX_SKILL.replace("Codex, Grok", "Grok, Codex")
     .replace("- `host`: `codex`", "- `host`: `grok`")
     .replace("- `adapter`: `lazycodex`", "- `adapter`: `lfg`");
 export const CODEX_AGENTS_BLOCK = `### OMO Memory lifecycle
 
-When the \`omo-memory\` MCP server is available, use it as the shared local memory ledger for Codex/Grok/OpenCode work.
-
-At the beginning of a non-trivial workspace session, call \`memory_bootstrap_session\` with:
+When the \`omo-memory\` MCP server is available, use it for concise local project memory. For non-trivial workspace work, call \`memory_bootstrap_session\` before edits:
 
 - \`host\`: \`codex\`
 - \`adapter\`: \`lazycodex\`
-- \`limit\`: \`5\`
-
-Read the returned \`recentEvents\` before making changes. Keep the returned \`sessionId\` for this session.
+- \`limit\`: \`2\`
 
-During work, record concise durable state with \`memory_record_event\` using that \`sessionId\`: decisions, task state, QA evidence, important blockers, and handoff-worthy facts. Use \`memory_write_handoff\` only for explicit handoff summaries. Do not store full transcripts, API keys, tokens, \`.env\` contents, auth files, cookies, bearer headers, or raw secret-bearing logs.`;
+Read \`recentEvents\`, keep the returned \`sessionId\`, and record only durable summaries with \`memory_record_event\`: decisions, task state, QA evidence, blockers, and handoffs. Never store transcripts, secrets, \`.env\`, auth files, cookies, bearer headers, or raw secret-bearing logs.`;
 export const GROK_AGENTS_BLOCK = CODEX_AGENTS_BLOCK.replace("- `host`: `codex`", "- `host`: `grok`").replace("- `adapter`: `lazycodex`", "- `adapter`: `lfg`");
 export const SESSION_BOOTSTRAP_SCRIPT = `#!/usr/bin/env node
 import { spawnSync } from "node:child_process";
 
 const host = process.env["OMO_MEMORY_HOST"] ?? "codex";
 const adapter = process.env["OMO_MEMORY_ADAPTER"] ?? "lazycodex";
-const limit = process.env["OMO_MEMORY_LIMIT"] ?? "5";
+const limit = process.env["OMO_MEMORY_LIMIT"] ?? "2";
+const args = ["session", "bootstrap", "--host", host, "--adapter", adapter, "--limit", limit];
 
-const result = spawnSync("npx", ["-y", "omo-memory", "session", "bootstrap", "--host", host, "--adapter", adapter, "--limit", limit], {
-  encoding: "utf8",
-  stdio: ["ignore", "pipe", "pipe"],
-  timeout: 5000
-});
+const direct = process.env["OMO_MEMORY_CLI"] ?? "omo-memory";
+const result = runBootstrap(direct, args) ?? runBootstrap("npx", ["-y", "omo-memory", ...args]);
 
-if (result.status !== 0) {
+if (result === undefined || result.status !== 0) {
   process.stdout.write("OMO Memory: bootstrap unavailable; continue without blocking the session.\\n");
   process.exit(0);
 }
@@ -69,7 +51,6 @@ try {
   const recentEvents = Array.isArray(payload.recentEvents) ? payload.recentEvents : [];
   process.stdout.write(\`OMO Memory sessionId: \${payload.sessionId}\\n\`);
   if (recentEvents.length === 0) {
-    process.stdout.write("OMO Memory recentEvents: none for this project.\\n");
     process.exit(0);
   }
   process.stdout.write("OMO Memory recentEvents:\\n");
@@ -80,11 +61,21 @@ try {
   const detail = error instanceof Error ? error.message : String(error);
   process.stdout.write(\`OMO Memory: bootstrap returned unreadable output; \${detail}\\n\`);
 }
+
+function runBootstrap(command, commandArgs) {
+  const result = spawnSync(command, commandArgs, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 2000
+  });
+  if (result.error && result.error.code === "ENOENT") return undefined;
+  return result;
+}
 `;
 export const GROK_HOOK_SCRIPT = SESSION_BOOTSTRAP_SCRIPT.replace('?? "codex"', '?? "grok"').replace('?? "lazycodex"', '?? "lfg"');
 export const GROK_PLUGIN_JSON = `{
   "name": "omo-memory",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Project-local OMO Memory bootstrap hook and MCP server for Grok.",
   "author": {
     "name": "islee23520"
@@ -109,7 +100,7 @@ export const GROK_MCP_JSON = `{
 `;
 export const CODEX_PLUGIN_JSON = `{
   "name": "omo-memory",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Session-start OMO Memory bootstrap hook for Codex.",
   "author": "islee23520",
   "homepage": "https://github.com/islee23520/omo-memory",
@@ -146,7 +137,7 @@ export const CODEX_HOOKS_JSON = `{
           {
             "type": "command",
             "command": "node \\"\${PLUGIN_ROOT}/scripts/omo-memory-session.mjs\\"",
-            "timeout": 5,
+            "timeout": 2,
             "description": "omo-memory session bootstrap",
             "statusMessage": "OMO Memory: loading recent session memory"
           }
@@ -164,7 +155,7 @@ export const GROK_HOOKS_JSON = `{
           {
             "type": "command",
             "command": "node \\"{{HOME}}/.grok/hooks/omo-memory-session.mjs\\"",
-            "timeout": 5,
+            "timeout": 2,
             "description": "omo-memory session bootstrap",
             "statusMessage": "OMO Memory: loading recent session memory"
           }

package/dist/mcp.js

@@ -1,7 +1,9 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { bootstrapSession, exportMemory, initMemory, memoryPaths, purgeMemory, PurgeConfirmationError, recentEvents, recordEvent, resolveProjectContext, startSession, writeHandoff } from "./memory.js";
+import { bootstrapSession, exportMemory, memoryPaths, PurgeConfirmationError, purgeMemory, recentEvents, recordEvent, startSession, writeHandoff, } from "./memory.js";
+import { initMemory } from "./memoryDb.js";
+import { resolveProjectContext } from "./projectContext.js";
 export async function runMcpServer() {
     const server = new McpServer({ name: "omo-memory", version: "0.1.2" });
     server.registerTool("memory_init", {

package/dist/memory.js

@@ -1,94 +1,22 @@
-import Database from "better-sqlite3";
-import { createHash, randomUUID } from "node:crypto";
-import { mkdirSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { execFileSync } from "node:child_process";
-import { redactSecrets, sanitizeGitRemote } from "./privacy.js";
+import { randomUUID } from "node:crypto";
+import { migrate, openMemoryDb, SCHEMA_VERSION } from "./memoryDb.js";
+import { redactSecrets } from "./privacy.js";
+import { defaultDbPath, resolveProjectContext } from "./projectContext.js";
+import { resolveStoredProject } from "./projectMigration.js";
 export class PurgeConfirmationError extends Error {
     constructor() {
         super("purge requires --yes");
         this.name = "PurgeConfirmationError";
     }
 }
-const SCHEMA_VERSION = 1;
-export function defaultDbPath() {
-    return process.env["OMO_MEMORY_DB"] ?? join(resolveProjectContext().repoRoot, ".omo", "memory", "state.sqlite");
-}
 export function memoryPaths() {
     return { dbPath: defaultDbPath() };
 }
-export function openMemoryDb(dbPath = defaultDbPath()) {
-    mkdirSync(dirname(dbPath), { recursive: true });
-    const db = new Database(dbPath);
-    db.pragma("journal_mode = WAL");
-    return db;
-}
-export function migrate(db) {
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS schema_meta (
-      key TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS projects (
-      id TEXT PRIMARY KEY,
-      repo_root TEXT NOT NULL,
-      git_remote TEXT,
-      created_at TEXT NOT NULL,
-      last_seen_at TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS sessions (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      host TEXT NOT NULL,
-      adapter TEXT NOT NULL,
-      started_at TEXT NOT NULL,
-      ended_at TEXT,
-      git_branch TEXT,
-      git_head TEXT,
-      FOREIGN KEY(project_id) REFERENCES projects(id)
-    );
-
-    CREATE TABLE IF NOT EXISTS events (
-      id TEXT PRIMARY KEY,
-      session_id TEXT,
-      project_id TEXT NOT NULL,
-      type TEXT NOT NULL,
-      summary TEXT NOT NULL,
-      payload_json TEXT,
-      created_at TEXT NOT NULL,
-      FOREIGN KEY(project_id) REFERENCES projects(id),
-      FOREIGN KEY(session_id) REFERENCES sessions(id)
-    );
-
-    CREATE TABLE IF NOT EXISTS handoffs (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      session_id TEXT,
-      summary_md TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      FOREIGN KEY(project_id) REFERENCES projects(id),
-      FOREIGN KEY(session_id) REFERENCES sessions(id)
-    );
-  `);
-    db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', ?)").run(String(SCHEMA_VERSION));
-}
-export function initMemory(dbPath = defaultDbPath()) {
-    const db = openMemoryDb(dbPath);
-    try {
-        migrate(db);
-        return { dbPath, schemaVersion: SCHEMA_VERSION };
-    }
-    finally {
-        db.close();
-    }
-}
 export function doctorReport(dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
     try {
         migrate(db);
-        const project = resolveProjectContext();
+        const project = resolveStoredProject(db, resolveProjectContext());
         const schemaVersion = Number(db.prepare("SELECT value FROM schema_meta WHERE key = 'schema_version'").pluck().get());
         const count = (table) => Number(db.prepare(`SELECT COUNT(*) FROM ${table}`).pluck().get());
         return {
@@ -107,15 +35,6 @@ export function doctorReport(dbPath = defaultDbPath()) {
         db.close();
     }
 }
-export function resolveProjectContext(cwd = process.cwd()) {
-    const repoRoot = gitValue(["rev-parse", "--show-toplevel"], cwd) ?? resolve(cwd);
-    const rawGitRemote = gitValue(["config", "--get", "remote.origin.url"], repoRoot);
-    const gitRemote = sanitizeGitRemote(rawGitRemote);
-    const gitBranch = gitValue(["rev-parse", "--abbrev-ref", "HEAD"], repoRoot);
-    const gitHead = gitValue(["rev-parse", "HEAD"], repoRoot);
-    const id = createHash("sha256").update(`${rawGitRemote ?? ""}\n${repoRoot}`).digest("hex").slice(0, 24);
-    return { id, repoRoot, gitRemote, gitBranch, gitHead };
-}
 export function upsertProject(db, project) {
     const now = new Date().toISOString();
     db.prepare(`
@@ -131,7 +50,7 @@ export function startSession(input, dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
     try {
         migrate(db);
-        const project = resolveProjectContext();
+        const project = resolveStoredProject(db, resolveProjectContext());
         upsertProject(db, project);
         const sessionId = randomUUID();
         db.prepare(`
@@ -152,7 +71,7 @@ export function recordEvent(input, dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
     try {
         migrate(db);
-        const project = resolveProjectContext();
+        const project = resolveStoredProject(db, resolveProjectContext());
         upsertProject(db, project);
         const eventId = randomUUID();
         db.prepare(`
@@ -169,14 +88,16 @@ export function recentEvents(limit, dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
     try {
         migrate(db);
-        const project = resolveProjectContext();
-        return db.prepare(`
+        const project = resolveStoredProject(db, resolveProjectContext());
+        return db
+            .prepare(`
       SELECT id, type, summary, created_at AS createdAt, session_id AS sessionId
       FROM events
       WHERE project_id = ?
       ORDER BY created_at DESC
       LIMIT ?
-    `).all(project.id, limit);
+    `)
+            .all(project.id, limit);
     }
     finally {
         db.close();
@@ -186,7 +107,7 @@ export function writeHandoff(summaryMd, sessionId, dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
     try {
         migrate(db);
-        const project = resolveProjectContext();
+        const project = resolveStoredProject(db, resolveProjectContext());
         upsertProject(db, project);
         const handoffId = randomUUID();
         db.prepare(`
@@ -203,19 +124,25 @@ export function exportMemory(dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
     try {
         migrate(db);
-        const project = resolveProjectContext();
-        const sessions = db.prepare(`
+        const project = resolveStoredProject(db, resolveProjectContext());
+        const sessions = db
+            .prepare(`
       SELECT id, host, adapter, started_at AS startedAt, ended_at AS endedAt, git_branch AS gitBranch, git_head AS gitHead FROM sessions
       WHERE project_id = ? ORDER BY started_at ASC, id ASC
-    `).all(project.id);
-        const events = db.prepare(`
+    `)
+            .all(project.id);
+        const events = db
+            .prepare(`
       SELECT id, session_id AS sessionId, type, summary, payload_json AS payloadJson, created_at AS createdAt FROM events
       WHERE project_id = ? ORDER BY created_at ASC, id ASC
-    `).all(project.id);
-        const handoffs = db.prepare(`
+    `)
+            .all(project.id);
+        const handoffs = db
+            .prepare(`
       SELECT id, session_id AS sessionId, summary_md AS summaryMd, created_at AS createdAt FROM handoffs
       WHERE project_id = ? ORDER BY created_at ASC, id ASC
-    `).all(project.id);
+    `)
+            .all(project.id);
         return {
             schemaVersion: SCHEMA_VERSION,
             exportedAt: new Date().toISOString(),
@@ -236,11 +163,17 @@ export function purgeMemory(input, dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
     try {
         migrate(db);
-        const project = resolveProjectContext();
+        const project = resolveStoredProject(db, resolveProjectContext());
         const deleteProject = db.transaction(() => {
-            const events = db.prepare("DELETE FROM events WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)").run(project.id, project.repoRoot).changes;
-            const handoffs = db.prepare("DELETE FROM handoffs WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)").run(project.id, project.repoRoot).changes;
-            const sessions = db.prepare("DELETE FROM sessions WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)").run(project.id, project.repoRoot).changes;
+            const events = db
+                .prepare("DELETE FROM events WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)")
+                .run(project.id, project.repoRoot).changes;
+            const handoffs = db
+                .prepare("DELETE FROM handoffs WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)")
+                .run(project.id, project.repoRoot).changes;
+            const sessions = db
+                .prepare("DELETE FROM sessions WHERE project_id IN (SELECT id FROM projects WHERE id = ? OR repo_root = ?)")
+                .run(project.id, project.repoRoot).changes;
             const projects = db.prepare("DELETE FROM projects WHERE id = ? OR repo_root = ?").run(project.id, project.repoRoot).changes;
             return { events, handoffs, sessions, projects };
         });
@@ -250,11 +183,3 @@ export function purgeMemory(input, dbPath = defaultDbPath()) {
         db.close();
     }
 }
-function gitValue(args, cwd) {
-    try {
-        return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
-    }
-    catch {
-        return null;
-    }
-}

package/dist/memoryDb.js

@@ -0,0 +1,72 @@
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import Database from "better-sqlite3";
+import { defaultDbPath } from "./projectContext.js";
+export const SCHEMA_VERSION = 1;
+export function openMemoryDb(dbPath = defaultDbPath()) {
+    mkdirSync(dirname(dbPath), { recursive: true });
+    const db = new Database(dbPath);
+    db.pragma("journal_mode = WAL");
+    return db;
+}
+export function migrate(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      repo_root TEXT NOT NULL,
+      git_remote TEXT,
+      created_at TEXT NOT NULL,
+      last_seen_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      host TEXT NOT NULL,
+      adapter TEXT NOT NULL,
+      started_at TEXT NOT NULL,
+      ended_at TEXT,
+      git_branch TEXT,
+      git_head TEXT,
+      FOREIGN KEY(project_id) REFERENCES projects(id)
+    );
+
+    CREATE TABLE IF NOT EXISTS events (
+      id TEXT PRIMARY KEY,
+      session_id TEXT,
+      project_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      payload_json TEXT,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY(project_id) REFERENCES projects(id),
+      FOREIGN KEY(session_id) REFERENCES sessions(id)
+    );
+
+    CREATE TABLE IF NOT EXISTS handoffs (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      session_id TEXT,
+      summary_md TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY(project_id) REFERENCES projects(id),
+      FOREIGN KEY(session_id) REFERENCES sessions(id)
+    );
+  `);
+    db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schema_version', ?)").run(String(SCHEMA_VERSION));
+}
+export function initMemory(dbPath = defaultDbPath()) {
+    const db = openMemoryDb(dbPath);
+    try {
+        migrate(db);
+        return { dbPath, schemaVersion: SCHEMA_VERSION };
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/projectContext.js

@@ -0,0 +1,27 @@
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { join, resolve } from "node:path";
+import { sanitizeGitRemote } from "./privacy.js";
+export function defaultDbPath() {
+    return process.env["OMO_MEMORY_DB"] ?? join(resolveProjectContext().repoRoot, ".omo", "memory", "state.sqlite");
+}
+export function resolveProjectContext(cwd = process.cwd()) {
+    const repoRoot = gitValue(["rev-parse", "--show-toplevel"], cwd) ?? resolve(cwd);
+    const rawGitRemote = gitValue(["config", "--get", "remote.origin.url"], repoRoot);
+    const gitRemote = sanitizeGitRemote(rawGitRemote);
+    const gitBranch = gitValue(["rev-parse", "--abbrev-ref", "HEAD"], repoRoot);
+    const gitHead = gitValue(["rev-parse", "HEAD"], repoRoot);
+    const id = createHash("sha256")
+        .update(`${rawGitRemote ?? ""}\n${repoRoot}`)
+        .digest("hex")
+        .slice(0, 24);
+    return { id, repoRoot, gitRemote, gitBranch, gitHead };
+}
+function gitValue(args, cwd) {
+    try {
+        return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/projectMigration.js

@@ -0,0 +1,40 @@
+export function resolveStoredProject(db, project) {
+    const current = readProjectById(db, project.id);
+    if (current !== undefined) {
+        updateProjectMetadata(db, project);
+        return project;
+    }
+    const candidate = findMovedProjectCandidate(db, project);
+    if (candidate === undefined || candidate.id === project.id)
+        return project;
+    updateProjectMetadata(db, { ...project, id: candidate.id });
+    return { ...project, id: candidate.id };
+}
+function findMovedProjectCandidate(db, project) {
+    const byRoot = readProjectByRepoRoot(db, project.repoRoot);
+    if (byRoot !== undefined)
+        return byRoot;
+    if (project.gitRemote !== null) {
+        const byRemote = readProjectByGitRemote(db, project.gitRemote);
+        if (byRemote !== undefined)
+            return byRemote;
+    }
+    const allProjects = db
+        .prepare("SELECT id, repo_root, git_remote, created_at FROM projects ORDER BY last_seen_at DESC, created_at DESC")
+        .all();
+    return allProjects.length === 1 ? allProjects[0] : undefined;
+}
+function readProjectById(db, id) {
+    return db.prepare("SELECT id, repo_root, git_remote, created_at FROM projects WHERE id = ?").get(id);
+}
+function readProjectByRepoRoot(db, repoRoot) {
+    return db.prepare("SELECT id, repo_root, git_remote, created_at FROM projects WHERE repo_root = ?").get(repoRoot);
+}
+function readProjectByGitRemote(db, gitRemote) {
+    return db
+        .prepare("SELECT id, repo_root, git_remote, created_at FROM projects WHERE git_remote = ? ORDER BY last_seen_at DESC, created_at DESC")
+        .get(gitRemote);
+}
+function updateProjectMetadata(db, project) {
+    db.prepare("UPDATE projects SET repo_root = ?, git_remote = ?, last_seen_at = ? WHERE id = ?").run(project.repoRoot, project.gitRemote, new Date().toISOString(), project.id);
+}

package/docs/adapter-integration.md

@@ -11,6 +11,7 @@ No full transcript capture by default. Do not store API keys, tokens, `.env` con
 - Record concise events with a stable `type`, a human-readable `summary`, and optional redacted JSON metadata in `payloadJson`.
 - Store handoffs as summary markdown that another host can read without needing the originating transcript.
 - Treat CLI and MCP as two entrypoints to the same core functions and schema.
+- When a project directory moves with its `.omo` ledger, OMO Memory migrates matching project rows to the new root automatically.
 - Use `OMO_MEMORY_DB` only when the caller explicitly chooses a different database path, such as an isolated smoke test.
 
 ## Adapter Metadata

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omo-memory",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Host-neutral local SQLite memory and session ledger for OMO adapters, exposed through CLI and MCP.",
   "type": "module",
   "files": [
@@ -25,6 +25,9 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "format": "biome format --write .",
+    "check": "npm run lint && npm run typecheck && npm run smoke",
     "start": "node dist/cli.js",
     "prepack": "npm run build",
     "presmoke": "npm run build",
@@ -40,6 +43,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.5.1",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^24.10.1",
     "typescript": "^6.0.3"