@launchapp-dev/ao-memory-mcp 1.0.0

package/migrate.ts

@@ -0,0 +1,250 @@
+#!/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)}`);

package/package.json

@@ -0,0 +1,24 @@
+{
+  "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",
+  "type": "module",
+  "bin": {
+    "ao-memory-mcp": "./src/server.ts"
+  },
+  "scripts": {
+    "start": "node --experimental-strip-types src/server.ts",
+    "migrate": "node --experimental-strip-types migrate.ts",
+    "build": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "better-sqlite3": "^11.0.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/src/db.ts

@@ -0,0 +1,48 @@
+import Database from "better-sqlite3";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { mkdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export function resolveDbPath(cliDbPath?: string): string {
+  if (cliDbPath) return cliDbPath;
+  if (process.env.AO_MEMORY_DB) return process.env.AO_MEMORY_DB;
+  const home = process.env.HOME || process.env.USERPROFILE || ".";
+  const aoDir = join(home, ".ao");
+  mkdirSync(aoDir, { recursive: true });
+  return join(aoDir, "memory.db");
+}
+
+export function initDb(dbPath: string): Database.Database {
+  const db = new Database(dbPath);
+  const schema = readFileSync(join(__dirname, "schema.sql"), "utf-8");
+  db.exec(schema);
+  return db;
+}
+
+export function contentHash(
+  entryType: string,
+  agentRole: string,
+  project: string,
+  title: string,
+  body: string
+): string {
+  return createHash("sha256")
+    .update(`${entryType}\0${agentRole}\0${project}\0${title}\0${body}`)
+    .digest("hex");
+}
+
+export function now(): string {
+  return new Date().toISOString();
+}
+
+export function jsonResult(data: unknown) {
+  return { content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }] };
+}
+
+export function errorResult(message: string) {
+  return { content: [{ type: "text" as const, text: JSON.stringify({ error: message }) }], isError: true };
+}

package/src/schema.sql

@@ -0,0 +1,113 @@
+PRAGMA journal_mode = WAL;
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS memory_entries (
+  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 '[]',
+  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
+);
+
+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
+);
+
+CREATE TABLE IF NOT EXISTS memory_patterns (
+  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,
+  created_at       TEXT    NOT NULL,
+  updated_at       TEXT    NOT NULL
+);
+
+-- 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 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 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);
+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);
+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);
+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;
+
+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;

package/src/server.ts

@@ -0,0 +1,59 @@
+#!/usr/bin/env node --experimental-strip-types
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { resolveDbPath, initDb, errorResult } from "./db.ts";
+import { storeTools, handleStore } from "./tools/store.ts";
+import { recallTools, handleRecall } from "./tools/recall.ts";
+import { statsTools, handleStats } from "./tools/stats.ts";
+import { contextTools, handleContext } from "./tools/context.ts";
+import { summarizeTools, handleSummarize } from "./tools/summarize.ts";
+import { patternTools, handlePatterns } from "./tools/patterns.ts";
+
+// Parse CLI args
+const args = process.argv.slice(2);
+let dbPath: string | undefined;
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--db" && args[i + 1]) {
+    dbPath = args[++i];
+  }
+}
+
+const db = initDb(resolveDbPath(dbPath));
+
+const allTools = [
+  ...storeTools,
+  ...recallTools,
+  ...statsTools,
+  ...contextTools,
+  ...summarizeTools,
+  ...patternTools,
+];
+
+const handlers = [handleStore, handleRecall, handleStats, handleContext, handleSummarize, handlePatterns];
+
+const server = new Server(
+  { name: "ao-memory-mcp", version: "1.0.0" },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: allTools,
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  const { name, arguments: input } = req.params;
+
+  for (const handler of handlers) {
+    const result = handler(db, name, input || {});
+    if (result) return result;
+  }
+
+  return errorResult(`Unknown tool: ${name}`);
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/src/tools/context.ts

@@ -0,0 +1,77 @@
+import type Database from "better-sqlite3";
+import { jsonResult } from "../db.ts";
+
+export const contextTools = [
+  {
+    name: "memory.context",
+    description:
+      "Agent boot tool — call at the start of each run to load relevant memory. Returns recent entries, active decisions, cross-project patterns, summaries, and a summarization_needed flag.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        agent_role: { type: "string", description: "Agent role requesting context" },
+        project: { type: "string", description: "Project the agent is working on" },
+        limit: { type: "number", description: "Max entries per section (default 10)" },
+      },
+      required: ["agent_role", "project"],
+    },
+  },
+];
+
+export function handleContext(db: Database.Database, name: string, args: any) {
+  if (name === "memory.context") return memoryContext(db, args);
+  return null;
+}
+
+function memoryContext(db: Database.Database, args: any) {
+  const { agent_role, project } = args;
+  const limit = args.limit || 10;
+
+  const recentEntries = db.prepare(`
+    SELECT * FROM memory_entries
+    WHERE agent_role = ? AND project = ? AND status = 'active'
+    ORDER BY occurred_at DESC LIMIT ?
+  `).all(agent_role, project, limit);
+
+  const activeDecisions = db.prepare(`
+    SELECT * FROM memory_entries
+    WHERE project = ? AND entry_type = 'decision' AND status = 'active'
+    ORDER BY occurred_at DESC LIMIT ?
+  `).all(project, limit);
+
+  const activePatterns = db.prepare(`
+    SELECT * FROM memory_patterns
+    WHERE status = 'active'
+      AND EXISTS (SELECT 1 FROM json_each(projects) WHERE json_each.value = ?)
+    ORDER BY last_seen DESC LIMIT ?
+  `).all(project, limit);
+
+  const recentSummaries = db.prepare(`
+    SELECT * FROM memory_summaries
+    WHERE agent_role = ? AND project = ?
+    ORDER BY created_at DESC LIMIT 5
+  `).all(agent_role, project);
+
+  const crossProjectAlerts = db.prepare(`
+    SELECT * FROM memory_patterns
+    WHERE status = 'active' AND occurrence_count >= 3
+    ORDER BY last_seen DESC LIMIT 5
+  `).all();
+
+  // Check if summarization is needed: 20+ active entries older than 3 days
+  const threeDaysAgo = new Date(Date.now() - 3 * 24 * 60 * 60 * 1000).toISOString();
+  const staleCount = (db.prepare(`
+    SELECT COUNT(*) as count FROM memory_entries
+    WHERE agent_role = ? AND project = ? AND status = 'active' AND occurred_at < ?
+  `).get(agent_role, project, threeDaysAgo) as any).count;
+
+  return jsonResult({
+    recent_entries: recentEntries,
+    active_decisions: activeDecisions,
+    active_patterns: activePatterns,
+    recent_summaries: recentSummaries,
+    cross_project_alerts: crossProjectAlerts,
+    summarization_needed: staleCount >= 20,
+    stale_entry_count: staleCount,
+  });
+}

package/src/tools/patterns.ts

@@ -0,0 +1,165 @@
+import type Database from "better-sqlite3";
+import { now, jsonResult, errorResult } from "../db.ts";
+
+export const patternTools = [
+  {
+    name: "memory.patterns.detect",
+    description:
+      "Scan for recurring patterns across projects. Finds entries with similar titles or matching tags that appear in multiple projects.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        min_occurrences: { type: "number", description: "Minimum projects to count as a pattern (default 2)" },
+        entry_type: { type: "string", description: "Restrict to entry type" },
+        limit: { type: "number", description: "Max patterns to return (default 10)" },
+      },
+    },
+  },
+  {
+    name: "memory.patterns.record",
+    description:
+      "Create or update a confirmed cross-project pattern.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        id: { type: "number", description: "Existing pattern ID to update (omit to create new)" },
+        pattern_type: { type: "string", description: "Type (e.g. bug_pattern, process_pattern, architectural_pattern, anti_pattern)" },
+        title: { type: "string", description: "Pattern name" },
+        description: { type: "string", description: "Full description" },
+        projects: { type: "array", items: { type: "string" }, description: "Projects where pattern appears" },
+        agent_roles: { type: "array", items: { type: "string" }, description: "Roles that reported it" },
+        entry_ids: { type: "array", items: { type: "number" }, description: "Memory entry IDs as evidence" },
+        status: { type: "string", enum: ["active", "resolved", "archived"], description: "Pattern status" },
+      },
+      required: ["pattern_type", "title", "description"],
+    },
+  },
+  {
+    name: "memory.patterns.list",
+    description: "List known cross-project patterns.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        status: { type: "string", enum: ["active", "resolved", "archived", "all"], description: "Filter by status (default: active)" },
+        pattern_type: { type: "string", description: "Filter by pattern type" },
+        project: { type: "string", description: "Filter patterns involving this project" },
+        limit: { type: "number", description: "Max results (default 20)" },
+      },
+    },
+  },
+];
+
+export function handlePatterns(db: Database.Database, name: string, args: any) {
+  if (name === "memory.patterns.detect") return patternsDetect(db, args);
+  if (name === "memory.patterns.record") return patternsRecord(db, args);
+  if (name === "memory.patterns.list") return patternsList(db, args);
+  return null;
+}
+
+function patternsDetect(db: Database.Database, args: any) {
+  const minOccurrences = args.min_occurrences ?? 2;
+  const limit = args.limit ?? 10;
+
+  // Find tags that appear across multiple projects
+  const tagCondition = args.entry_type ? "AND e.entry_type = ?" : "";
+  const tagVals = args.entry_type ? [args.entry_type] : [];
+
+  const tagPatterns = db.prepare(`
+    SELECT t.value as tag, COUNT(DISTINCT e.project) as project_count,
+           GROUP_CONCAT(DISTINCT e.project) as projects,
+           COUNT(*) as total_entries
+    FROM memory_entries e, json_each(e.tags) t
+    WHERE e.status = 'active' ${tagCondition}
+    GROUP BY t.value
+    HAVING COUNT(DISTINCT e.project) >= ?
+    ORDER BY project_count DESC
+    LIMIT ?
+  `).all(...tagVals, minOccurrences, limit);
+
+  // Find similar titles across projects using FTS5
+  const titlePatterns = db.prepare(`
+    SELECT e1.title, COUNT(DISTINCT e1.project) as project_count,
+           GROUP_CONCAT(DISTINCT e1.project) as projects,
+           COUNT(*) as total_entries
+    FROM memory_entries e1
+    WHERE e1.status = 'active' ${tagCondition}
+    GROUP BY e1.title
+    HAVING COUNT(DISTINCT e1.project) >= ?
+    ORDER BY project_count DESC
+    LIMIT ?
+  `).all(...tagVals, minOccurrences, limit);
+
+  return jsonResult({
+    tag_patterns: tagPatterns,
+    title_patterns: titlePatterns,
+  });
+}
+
+function patternsRecord(db: Database.Database, args: any) {
+  const ts = now();
+
+  if (args.id) {
+    const existing = db.prepare("SELECT * FROM memory_patterns WHERE id = ?").get(args.id) as any;
+    if (!existing) return errorResult(`Pattern ${args.id} not found`);
+
+    const sets: string[] = [];
+    const vals: any[] = [];
+
+    if (args.pattern_type) { sets.push("pattern_type = ?"); vals.push(args.pattern_type); }
+    if (args.title) { sets.push("title = ?"); vals.push(args.title); }
+    if (args.description) { sets.push("description = ?"); vals.push(args.description); }
+    if (args.projects) { sets.push("projects = ?"); vals.push(JSON.stringify(args.projects)); }
+    if (args.agent_roles) { sets.push("agent_roles = ?"); vals.push(JSON.stringify(args.agent_roles)); }
+    if (args.entry_ids) { sets.push("entry_ids = ?"); vals.push(JSON.stringify(args.entry_ids)); }
+    if (args.status) {
+      sets.push("status = ?"); vals.push(args.status);
+      if (args.status === "resolved") { sets.push("resolved_at = ?"); vals.push(ts); }
+    }
+
+    sets.push("last_seen = ?"); vals.push(ts);
+    sets.push("updated_at = ?"); vals.push(ts);
+    sets.push("occurrence_count = occurrence_count + 1");
+
+    vals.push(args.id);
+    db.prepare(`UPDATE memory_patterns SET ${sets.join(", ")} WHERE id = ?`).run(...vals);
+
+    return jsonResult({ id: args.id, updated: true });
+  }
+
+  const result = db.prepare(`
+    INSERT INTO memory_patterns (pattern_type, title, description, projects, agent_roles, entry_ids, occurrence_count, status, first_seen, last_seen, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, 1, 'active', ?, ?, ?, ?)
+  `).run(
+    args.pattern_type,
+    args.title,
+    args.description,
+    JSON.stringify(args.projects || []),
+    JSON.stringify(args.agent_roles || []),
+    JSON.stringify(args.entry_ids || []),
+    ts, ts, ts, ts
+  );
+
+  return jsonResult({ id: result.lastInsertRowid, created: true });
+}
+
+function patternsList(db: Database.Database, args: any) {
+  const conditions: string[] = [];
+  const vals: any[] = [];
+  const status = args.status || "active";
+
+  if (status !== "all") { conditions.push("status = ?"); vals.push(status); }
+  if (args.pattern_type) { conditions.push("pattern_type = ?"); vals.push(args.pattern_type); }
+  if (args.project) {
+    conditions.push("EXISTS (SELECT 1 FROM json_each(projects) WHERE json_each.value = ?)");
+    vals.push(args.project);
+  }
+
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = args.limit || 20;
+
+  const rows = db.prepare(
+    `SELECT * FROM memory_patterns ${where} ORDER BY last_seen DESC LIMIT ?`
+  ).all(...vals, limit);
+
+  return jsonResult({ patterns: rows, count: rows.length });
+}

package/src/tools/recall.ts

@@ -0,0 +1,124 @@
+import type Database from "better-sqlite3";
+import { jsonResult, errorResult } from "../db.ts";
+
+export const recallTools = [
+  {
+    name: "memory.recall",
+    description:
+      "Query memory entries with structured filters. Returns entries sorted by date. Default: 50 most recent active entries.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        agent_role: { type: "string", description: "Filter by agent role" },
+        project: { type: "string", description: "Filter by project" },
+        entry_type: { type: "string", description: "Filter by entry type" },
+        task_id: { type: "string", description: "Filter by task ID" },
+        status: { type: "string", enum: ["active", "summarized", "archived"], description: "Filter by status (default: active)" },
+        date_from: { type: "string", description: "Entries from this ISO date" },
+        date_to: { type: "string", description: "Entries up to this ISO date" },
+        tags: { type: "array", items: { type: "string" }, description: "Filter by tags (must have ALL specified)" },
+        limit: { type: "number", description: "Max results (default 50)" },
+        offset: { type: "number", description: "Pagination offset (default 0)" },
+        order: { type: "string", enum: ["newest", "oldest"], description: "Sort order (default: newest)" },
+      },
+    },
+  },
+  {
+    name: "memory.search",
+    description:
+      "Full-text search across all memory entries. Uses FTS5 for fast matching.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        query: { type: "string", description: "Search query (supports FTS5 syntax)" },
+        agent_role: { type: "string", description: "Restrict to agent role" },
+        project: { type: "string", description: "Restrict to project" },
+        entry_type: { type: "string", description: "Restrict to entry type" },
+        status: { type: "string", description: "Restrict to status" },
+        limit: { type: "number", description: "Max results (default 20)" },
+      },
+      required: ["query"],
+    },
+  },
+  {
+    name: "memory.get",
+    description: "Get a single memory entry by ID.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        id: { type: "number", description: "Memory entry ID" },
+      },
+      required: ["id"],
+    },
+  },
+];
+
+export function handleRecall(db: Database.Database, name: string, args: any) {
+  if (name === "memory.recall") return memoryRecall(db, args);
+  if (name === "memory.search") return memorySearch(db, args);
+  if (name === "memory.get") return memoryGet(db, args);
+  return null;
+}
+
+function memoryRecall(db: Database.Database, args: any) {
+  const conditions: string[] = [];
+  const vals: any[] = [];
+  const status = args.status || "active";
+
+  conditions.push("status = ?"); vals.push(status);
+  if (args.agent_role) { conditions.push("agent_role = ?"); vals.push(args.agent_role); }
+  if (args.project) { conditions.push("project = ?"); vals.push(args.project); }
+  if (args.entry_type) { conditions.push("entry_type = ?"); vals.push(args.entry_type); }
+  if (args.task_id) { conditions.push("task_id = ?"); vals.push(args.task_id); }
+  if (args.date_from) { conditions.push("occurred_at >= ?"); vals.push(args.date_from); }
+  if (args.date_to) { conditions.push("occurred_at <= ?"); vals.push(args.date_to); }
+
+  if (args.tags?.length) {
+    for (const tag of args.tags) {
+      conditions.push("EXISTS (SELECT 1 FROM json_each(tags) WHERE json_each.value = ?)");
+      vals.push(tag);
+    }
+  }
+
+  const order = args.order === "oldest" ? "ASC" : "DESC";
+  const limit = args.limit || 50;
+  const offset = args.offset || 0;
+
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = db.prepare(
+    `SELECT * FROM memory_entries ${where} ORDER BY occurred_at ${order} LIMIT ? OFFSET ?`
+  ).all(...vals, limit, offset);
+
+  return jsonResult({ entries: rows, count: rows.length });
+}
+
+function memorySearch(db: Database.Database, args: any) {
+  const conditions: string[] = [];
+  const vals: any[] = [];
+
+  if (args.agent_role) { conditions.push("e.agent_role = ?"); vals.push(args.agent_role); }
+  if (args.project) { conditions.push("e.project = ?"); vals.push(args.project); }
+  if (args.entry_type) { conditions.push("e.entry_type = ?"); vals.push(args.entry_type); }
+  if (args.status) { conditions.push("e.status = ?"); vals.push(args.status); }
+
+  const extraWhere = conditions.length ? `AND ${conditions.join(" AND ")}` : "";
+  const limit = args.limit || 20;
+
+  const rows = db.prepare(`
+    SELECT e.*, snippet(memory_fts, 0, '<mark>', '</mark>', '...', 32) as title_snippet,
+           snippet(memory_fts, 1, '<mark>', '</mark>', '...', 64) as body_snippet
+    FROM memory_fts f
+    JOIN memory_entries e ON e.id = f.rowid
+    WHERE memory_fts MATCH ? ${extraWhere}
+    ORDER BY rank
+    LIMIT ?
+  `).all(args.query, ...vals, limit);
+
+  return jsonResult({ entries: rows, count: rows.length });
+}
+
+function memoryGet(db: Database.Database, args: any) {
+  const entry = db.prepare("SELECT * FROM memory_entries WHERE id = ?").get(args.id);
+  if (!entry) return errorResult(`Entry ${args.id} not found`);
+  return jsonResult(entry);
+}

package/src/tools/stats.ts

@@ -0,0 +1,74 @@
+import type Database from "better-sqlite3";
+import { jsonResult } from "../db.ts";
+
+export const statsTools = [
+  {
+    name: "memory.stats",
+    description:
+      "Get aggregate statistics about memory entries. Optionally filter by project or agent role.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        project: { type: "string", description: "Filter by project" },
+        agent_role: { type: "string", description: "Filter by agent role" },
+      },
+    },
+  },
+];
+
+export function handleStats(db: Database.Database, name: string, args: any) {
+  if (name === "memory.stats") return memoryStats(db, args);
+  return null;
+}
+
+function memoryStats(db: Database.Database, args: any) {
+  const conditions: string[] = [];
+  const vals: any[] = [];
+
+  if (args.project) { conditions.push("project = ?"); vals.push(args.project); }
+  if (args.agent_role) { conditions.push("agent_role = ?"); vals.push(args.agent_role); }
+
+  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : "";
+
+  const total = (db.prepare(`SELECT COUNT(*) as count FROM memory_entries ${where}`).get(...vals) as any).count;
+
+  const byType = db.prepare(
+    `SELECT entry_type, COUNT(*) as count FROM memory_entries ${where} GROUP BY entry_type ORDER BY count DESC`
+  ).all(...vals);
+
+  const byStatus = db.prepare(
+    `SELECT status, COUNT(*) as count FROM memory_entries ${where} GROUP BY status ORDER BY count DESC`
+  ).all(...vals);
+
+  const byRole = db.prepare(
+    `SELECT agent_role, COUNT(*) as count FROM memory_entries ${where} GROUP BY agent_role ORDER BY count DESC`
+  ).all(...vals);
+
+  const byProject = db.prepare(
+    `SELECT project, COUNT(*) as count FROM memory_entries ${where} GROUP BY project ORDER BY count DESC`
+  ).all(...vals);
+
+  const dateRange = db.prepare(
+    `SELECT MIN(occurred_at) as oldest, MAX(occurred_at) as newest FROM memory_entries ${where}`
+  ).get(...vals) as any;
+
+  const summaryCount = (db.prepare(
+    `SELECT COUNT(*) as count FROM memory_summaries ${where.replace("entry_type", "entry_type")}`
+  ).get(...vals) as any).count;
+
+  const patternCount = (db.prepare(
+    `SELECT COUNT(*) as count FROM memory_patterns WHERE status = 'active'`
+  ).get() as any).count;
+
+  return jsonResult({
+    total_entries: total,
+    total_summaries: summaryCount,
+    active_patterns: patternCount,
+    oldest_entry: dateRange?.oldest,
+    newest_entry: dateRange?.newest,
+    by_type: byType,
+    by_status: byStatus,
+    by_role: byRole,
+    by_project: byProject,
+  });
+}

package/src/tools/store.ts

@@ -0,0 +1,160 @@
+import type Database from "better-sqlite3";
+import { contentHash, now, jsonResult, errorResult } from "../db.ts";
+
+export const storeTools = [
+  {
+    name: "memory.store",
+    description:
+      "Store a new memory entry. Deduplicates via content hash — returns existing entry if duplicate detected.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        entry_type: { type: "string", description: "Type of memory (e.g. decision, observation, task_dispatch, test_result, review, action)" },
+        agent_role: { type: "string", description: "Agent role that produced this memory (e.g. planner, reviewer, qa-tester)" },
+        project: { type: "string", description: "Project/repo name" },
+        title: { type: "string", description: "Short summary line" },
+        body: { type: "string", description: "Full markdown content" },
+        task_id: { type: "string", description: "Task ID reference (e.g. TASK-051)" },
+        pr_number: { type: "number", description: "PR number if applicable" },
+        run_id: { type: "string", description: "Run identifier (e.g. run 51)" },
+        tags: { type: "array", items: { type: "string" }, description: "Tags for categorization" },
+        metadata: { type: "object", description: "Entry-type-specific metadata" },
+        occurred_at: { type: "string", description: "ISO 8601 date when event occurred (defaults to now)" },
+      },
+      required: ["entry_type", "agent_role", "project", "title", "body"],
+    },
+  },
+  {
+    name: "memory.update",
+    description: "Update an existing memory entry by ID.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        id: { type: "number", description: "Memory entry ID" },
+        title: { type: "string", description: "New title" },
+        body: { type: "string", description: "New body" },
+        status: { type: "string", enum: ["active", "summarized", "archived"], description: "New status" },
+        tags: { type: "array", items: { type: "string" }, description: "New tags" },
+        metadata: { type: "object", description: "Metadata to merge" },
+      },
+      required: ["id"],
+    },
+  },
+  {
+    name: "memory.archive",
+    description: "Bulk archive entries by filter. At least one filter required.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        ids: { type: "array", items: { type: "number" }, description: "Specific entry IDs to archive" },
+        agent_role: { type: "string", description: "Archive all active entries for this role" },
+        project: { type: "string", description: "Archive all active entries for this project" },
+        before: { type: "string", description: "Archive entries with occurred_at before this ISO date" },
+      },
+    },
+  },
+];
+
+export function handleStore(db: Database.Database, name: string, args: any) {
+  if (name === "memory.store") return memoryStore(db, args);
+  if (name === "memory.update") return memoryUpdate(db, args);
+  if (name === "memory.archive") return memoryArchive(db, args);
+  return null;
+}
+
+function memoryStore(db: Database.Database, args: any) {
+  const { entry_type, agent_role, project, title, body } = args;
+  const hash = contentHash(entry_type, agent_role, project, title, body);
+
+  const existing = db.prepare("SELECT id FROM memory_entries WHERE content_hash = ?").get(hash) as any;
+  if (existing) {
+    return jsonResult({ duplicate: true, existing_id: existing.id });
+  }
+
+  const ts = now();
+  const result = 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', ?, ?, ?, ?, ?, ?)
+  `).run(
+    entry_type,
+    agent_role,
+    project,
+    title,
+    body,
+    args.task_id || null,
+    args.pr_number || null,
+    args.run_id || null,
+    JSON.stringify(args.tags || []),
+    JSON.stringify(args.metadata || {}),
+    ts,
+    args.occurred_at || ts,
+    ts,
+    hash
+  );
+
+  return jsonResult({ id: result.lastInsertRowid, created: true });
+}
+
+function memoryUpdate(db: Database.Database, args: any) {
+  const { id, ...updates } = args;
+
+  const entry = db.prepare("SELECT * FROM memory_entries WHERE id = ?").get(id) as any;
+  if (!entry) return errorResult(`Entry ${id} not found`);
+
+  const sets: string[] = [];
+  const vals: any[] = [];
+
+  if (updates.title !== undefined) { sets.push("title = ?"); vals.push(updates.title); }
+  if (updates.body !== undefined) { sets.push("body = ?"); vals.push(updates.body); }
+  if (updates.status !== undefined) {
+    sets.push("status = ?"); vals.push(updates.status);
+    if (updates.status === "archived") { sets.push("archived_at = ?"); vals.push(now()); }
+  }
+  if (updates.tags !== undefined) { sets.push("tags = ?"); vals.push(JSON.stringify(updates.tags)); }
+  if (updates.metadata !== undefined) {
+    const merged = { ...JSON.parse(entry.metadata), ...updates.metadata };
+    sets.push("metadata = ?"); vals.push(JSON.stringify(merged));
+  }
+
+  if (sets.length === 0) return errorResult("No fields to update");
+
+  sets.push("updated_at = ?"); vals.push(now());
+
+  if (updates.title !== undefined || updates.body !== undefined) {
+    const newTitle = updates.title || entry.title;
+    const newBody = updates.body || entry.body;
+    const hash = contentHash(entry.entry_type, entry.agent_role, entry.project, newTitle, newBody);
+    sets.push("content_hash = ?"); vals.push(hash);
+  }
+
+  vals.push(id);
+  db.prepare(`UPDATE memory_entries SET ${sets.join(", ")} WHERE id = ?`).run(...vals);
+
+  return jsonResult({ id, updated: true });
+}
+
+function memoryArchive(db: Database.Database, args: any) {
+  const { ids, agent_role, project, before } = args;
+
+  if (!ids && !agent_role && !project && !before) {
+    return errorResult("At least one filter required");
+  }
+
+  const conditions: string[] = ["status = 'active'"];
+  const vals: any[] = [];
+
+  if (ids?.length) {
+    conditions.push(`id IN (${ids.map(() => "?").join(",")})`);
+    vals.push(...ids);
+  }
+  if (agent_role) { conditions.push("agent_role = ?"); vals.push(agent_role); }
+  if (project) { conditions.push("project = ?"); vals.push(project); }
+  if (before) { conditions.push("occurred_at < ?"); vals.push(before); }
+
+  const ts = now();
+  const result = db.prepare(
+    `UPDATE memory_entries SET status = 'archived', archived_at = ?, updated_at = ? WHERE ${conditions.join(" AND ")}`
+  ).run(ts, ts, ...vals);
+
+  return jsonResult({ archived_count: result.changes });
+}

package/src/tools/summarize.ts

@@ -0,0 +1,140 @@
+import type Database from "better-sqlite3";
+import { now, jsonResult, errorResult } from "../db.ts";
+
+export const summarizeTools = [
+  {
+    name: "memory.summarize",
+    description:
+      "Create a summary of memory entries. The calling agent provides the summary text. The server creates the summary record and transitions matching entries to 'summarized' status.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        agent_role: { type: "string", description: "Agent role being summarized" },
+        project: { type: "string", description: "Project being summarized" },
+        entry_type: { type: "string", description: "Entry type filter (omit for mixed)" },
+        summary_title: { type: "string", description: "Title for the summary" },
+        summary_body: { type: "string", description: "The summary text (markdown)" },
+        before: { type: "string", description: "Summarize entries before this ISO date (default: 3 days ago)" },
+        entry_ids: { type: "array", items: { type: "number" }, description: "Specific entry IDs to summarize (overrides date filter)" },
+      },
+      required: ["agent_role", "project", "summary_title", "summary_body"],
+    },
+  },
+  {
+    name: "memory.cleanup",
+    description:
+      "Identify entries needing summarization or archive old summarized entries. Use dry_run to preview without changes.",
+    inputSchema: {
+      type: "object" as const,
+      properties: {
+        older_than_days: { type: "number", description: "Entries older than N days (default 7)" },
+        min_entries: { type: "number", description: "Minimum entries per role+project to trigger (default 10)" },
+        dry_run: { type: "boolean", description: "If true, just report what would happen (default true)" },
+      },
+    },
+  },
+];
+
+export function handleSummarize(db: Database.Database, name: string, args: any) {
+  if (name === "memory.summarize") return memorySummarize(db, args);
+  if (name === "memory.cleanup") return memoryCleanup(db, args);
+  return null;
+}
+
+function memorySummarize(db: Database.Database, args: any) {
+  const { agent_role, project, entry_type, summary_title, summary_body } = args;
+
+  const summarize = db.transaction(() => {
+    let entryIds: number[];
+
+    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 = ["agent_role = ?", "project = ?", "status = 'active'", "occurred_at < ?"];
+      const vals = [agent_role, project, cutoff];
+      if (entry_type) { conditions.push("entry_type = ?"); vals.push(entry_type); }
+
+      const rows = db.prepare(
+        `SELECT id FROM memory_entries WHERE ${conditions.join(" AND ")} ORDER BY occurred_at ASC`
+      ).all(...vals) as any[];
+      entryIds = rows.map(r => r.id);
+    }
+
+    if (entryIds.length === 0) {
+      return { error: "No entries to summarize" };
+    }
+
+    const entries = db.prepare(
+      `SELECT MIN(occurred_at) as date_from, MAX(occurred_at) as date_to FROM memory_entries WHERE id IN (${entryIds.map(() => "?").join(",")})`
+    ).get(...entryIds) as any;
+
+    const ts = now();
+    const result = db.prepare(`
+      INSERT INTO memory_summaries (agent_role, project, entry_type, title, body, entry_count, date_from, date_to, entry_ids, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      agent_role, project, entry_type || null,
+      summary_title, summary_body,
+      entryIds.length, entries.date_from, entries.date_to,
+      JSON.stringify(entryIds), ts
+    );
+
+    const placeholders = entryIds.map(() => "?").join(",");
+    db.prepare(
+      `UPDATE memory_entries SET status = 'summarized', updated_at = ? WHERE id IN (${placeholders})`
+    ).run(ts, ...entryIds);
+
+    return {
+      summary_id: result.lastInsertRowid,
+      entries_summarized: entryIds.length,
+      date_from: entries.date_from,
+      date_to: entries.date_to,
+    };
+  });
+
+  const result = summarize();
+  if ((result as any).error) return errorResult((result as any).error);
+  return jsonResult(result);
+}
+
+function memoryCleanup(db: Database.Database, args: any) {
+  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();
+
+  // Find scopes that need summarization
+  const needsSummarization = db.prepare(`
+    SELECT agent_role, project, COUNT(*) as entry_count,
+           MIN(occurred_at) as date_from, MAX(occurred_at) as date_to
+    FROM memory_entries
+    WHERE status = 'active' AND occurred_at < ?
+    GROUP BY agent_role, project
+    HAVING COUNT(*) >= ?
+    ORDER BY entry_count DESC
+  `).all(cutoff, minEntries);
+
+  // Find old summarized entries eligible for archival
+  const archivalCutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
+  const needsArchival = (db.prepare(`
+    SELECT COUNT(*) as count FROM memory_entries
+    WHERE status = 'summarized' AND updated_at < ?
+  `).get(archivalCutoff) as any).count;
+
+  if (!dryRun && needsArchival > 0) {
+    const ts = now();
+    db.prepare(`
+      UPDATE memory_entries SET status = 'archived', archived_at = ?, updated_at = ?
+      WHERE status = 'summarized' AND updated_at < ?
+    `).run(ts, ts, archivalCutoff);
+  }
+
+  return jsonResult({
+    needs_summarization: needsSummarization,
+    needs_archival: needsArchival,
+    archived: dryRun ? 0 : needsArchival,
+    dry_run: dryRun,
+  });
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "noEmit": true,
+    "strict": false,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts", "migrate.ts"]
+}