omo-memory 0.1.0 → 0.1.1

package/README.md

@@ -32,6 +32,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 session bootstrap --host codex --adapter lazycodex --limit 5
 npx -y omo-memory recent --limit 5
 npx -y omo-memory mcp
 ```
@@ -63,6 +64,36 @@ grok mcp add omo-memory -- npx -y omo-memory mcp
 
 Both hosts use `~/.omo/memory/state.sqlite` by default. The `host` value is recorded when an adapter calls `memory_start_session`, not by installing separate servers.
 
+## Session bootstrap
+
+Adapters should call the bootstrap tool at the beginning of each host session:
+
+```json
+{
+  "tool": "memory_bootstrap_session",
+  "arguments": {
+    "host": "codex",
+    "adapter": "lazycodex",
+    "limit": 5
+  }
+}
+```
+
+The response contains a new `sessionId` plus `recentEvents` for the current project. Reuse that `sessionId` when recording follow-up events:
+
+```json
+{
+  "tool": "memory_record_event",
+  "arguments": {
+    "type": "decision",
+    "summary": "Chose the npm MCP package as the shared local memory surface.",
+    "sessionId": "<sessionId>"
+  }
+}
+```
+
+This is local routing, not transcript scraping. OMO Memory does not automatically read full Codex or Grok transcripts; the host or adapter must call these MCP tools.
+
 ## MCP tools
 
 Initial stdio MCP tools:
@@ -70,6 +101,7 @@ Initial stdio MCP tools:
 - `memory_init`
 - `memory_project_context`
 - `memory_start_session`
+- `memory_bootstrap_session`
 - `memory_record_event`
 - `memory_recent_events`
 - `memory_write_handoff`

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { readFileSync } from "node:fs";
-import { doctorReport, exportMemory, initMemory, purgeMemory, recentEvents, recordEvent, startSession, writeHandoff } from "./memory.js";
+import { bootstrapSession, doctorReport, exportMemory, initMemory, purgeMemory, recentEvents, recordEvent, startSession, writeHandoff } from "./memory.js";
 import { runMcpServer } from "./mcp.js";
 async function main(argv) {
     const [command, subcommand, ...rest] = argv;
@@ -34,6 +34,11 @@ function runCommand(command, subcommand, rest) {
         const adapter = readFlag(rest, "--adapter") ?? "unknown";
         return { ok: true, ...startSession({ host, adapter }) };
     }
+    if (command === "session" && subcommand === "bootstrap") {
+        const host = parseHost(readFlag(rest, "--host") ?? "unknown");
+        const adapter = readFlag(rest, "--adapter") ?? "unknown";
+        return { ok: true, ...bootstrapSession({ host, adapter, limit: readPositiveIntFlag(rest, "--limit", 5) }) };
+    }
     if (command === "event" && subcommand === "record") {
         const type = readFlag(rest, "--type") ?? fail("event record requires --type");
         const summary = readFlag(rest, "--summary") ?? fail("event record requires --summary");
@@ -43,10 +48,7 @@ function runCommand(command, subcommand, rest) {
     }
     if (command === "recent") {
         const limitRaw = readFlag([subcommand, ...rest].filter((value) => value !== undefined), "--limit");
-        const limit = limitRaw === undefined ? 10 : Number(limitRaw);
-        if (!Number.isInteger(limit) || limit <= 0)
-            fail("recent --limit must be a positive integer");
-        return { ok: true, events: recentEvents(limit) };
+        return { ok: true, events: recentEvents(parsePositiveInt(limitRaw, "recent --limit")) };
     }
     if (command === "handoff" && subcommand === "write") {
         const summary = readFlag(rest, "--summary");
@@ -71,11 +73,20 @@ function parseHost(value) {
         return value;
     fail("--host must be one of codex, opencode, grok, unknown");
 }
+function readPositiveIntFlag(args, name, defaultValue) {
+    return parsePositiveInt(readFlag(args, name) ?? String(defaultValue), name);
+}
+function parsePositiveInt(value, label) {
+    const limit = value === undefined ? 10 : Number(value);
+    if (!Number.isInteger(limit) || limit <= 0)
+        fail(`${label} must be a positive integer`);
+    return limit;
+}
 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 session start --host <codex|opencode|grok|unknown> --adapter <name>\n  omo-memory event record --type <type> --summary <text> [--session-id <id>]\n  omo-memory recent [--limit <n>]\n  omo-memory handoff write (--summary <text> | --summary-file <path>) [--session-id <id>]\n  omo-memory mcp\n`);
+    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 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 handoff write (--summary <text> | --summary-file <path>) [--session-id <id>]\n  omo-memory mcp\n`);
 }
 main(process.argv.slice(2)).catch((error) => {
     const message = error instanceof Error ? error.message : String(error);

package/dist/mcp.js

@@ -1,9 +1,9 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { exportMemory, initMemory, memoryPaths, purgeMemory, PurgeConfirmationError, recentEvents, recordEvent, resolveProjectContext, startSession, writeHandoff } from "./memory.js";
+import { bootstrapSession, exportMemory, initMemory, memoryPaths, purgeMemory, PurgeConfirmationError, recentEvents, recordEvent, resolveProjectContext, startSession, writeHandoff } from "./memory.js";
 export async function runMcpServer() {
-    const server = new McpServer({ name: "omo-memory", version: "0.1.0" });
+    const server = new McpServer({ name: "omo-memory", version: "0.1.1" });
     server.registerTool("memory_init", {
         title: "Initialize OMO Memory",
         description: "Create or migrate the local OMO memory SQLite database.",
@@ -44,6 +44,15 @@ export async function runMcpServer() {
             adapter: z.string().min(1),
         },
     }, 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.",
+        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_record_event", {
         title: "Record OMO Memory Event",
         description: "Append a summarized event to the current project's OMO memory ledger.",

package/dist/memory.js

@@ -145,6 +145,10 @@ export function startSession(input, dbPath = defaultDbPath()) {
         db.close();
     }
 }
+export function bootstrapSession(input, dbPath = defaultDbPath()) {
+    const session = startSession({ host: input.host, adapter: input.adapter }, dbPath);
+    return { ...session, recentEvents: recentEvents(input.limit, dbPath) };
+}
 export function recordEvent(input, dbPath = defaultDbPath()) {
     const db = openMemoryDb(dbPath);
     try {

package/docs/adapter-integration.md

@@ -27,6 +27,7 @@ After npm publish, adapters and users can invoke the packaged CLI directly:
 
 ```sh
 npx -y omo-memory init
+npx -y omo-memory session bootstrap --host codex --adapter lazycodex --limit 5
 npx -y omo-memory session start --host codex --adapter lazycodex
 npx -y omo-memory session start --host grok --adapter lfg
 npx -y omo-memory recent --limit 10
@@ -81,10 +82,47 @@ grok mcp add omo-memory -- npx -y omo-memory mcp
 
 Register the same MCP server in every host that needs memory access. Do not create separate Codex/Grok schemas or databases; host identity belongs in `memory_start_session` metadata.
 
+## Session Bootstrap Flow
+
+At the beginning of a Codex, OpenCode, or Grok adapter session, call `memory_bootstrap_session` instead of separately calling `memory_start_session` and `memory_recent_events`.
+
+```json
+{
+  "tool": "memory_bootstrap_session",
+  "arguments": {
+    "host": "grok",
+    "adapter": "lfg",
+    "limit": 5
+  }
+}
+```
+
+The tool returns:
+
+- `sessionId`: the new session row for subsequent event/handoff writes.
+- `project`: the current git/project namespace.
+- `recentEvents`: recent events from the same project namespace.
+
+During the session, write concise task state and evidence with the returned `sessionId`:
+
+```json
+{
+  "tool": "memory_record_event",
+  "arguments": {
+    "type": "qa_evidence",
+    "summary": "npm-published MCP exposed memory_bootstrap_session and memory_recent_events.",
+    "sessionId": "<sessionId>"
+  }
+}
+```
+
+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.
+
 Use these tools:
 
 - `memory_init`
 - `memory_project_context`
+- `memory_bootstrap_session`
 - `memory_start_session`
 - `memory_record_event`
 - `memory_recent_events`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omo-memory",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Host-neutral local SQLite memory and session ledger for OMO adapters, exposed through CLI and MCP.",
   "type": "module",
   "files": [
@@ -27,6 +27,7 @@
     "typecheck": "tsc --noEmit",
     "start": "node dist/cli.js",
     "prepack": "npm run build",
+    "presmoke": "npm run build",
     "smoke": "npm run smoke:cli && npm run smoke:mcp",
     "smoke:cli": "node scripts/smoke-cli.mjs",
     "smoke:mcp": "node scripts/smoke-mcp.mjs",