@launchapp-dev/ao-memory-mcp 1.0.0 → 2.0.1

package/dist/tools/summarize.js

@@ -0,0 +1,92 @@
+import { now, jsonResult, errorResult } from "../db.js";
+export const summarizeTools = [
+    {
+        name: "memory.summarize",
+        description: "Create a summary of memory entries. Agent provides the summary text. Server creates the summary record and transitions entries to 'summarized'.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                namespace: { type: "string", description: "Namespace to summarize" },
+                agent_role: { type: "string", description: "Agent role" },
+                summary_title: { type: "string", description: "Summary title" },
+                summary_body: { type: "string", description: "Summary content (markdown)" },
+                before: { type: "string", description: "Summarize entries before this ISO date" },
+                entry_ids: { type: "array", items: { type: "number" }, description: "Specific IDs to summarize" },
+            },
+            required: ["namespace", "summary_title", "summary_body"],
+        },
+    },
+    {
+        name: "memory.cleanup",
+        description: "Identify stale entries needing summarization or archive old summarized entries.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                older_than_days: { type: "number", description: "Entries older than N days (default 7)" },
+                min_entries: { type: "number", description: "Min entries per scope to trigger (default 10)" },
+                dry_run: { type: "boolean", description: "Preview only (default true)" },
+            },
+        },
+    },
+];
+export function handleSummarize(db, name, args) {
+    if (name === "memory.summarize")
+        return memorySummarize(db, args);
+    if (name === "memory.cleanup")
+        return memoryCleanup(db, args);
+    return null;
+}
+function memorySummarize(db, args) {
+    const { namespace, agent_role, summary_title, summary_body } = args;
+    const result = db.transaction(() => {
+        let entryIds;
+        if (args.entry_ids?.length) {
+            entryIds = args.entry_ids;
+        }
+        else {
+            const cutoff = args.before || new Date(Date.now() - 3 * 24 * 60 * 60 * 1000).toISOString();
+            const conditions = ["namespace = ?", "status = 'active'", "occurred_at < ?"];
+            const vals = [namespace, cutoff];
+            if (agent_role) {
+                conditions.push("agent_role = ?");
+                vals.push(agent_role);
+            }
+            const rows = db.prepare(`SELECT id FROM memories WHERE ${conditions.join(" AND ")}`).all(...vals);
+            entryIds = rows.map(r => r.id);
+        }
+        if (entryIds.length === 0)
+            return { error: "No entries to summarize" };
+        const range = db.prepare(`SELECT MIN(occurred_at) as date_from, MAX(occurred_at) as date_to FROM memories WHERE id IN (${entryIds.map(() => "?").join(",")})`).get(...entryIds);
+        const ts = now();
+        const sumResult = db.prepare(`
+      INSERT INTO summaries (scope, namespace, agent_role, title, content, entry_count, date_from, date_to, entry_ids, created_at)
+      VALUES ('project', ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(namespace, agent_role || null, summary_title, summary_body, entryIds.length, range.date_from, range.date_to, JSON.stringify(entryIds), ts);
+        db.prepare(`UPDATE memories SET status = 'summarized', updated_at = ? WHERE id IN (${entryIds.map(() => "?").join(",")})`).run(ts, ...entryIds);
+        return { summary_id: Number(sumResult.lastInsertRowid), entries_summarized: entryIds.length };
+    })();
+    if (result.error)
+        return errorResult(result.error);
+    return jsonResult(result);
+}
+function memoryCleanup(db, args) {
+    const olderThanDays = args.older_than_days ?? 7;
+    const minEntries = args.min_entries ?? 10;
+    const dryRun = args.dry_run ?? true;
+    const cutoff = new Date(Date.now() - olderThanDays * 24 * 60 * 60 * 1000).toISOString();
+    const needsSummarization = db.prepare(`
+    SELECT namespace, agent_role, COUNT(*) as entry_count,
+           MIN(occurred_at) as date_from, MAX(occurred_at) as date_to
+    FROM memories WHERE status = 'active' AND occurred_at < ?
+    GROUP BY namespace, agent_role
+    HAVING COUNT(*) >= ?
+  `).all(cutoff, minEntries);
+    const archivalCutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
+    const needsArchival = db.prepare("SELECT COUNT(*) as c FROM memories WHERE status = 'summarized' AND updated_at < ?").get(archivalCutoff).c;
+    let archived = 0;
+    if (!dryRun && needsArchival > 0) {
+        const ts = now();
+        archived = db.prepare("UPDATE memories SET status = 'archived', updated_at = ? WHERE status = 'summarized' AND updated_at < ?").run(ts, archivalCutoff).changes;
+    }
+    return jsonResult({ needs_summarization: needsSummarization, needs_archival: needsArchival, archived, dry_run: dryRun });
+}

package/package.json

@@ -1,19 +1,25 @@
 {
   "name": "@launchapp-dev/ao-memory-mcp",
-  "version": "1.0.0",
-  "description": "MCP server for agent memory management — structured recall, cross-project patterns, and lifecycle management for ao-cli agents",
+  "version": "2.0.1",
+  "description": "Cognitive memory MCP server for AI agents — semantic search, document RAG, knowledge graph, episodic memory, and hybrid retrieval",
   "type": "module",
   "bin": {
-    "ao-memory-mcp": "./src/server.ts"
+    "ao-memory-mcp": "./dist/server.js"
   },
+  "files": [
+    "dist",
+    "src/schema.sql"
+  ],
   "scripts": {
-    "start": "node --experimental-strip-types src/server.ts",
-    "migrate": "node --experimental-strip-types migrate.ts",
-    "build": "tsc --noEmit -p tsconfig.json"
+    "start": "node dist/server.js",
+    "build": "tsc && cp src/schema.sql dist/schema.sql",
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@huggingface/transformers": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "better-sqlite3": "^11.0.0",
+    "sqlite-vec": "^0.1.0",
     "zod": "^3.22.0"
   },
   "devDependencies": {

package/src/schema.sql

@@ -1,113 +1,194 @@
 PRAGMA journal_mode = WAL;
 PRAGMA foreign_keys = ON;
 
-CREATE TABLE IF NOT EXISTS memory_entries (
+-- ============================================================
+-- MEMORIES — unified store for semantic, episodic, procedural
+-- ============================================================
+CREATE TABLE IF NOT EXISTS memories (
+  id              INTEGER PRIMARY KEY AUTOINCREMENT,
+  memory_type     TEXT    NOT NULL,  -- semantic | episodic | procedural
+  scope           TEXT    NOT NULL DEFAULT 'project',  -- global | user | project | session
+  namespace       TEXT,              -- project name, user id, session id, etc.
+  agent_role      TEXT,              -- planner, reviewer, qa-tester, or any custom role
+  title           TEXT    NOT NULL,
+  content         TEXT    NOT NULL,
+  -- references
+  task_id         TEXT,
+  pr_number       INTEGER,
+  run_id          TEXT,
+  -- lifecycle
+  status          TEXT    NOT NULL DEFAULT 'active',  -- active | summarized | archived
+  confidence      REAL    NOT NULL DEFAULT 1.0,       -- 0.0-1.0, decays over time
+  superseded_by   INTEGER REFERENCES memories(id),
+  -- temporal
+  tags            TEXT    NOT NULL DEFAULT '[]',
+  metadata        TEXT    NOT NULL DEFAULT '{}',
+  created_at      TEXT    NOT NULL,
+  occurred_at     TEXT    NOT NULL,
+  updated_at      TEXT    NOT NULL,
+  last_accessed_at TEXT,
+  access_count    INTEGER NOT NULL DEFAULT 0,
+  content_hash    TEXT    NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_mem_type       ON memories(memory_type);
+CREATE INDEX IF NOT EXISTS idx_mem_scope      ON memories(scope, namespace);
+CREATE INDEX IF NOT EXISTS idx_mem_role       ON memories(agent_role);
+CREATE INDEX IF NOT EXISTS idx_mem_status     ON memories(status);
+CREATE INDEX IF NOT EXISTS idx_mem_task       ON memories(task_id);
+CREATE INDEX IF NOT EXISTS idx_mem_occurred   ON memories(occurred_at);
+CREATE INDEX IF NOT EXISTS idx_mem_hash       ON memories(content_hash);
+CREATE INDEX IF NOT EXISTS idx_mem_ns_type    ON memories(namespace, memory_type);
+CREATE INDEX IF NOT EXISTS idx_mem_ns_role    ON memories(namespace, agent_role);
+CREATE INDEX IF NOT EXISTS idx_mem_confidence ON memories(confidence);
+CREATE INDEX IF NOT EXISTS idx_mem_accessed   ON memories(last_accessed_at);
+
+-- FTS5 for memories
+CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+  title, content,
+  content=memories, content_rowid=id
+);
+CREATE TRIGGER IF NOT EXISTS mem_fts_i AFTER INSERT ON memories BEGIN
+  INSERT INTO memories_fts(rowid, title, content) VALUES (new.id, new.title, new.content);
+END;
+CREATE TRIGGER IF NOT EXISTS mem_fts_u AFTER UPDATE ON memories BEGIN
+  INSERT INTO memories_fts(memories_fts, rowid, title, content) VALUES ('delete', old.id, old.title, old.content);
+  INSERT INTO memories_fts(rowid, title, content) VALUES (new.id, new.title, new.content);
+END;
+CREATE TRIGGER IF NOT EXISTS mem_fts_d AFTER DELETE ON memories BEGIN
+  INSERT INTO memories_fts(memories_fts, rowid, title, content) VALUES ('delete', old.id, old.title, old.content);
+END;
+
+-- ============================================================
+-- DOCUMENTS — source documents ingested for RAG
+-- ============================================================
+CREATE TABLE IF NOT EXISTS documents (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  namespace   TEXT,
+  title       TEXT    NOT NULL,
+  source      TEXT,              -- file path, URL, or identifier
+  mime_type   TEXT    DEFAULT 'text/plain',
+  content     TEXT    NOT NULL,  -- full original content
+  metadata    TEXT    NOT NULL DEFAULT '{}',
+  created_at  TEXT    NOT NULL,
+  updated_at  TEXT    NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_doc_ns ON documents(namespace);
+
+-- CHUNKS — document chunks with embeddings
+CREATE TABLE IF NOT EXISTS chunks (
   id           INTEGER PRIMARY KEY AUTOINCREMENT,
-  entry_type   TEXT    NOT NULL,
-  agent_role   TEXT    NOT NULL,
-  project      TEXT    NOT NULL,
-  title        TEXT    NOT NULL,
-  body         TEXT    NOT NULL,
-  task_id      TEXT,
-  pr_number    INTEGER,
-  run_id       TEXT,
-  status       TEXT    NOT NULL DEFAULT 'active',
-  tags         TEXT    NOT NULL DEFAULT '[]',
+  document_id  INTEGER NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
+  chunk_index  INTEGER NOT NULL,
+  content      TEXT    NOT NULL,
+  char_offset  INTEGER NOT NULL DEFAULT 0,
+  char_length  INTEGER NOT NULL DEFAULT 0,
   metadata     TEXT    NOT NULL DEFAULT '{}',
-  created_at   TEXT    NOT NULL,
-  occurred_at  TEXT    NOT NULL,
-  updated_at   TEXT    NOT NULL,
-  content_hash TEXT    NOT NULL
+  created_at   TEXT    NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_chunk_doc ON chunks(document_id);
+
+-- FTS5 for chunks
+CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+  content,
+  content=chunks, content_rowid=id
 );
+CREATE TRIGGER IF NOT EXISTS chunk_fts_i AFTER INSERT ON chunks BEGIN
+  INSERT INTO chunks_fts(rowid, content) VALUES (new.id, new.content);
+END;
+CREATE TRIGGER IF NOT EXISTS chunk_fts_u AFTER UPDATE ON chunks BEGIN
+  INSERT INTO chunks_fts(chunks_fts, rowid, content) VALUES ('delete', old.id, old.content);
+  INSERT INTO chunks_fts(rowid, content) VALUES (new.id, new.content);
+END;
+CREATE TRIGGER IF NOT EXISTS chunk_fts_d AFTER DELETE ON chunks BEGIN
+  INSERT INTO chunks_fts(chunks_fts, rowid, content) VALUES ('delete', old.id, old.content);
+END;
 
-CREATE TABLE IF NOT EXISTS memory_summaries (
-  id            INTEGER PRIMARY KEY AUTOINCREMENT,
-  agent_role    TEXT    NOT NULL,
-  project       TEXT    NOT NULL,
-  entry_type    TEXT,
-  title         TEXT    NOT NULL,
-  body          TEXT    NOT NULL,
-  entry_count   INTEGER NOT NULL,
-  date_from     TEXT    NOT NULL,
-  date_to       TEXT    NOT NULL,
-  entry_ids     TEXT    NOT NULL,
-  created_at    TEXT    NOT NULL
+-- ============================================================
+-- KNOWLEDGE GRAPH — entities and relations
+-- ============================================================
+CREATE TABLE IF NOT EXISTS entities (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  name        TEXT    NOT NULL,
+  entity_type TEXT    NOT NULL,  -- project, person, technology, concept, file, etc.
+  namespace   TEXT,
+  description TEXT,
+  metadata    TEXT    NOT NULL DEFAULT '{}',
+  created_at  TEXT    NOT NULL,
+  updated_at  TEXT    NOT NULL,
+  UNIQUE(name, entity_type, namespace)
 );
 
-CREATE TABLE IF NOT EXISTS memory_patterns (
+CREATE INDEX IF NOT EXISTS idx_ent_type ON entities(entity_type);
+CREATE INDEX IF NOT EXISTS idx_ent_ns   ON entities(namespace);
+
+CREATE TABLE IF NOT EXISTS relations (
   id               INTEGER PRIMARY KEY AUTOINCREMENT,
-  pattern_type     TEXT    NOT NULL,
-  title            TEXT    NOT NULL,
-  description      TEXT    NOT NULL,
-  projects         TEXT    NOT NULL DEFAULT '[]',
-  agent_roles      TEXT    NOT NULL DEFAULT '[]',
-  entry_ids        TEXT    NOT NULL DEFAULT '[]',
-  occurrence_count INTEGER NOT NULL DEFAULT 1,
-  status           TEXT    NOT NULL DEFAULT 'active',
-  first_seen       TEXT    NOT NULL,
-  last_seen        TEXT    NOT NULL,
-  resolved_at      TEXT,
+  source_entity_id INTEGER NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
+  relation_type    TEXT    NOT NULL,  -- uses, depends_on, created_by, part_of, related_to, etc.
+  target_entity_id INTEGER NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
+  weight           REAL    NOT NULL DEFAULT 1.0,
+  memory_id        INTEGER REFERENCES memories(id),  -- evidence link
+  metadata         TEXT    NOT NULL DEFAULT '{}',
   created_at       TEXT    NOT NULL,
-  updated_at       TEXT    NOT NULL
+  UNIQUE(source_entity_id, relation_type, target_entity_id)
 );
 
--- Indexes for memory_entries
-CREATE INDEX IF NOT EXISTS idx_me_entry_type   ON memory_entries(entry_type);
-CREATE INDEX IF NOT EXISTS idx_me_agent_role   ON memory_entries(agent_role);
-CREATE INDEX IF NOT EXISTS idx_me_project      ON memory_entries(project);
-CREATE INDEX IF NOT EXISTS idx_me_status       ON memory_entries(status);
-CREATE INDEX IF NOT EXISTS idx_me_task_id      ON memory_entries(task_id);
-CREATE INDEX IF NOT EXISTS idx_me_occurred_at  ON memory_entries(occurred_at);
-CREATE INDEX IF NOT EXISTS idx_me_content_hash ON memory_entries(content_hash);
-CREATE INDEX IF NOT EXISTS idx_me_role_project ON memory_entries(agent_role, project);
-CREATE INDEX IF NOT EXISTS idx_me_proj_type    ON memory_entries(project, entry_type);
-CREATE INDEX IF NOT EXISTS idx_me_proj_date    ON memory_entries(project, occurred_at);
-
--- Indexes for memory_summaries
-CREATE INDEX IF NOT EXISTS idx_ms_role_project ON memory_summaries(agent_role, project);
-
--- Indexes for memory_patterns
-CREATE INDEX IF NOT EXISTS idx_mp_status       ON memory_patterns(status);
-CREATE INDEX IF NOT EXISTS idx_mp_pattern_type ON memory_patterns(pattern_type);
-
--- FTS5 for memory_entries
-CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
-  title,
-  body,
-  content=memory_entries,
-  content_rowid=id
+CREATE INDEX IF NOT EXISTS idx_rel_source ON relations(source_entity_id);
+CREATE INDEX IF NOT EXISTS idx_rel_target ON relations(target_entity_id);
+CREATE INDEX IF NOT EXISTS idx_rel_type   ON relations(relation_type);
+
+-- ============================================================
+-- EPISODES — conversation/run history
+-- ============================================================
+CREATE TABLE IF NOT EXISTS episodes (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id  TEXT    NOT NULL,
+  namespace   TEXT,
+  agent_role  TEXT,
+  role        TEXT    NOT NULL,  -- user | assistant | system
+  content     TEXT    NOT NULL,
+  summary     TEXT,
+  metadata    TEXT    NOT NULL DEFAULT '{}',
+  created_at  TEXT    NOT NULL
 );
 
-CREATE TRIGGER IF NOT EXISTS memory_fts_insert AFTER INSERT ON memory_entries BEGIN
-  INSERT INTO memory_fts(rowid, title, body) VALUES (new.id, new.title, new.body);
-END;
+CREATE INDEX IF NOT EXISTS idx_ep_session ON episodes(session_id);
+CREATE INDEX IF NOT EXISTS idx_ep_ns      ON episodes(namespace);
 
-CREATE TRIGGER IF NOT EXISTS memory_fts_update AFTER UPDATE ON memory_entries BEGIN
-  INSERT INTO memory_fts(memory_fts, rowid, title, body) VALUES ('delete', old.id, old.title, old.body);
-  INSERT INTO memory_fts(rowid, title, body) VALUES (new.id, new.title, new.body);
+-- FTS5 for episodes
+CREATE VIRTUAL TABLE IF NOT EXISTS episodes_fts USING fts5(
+  content, summary,
+  content=episodes, content_rowid=id
+);
+CREATE TRIGGER IF NOT EXISTS ep_fts_i AFTER INSERT ON episodes BEGIN
+  INSERT INTO episodes_fts(rowid, content, summary) VALUES (new.id, new.content, new.summary);
 END;
-
-CREATE TRIGGER IF NOT EXISTS memory_fts_delete AFTER DELETE ON memory_entries BEGIN
-  INSERT INTO memory_fts(memory_fts, rowid, title, body) VALUES ('delete', old.id, old.title, old.body);
+CREATE TRIGGER IF NOT EXISTS ep_fts_u AFTER UPDATE ON episodes BEGIN
+  INSERT INTO episodes_fts(episodes_fts, rowid, content, summary) VALUES ('delete', old.id, old.content, old.summary);
+  INSERT INTO episodes_fts(rowid, content, summary) VALUES (new.id, new.content, new.summary);
 END;
-
--- FTS5 for memory_summaries
-CREATE VIRTUAL TABLE IF NOT EXISTS memory_summaries_fts USING fts5(
-  title,
-  body,
-  content=memory_summaries,
-  content_rowid=id
-);
-
-CREATE TRIGGER IF NOT EXISTS ms_fts_insert AFTER INSERT ON memory_summaries BEGIN
-  INSERT INTO memory_summaries_fts(rowid, title, body) VALUES (new.id, new.title, new.body);
+CREATE TRIGGER IF NOT EXISTS ep_fts_d AFTER DELETE ON episodes BEGIN
+  INSERT INTO episodes_fts(episodes_fts, rowid, content, summary) VALUES ('delete', old.id, old.content, old.content);
 END;
 
-CREATE TRIGGER IF NOT EXISTS ms_fts_update AFTER UPDATE ON memory_summaries BEGIN
-  INSERT INTO memory_summaries_fts(memory_summaries_fts, rowid, title, body) VALUES ('delete', old.id, old.title, old.body);
-  INSERT INTO memory_summaries_fts(rowid, title, body) VALUES (new.id, new.title, new.body);
-END;
+-- ============================================================
+-- SUMMARIES — rolled-up digests
+-- ============================================================
+CREATE TABLE IF NOT EXISTS summaries (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  scope       TEXT    NOT NULL,
+  namespace   TEXT,
+  agent_role  TEXT,
+  title       TEXT    NOT NULL,
+  content     TEXT    NOT NULL,
+  entry_count INTEGER NOT NULL,
+  date_from   TEXT    NOT NULL,
+  date_to     TEXT    NOT NULL,
+  entry_ids   TEXT    NOT NULL,  -- JSON array
+  created_at  TEXT    NOT NULL
+);
 
-CREATE TRIGGER IF NOT EXISTS ms_fts_delete AFTER DELETE ON memory_summaries BEGIN
-  INSERT INTO memory_summaries_fts(memory_summaries_fts, rowid, title, body) VALUES ('delete', old.id, old.title, old.body);
-END;
+CREATE INDEX IF NOT EXISTS idx_sum_ns ON summaries(namespace, agent_role);

package/migrate.ts

@@ -1,250 +0,0 @@
-#!/usr/bin/env node --experimental-strip-types
-/**
- * Migration utility: imports existing .ao/memory/*.md files into the memory database.
- *
- * Usage:
- *   node --experimental-strip-types migrate.ts [--repos-dir <path>] [--db <path>]
- *
- * Defaults:
- *   --repos-dir: scans current directory and subdirectories for .ao/memory/
- *   --db: ~/.ao/memory.db
- */
-import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
-import { join, basename, dirname } from "node:path";
-import { resolveDbPath, initDb, contentHash, now } from "./src/db.ts";
-
-// Parse args
-const argv = process.argv.slice(2);
-let reposDir = ".";
-let dbPath: string | undefined;
-for (let i = 0; i < argv.length; i++) {
-  if (argv[i] === "--repos-dir" && argv[i + 1]) reposDir = argv[++i];
-  if (argv[i] === "--db" && argv[i + 1]) dbPath = argv[++i];
-}
-
-const db = initDb(resolveDbPath(dbPath));
-
-const roleToFile: Record<string, string> = {
-  "planner.md": "planner",
-  "product-owner.md": "product-owner",
-  "reconciler.md": "reconciler",
-  "reviewer.md": "reviewer",
-  "qa-tester.md": "qa-tester",
-};
-
-const sectionToEntryType: Record<string, string> = {
-  "tasks enqueued": "task_dispatch",
-  "recently enqueued": "task_dispatch",
-  "rework dispatched": "task_dispatch",
-  "rebase dispatched": "task_dispatch",
-  "tasks skipped": "observation",
-  "capacity notes": "observation",
-  "queue status": "observation",
-  "pipeline health": "observation",
-  "decisions": "decision",
-  "tasks created": "decision",
-  "features assessed": "observation",
-  "gaps identified": "observation",
-  "tasks unblocked": "action",
-  "tasks marked done": "action",
-  "queue cleaned": "action",
-  "actions log": "action",
-  "prs merged": "review",
-  "prs with changes requested": "review",
-  "prs closed": "review",
-  "known patterns": "pattern",
-  "log": "test_result",
-  "test results": "test_result",
-  "bugs filed": "test_result",
-  "regressions": "test_result",
-};
-
-function guessEntryType(sectionHeader: string, agentRole: string): string {
-  const lower = sectionHeader.toLowerCase();
-  for (const [key, type] of Object.entries(sectionToEntryType)) {
-    if (lower.includes(key)) return type;
-  }
-  // Fallback by role
-  if (agentRole === "planner") return "task_dispatch";
-  if (agentRole === "product-owner") return "decision";
-  if (agentRole === "reconciler") return "action";
-  if (agentRole === "reviewer") return "review";
-  if (agentRole === "qa-tester") return "test_result";
-  return "observation";
-}
-
-interface ParsedEntry {
-  date: string;
-  title: string;
-  body: string;
-  entryType: string;
-  taskId?: string;
-  prNumber?: number;
-  runId?: string;
-}
-
-function parseMemoryFile(content: string, agentRole: string): ParsedEntry[] {
-  const entries: ParsedEntry[] = [];
-  const lines = content.split("\n");
-  let currentSection = "";
-  let currentDate = "";
-  let currentBlock: string[] = [];
-
-  function flushBlock() {
-    if (currentBlock.length === 0 || !currentDate) return;
-    const body = currentBlock.join("\n").trim();
-    if (!body) return;
-
-    const entryType = guessEntryType(currentSection, agentRole);
-    const firstLine = currentBlock.find(l => l.trim())?.trim() || "";
-    const title = firstLine.length > 120 ? firstLine.slice(0, 117) + "..." : firstLine;
-
-    // Extract task IDs
-    const taskMatch = body.match(/TASK-\d+/);
-    const prMatch = body.match(/(?:PR\s*#|#)(\d+)/);
-    const runMatch = body.match(/run\s+(\d+)/i);
-
-    entries.push({
-      date: currentDate,
-      title: title || `${agentRole} ${entryType} ${currentDate}`,
-      body,
-      entryType,
-      taskId: taskMatch?.[0],
-      prNumber: prMatch ? parseInt(prMatch[1]) : undefined,
-      runId: runMatch ? `run ${runMatch[1]}` : undefined,
-    });
-  }
-
-  for (const line of lines) {
-    // Section headers
-    const sectionMatch = line.match(/^##\s+(.+)/);
-    if (sectionMatch) {
-      flushBlock();
-      currentBlock = [];
-      currentSection = sectionMatch[1];
-
-      // Check if section header contains a date
-      const dateInHeader = currentSection.match(/(\d{4}-\d{2}-\d{2})/);
-      if (dateInHeader) currentDate = dateInHeader[1];
-      continue;
-    }
-
-    // Date patterns
-    const dateMatch = line.match(/\[(\d{4}-\d{2}-\d{2})\]/);
-    if (dateMatch) {
-      flushBlock();
-      currentBlock = [];
-      currentDate = dateMatch[1];
-      currentBlock.push(line);
-      continue;
-    }
-
-    // Separator — flush
-    if (line.match(/^---\s*$/)) {
-      flushBlock();
-      currentBlock = [];
-      continue;
-    }
-
-    currentBlock.push(line);
-  }
-  flushBlock();
-
-  return entries;
-}
-
-function findMemoryDirs(rootDir: string): { project: string; memoryDir: string }[] {
-  const results: { project: string; memoryDir: string }[] = [];
-
-  // Check if rootDir itself has .ao/memory
-  const directMemory = join(rootDir, ".ao", "memory");
-  if (existsSync(directMemory) && statSync(directMemory).isDirectory()) {
-    results.push({ project: basename(rootDir), memoryDir: directMemory });
-  }
-
-  // Scan subdirectories
-  try {
-    for (const entry of readdirSync(rootDir, { withFileTypes: true })) {
-      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const memDir = join(rootDir, entry.name, ".ao", "memory");
-      if (existsSync(memDir) && statSync(memDir).isDirectory()) {
-        results.push({ project: entry.name, memoryDir: memDir });
-      }
-    }
-  } catch {}
-
-  return results;
-}
-
-// Main
-const ts = now();
-const memoryDirs = findMemoryDirs(reposDir);
-const summary: Record<string, Record<string, number>> = {};
-let totalImported = 0;
-let totalSkipped = 0;
-
-const insert = db.prepare(`
-  INSERT INTO memory_entries (entry_type, agent_role, project, title, body, task_id, pr_number, run_id, status, tags, metadata, created_at, occurred_at, updated_at, content_hash)
-  VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'active', '[]', '{}', ?, ?, ?, ?)
-`);
-
-const checkHash = db.prepare("SELECT id FROM memory_entries WHERE content_hash = ?");
-
-const importAll = db.transaction(() => {
-  for (const { project, memoryDir } of memoryDirs) {
-    summary[project] = {};
-    try {
-      for (const file of readdirSync(memoryDir)) {
-        const agentRole = roleToFile[file];
-        if (!agentRole) continue;
-
-        const content = readFileSync(join(memoryDir, file), "utf-8");
-        const entries = parseMemoryFile(content, agentRole);
-
-        let count = 0;
-        for (const entry of entries) {
-          const hash = contentHash(entry.entryType, agentRole, project, entry.title, entry.body);
-          if (checkHash.get(hash)) {
-            totalSkipped++;
-            continue;
-          }
-
-          insert.run(
-            entry.entryType, agentRole, project,
-            entry.title, entry.body,
-            entry.taskId || null, entry.prNumber || null, entry.runId || null,
-            ts, entry.date + "T00:00:00.000Z", ts, hash
-          );
-          count++;
-          totalImported++;
-        }
-        summary[project][agentRole] = count;
-      }
-    } catch (err) {
-      console.error(`Error processing ${project}: ${err}`);
-    }
-  }
-});
-
-importAll();
-
-// Print results
-console.log("\n=== Migration Complete ===\n");
-console.log(`Scanned: ${memoryDirs.length} projects with .ao/memory/`);
-console.log(`Imported: ${totalImported} entries`);
-console.log(`Skipped (duplicates): ${totalSkipped}\n`);
-
-const roles = [...new Set(Object.values(summary).flatMap(s => Object.keys(s)))].sort();
-const header = ["Project", ...roles, "Total"].map(h => h.padEnd(16)).join(" | ");
-console.log(header);
-console.log("-".repeat(header.length));
-
-for (const [project, counts] of Object.entries(summary).sort()) {
-  const total = Object.values(counts).reduce((a, b) => a + b, 0);
-  const row = [project, ...roles.map(r => String(counts[r] || 0)), String(total)]
-    .map(v => v.padEnd(16))
-    .join(" | ");
-  console.log(row);
-}
-
-console.log(`\nDatabase: ${resolveDbPath(dbPath)}`);