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

package/dist/db.d.ts

@@ -0,0 +1,25 @@
+import Database from "better-sqlite3";
+export declare function resolveDbPath(cliDbPath?: string): string;
+export declare function initDb(dbPath: string): Database.Database;
+export declare function initVec(db: Database.Database, dimensions: number): Promise<void>;
+export declare function isVecAvailable(): boolean;
+export declare function contentHash(...parts: string[]): string;
+export declare function now(): string;
+export declare function jsonResult(data: unknown): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+export declare function errorResult(message: string): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+};
+export declare function touchAccess(db: Database.Database, id: number): void;
+export declare function chunkText(text: string, maxChars?: number, overlap?: number): {
+    content: string;
+    offset: number;
+}[];

package/dist/db.js

@@ -0,0 +1,90 @@
+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));
+let vecLoaded = false;
+export function resolveDbPath(cliDbPath) {
+    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) {
+    const db = new Database(dbPath);
+    const schema = readFileSync(join(__dirname, "schema.sql"), "utf-8");
+    db.exec(schema);
+    return db;
+}
+export async function initVec(db, dimensions) {
+    if (vecLoaded)
+        return;
+    try {
+        const sqliteVec = await import("sqlite-vec");
+        const load = sqliteVec.load || sqliteVec.default?.load;
+        if (load)
+            load(db);
+        vecLoaded = true;
+    }
+    catch (e) {
+        console.error("[ao-memory] sqlite-vec not available, vector search disabled");
+        return;
+    }
+    db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS vec_memories USING vec0(
+      embedding float[${dimensions}] distance_metric=cosine
+    );
+    CREATE VIRTUAL TABLE IF NOT EXISTS vec_chunks USING vec0(
+      embedding float[${dimensions}] distance_metric=cosine
+    );
+  `);
+}
+export function isVecAvailable() {
+    return vecLoaded;
+}
+export function contentHash(...parts) {
+    return createHash("sha256").update(parts.join("\0")).digest("hex");
+}
+export function now() {
+    return new Date().toISOString();
+}
+export function jsonResult(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+export function errorResult(message) {
+    return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
+}
+export function touchAccess(db, id) {
+    db.prepare("UPDATE memories SET last_accessed_at = ?, access_count = access_count + 1 WHERE id = ?").run(now(), id);
+}
+export function chunkText(text, maxChars = 1000, overlap = 100) {
+    if (text.length <= maxChars) {
+        return [{ content: text, offset: 0 }];
+    }
+    const chunks = [];
+    let offset = 0;
+    while (offset < text.length) {
+        let end = Math.min(offset + maxChars, text.length);
+        if (end < text.length) {
+            const paraBreak = text.lastIndexOf("\n\n", end);
+            if (paraBreak > offset + maxChars * 0.3)
+                end = paraBreak + 2;
+            else {
+                const sentBreak = text.lastIndexOf(". ", end);
+                if (sentBreak > offset + maxChars * 0.3)
+                    end = sentBreak + 2;
+            }
+        }
+        chunks.push({ content: text.slice(offset, end).trim(), offset });
+        offset = end - overlap;
+        if (offset >= text.length)
+            break;
+    }
+    return chunks.filter(c => c.content.length > 0);
+}

package/dist/embeddings.d.ts

@@ -0,0 +1,14 @@
+import type Database from "better-sqlite3";
+export declare function getModelId(): string;
+export declare function getDimensions(): number;
+export declare function embed(text: string, isQuery?: boolean): Promise<Float32Array>;
+export declare function storeVector(db: Database.Database, table: string, rowid: number, embedding: Float32Array): void;
+export declare function deleteVector(db: Database.Database, table: string, rowid: number): void;
+export declare function searchVectors(db: Database.Database, table: string, queryEmbedding: Float32Array, limit?: number): {
+    rowid: number;
+    distance: number;
+}[];
+export declare function hybridSearch(db: Database.Database, ftsTable: string, vecTable: string, queryText: string, queryEmbedding: Float32Array, limit?: number, alpha?: number): {
+    rowid: number;
+    score: number;
+}[];

package/dist/embeddings.js

@@ -0,0 +1,72 @@
+import { isVecAvailable } from "./db.js";
+let extractor = null;
+const DEFAULT_MODEL = "nomic-ai/nomic-embed-text-v1.5";
+const NOMIC_DIMS = 768;
+const MINILM_DIMS = 384;
+export function getModelId() {
+    return process.env.AO_MEMORY_MODEL || DEFAULT_MODEL;
+}
+function isNomicModel() {
+    return getModelId().includes("nomic");
+}
+export function getDimensions() {
+    return isNomicModel() ? NOMIC_DIMS : MINILM_DIMS;
+}
+async function getExtractor() {
+    if (extractor)
+        return extractor;
+    const { pipeline } = await import("@huggingface/transformers");
+    const model = getModelId();
+    console.error(`[ao-memory] Loading embedding model: ${model}`);
+    extractor = await pipeline("feature-extraction", model, { dtype: "q8" });
+    console.error(`[ao-memory] Model ready (${getDimensions()}d)`);
+    return extractor;
+}
+export async function embed(text, isQuery = false) {
+    const ext = await getExtractor();
+    const input = isNomicModel()
+        ? (isQuery ? `search_query: ${text}` : `search_document: ${text}`)
+        : text;
+    const output = await ext(input, { pooling: "mean", normalize: true });
+    return new Float32Array(output.data);
+}
+export function storeVector(db, table, rowid, embedding) {
+    if (!isVecAvailable())
+        return;
+    db.prepare(`INSERT OR REPLACE INTO ${table}(rowid, embedding) VALUES (?, ?)`).run(BigInt(rowid), Buffer.from(embedding.buffer));
+}
+export function deleteVector(db, table, rowid) {
+    if (!isVecAvailable())
+        return;
+    db.prepare(`DELETE FROM ${table} WHERE rowid = ?`).run(BigInt(rowid));
+}
+export function searchVectors(db, table, queryEmbedding, limit = 20) {
+    if (!isVecAvailable())
+        return [];
+    return db.prepare(`SELECT rowid, distance FROM ${table} WHERE embedding MATCH ? ORDER BY distance LIMIT ?`).all(Buffer.from(queryEmbedding.buffer), limit);
+}
+export function hybridSearch(db, ftsTable, vecTable, queryText, queryEmbedding, limit = 10, alpha = 0.5) {
+    const RRF_K = 60;
+    const scores = new Map();
+    // FTS5 keyword results
+    try {
+        const ftsResults = db.prepare(`SELECT rowid FROM ${ftsTable} WHERE ${ftsTable} MATCH ? LIMIT 30`).all(queryText);
+        ftsResults.forEach((r, i) => {
+            const id = Number(r.rowid);
+            scores.set(id, (scores.get(id) || 0) + (1 - alpha) * (1 / (RRF_K + i + 1)));
+        });
+    }
+    catch { }
+    // Vector similarity results
+    if (isVecAvailable()) {
+        const vecResults = searchVectors(db, vecTable, queryEmbedding, 30);
+        vecResults.forEach((r, i) => {
+            const id = Number(r.rowid);
+            scores.set(id, (scores.get(id) || 0) + alpha * (1 / (RRF_K + i + 1)));
+        });
+    }
+    return [...scores.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, limit)
+        .map(([rowid, score]) => ({ rowid, score }));
+}

package/dist/schema.sql

@@ -0,0 +1,194 @@
+PRAGMA journal_mode = WAL;
+PRAGMA foreign_keys = ON;
+
+-- ============================================================
+-- 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,
+  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
+);
+
+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;
+
+-- ============================================================
+-- 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 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,
+  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,
+  UNIQUE(source_entity_id, relation_type, target_entity_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 INDEX IF NOT EXISTS idx_ep_session ON episodes(session_id);
+CREATE INDEX IF NOT EXISTS idx_ep_ns      ON episodes(namespace);
+
+-- 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 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;
+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;
+
+-- ============================================================
+-- 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 INDEX IF NOT EXISTS idx_sum_ns ON summaries(namespace, agent_role);

package/dist/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/server.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+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, initVec, errorResult } from "./db.js";
+import { getDimensions } from "./embeddings.js";
+import { storeTools, handleStore } from "./tools/store.js";
+import { recallTools, handleRecall } from "./tools/recall.js";
+import { statsTools, handleStats } from "./tools/stats.js";
+import { contextTools, handleContext } from "./tools/context.js";
+import { summarizeTools, handleSummarize } from "./tools/summarize.js";
+import { documentTools, handleDocuments } from "./tools/documents.js";
+import { knowledgeTools, handleKnowledge } from "./tools/knowledge.js";
+import { episodeTools, handleEpisodes } from "./tools/episodes.js";
+// Parse CLI args
+const args = process.argv.slice(2);
+let dbPath;
+for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--db" && args[i + 1])
+        dbPath = args[++i];
+}
+const db = initDb(resolveDbPath(dbPath));
+await initVec(db, getDimensions());
+const allTools = [
+    ...storeTools,
+    ...recallTools,
+    ...documentTools,
+    ...knowledgeTools,
+    ...episodeTools,
+    ...contextTools,
+    ...summarizeTools,
+    ...statsTools,
+];
+const handlers = [
+    handleStore, handleRecall, handleDocuments, handleKnowledge,
+    handleEpisodes, handleContext, handleSummarize, handleStats,
+];
+const server = new Server({ name: "ao-memory-mcp", version: "2.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 !== null) {
+            // Handle async results (embed operations)
+            if (result instanceof Promise)
+                return await result;
+            return result;
+        }
+    }
+    return errorResult(`Unknown tool: ${name}`);
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/tools/context.d.ts

@@ -0,0 +1,29 @@
+import type Database from "better-sqlite3";
+export declare const contextTools: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            namespace: {
+                type: string;
+                description: string;
+            };
+            agent_role: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+}[];
+export declare function handleContext(db: Database.Database, name: string, args: any): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};

package/dist/tools/context.js

@@ -0,0 +1,88 @@
+import { jsonResult } from "../db.js";
+export const contextTools = [
+    {
+        name: "memory.context",
+        description: "Agent boot tool — call at the start of each run to load all relevant memory. Returns recent memories, active decisions, related entities, episode summaries, and document count. Scoped by namespace and agent role.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                namespace: { type: "string", description: "Project/scope to load context for" },
+                agent_role: { type: "string", description: "Agent role requesting context" },
+                limit: { type: "number", description: "Max entries per section (default 10)" },
+            },
+            required: ["namespace"],
+        },
+    },
+];
+export function handleContext(db, name, args) {
+    if (name === "memory.context")
+        return memoryContext(db, args);
+    return null;
+}
+function memoryContext(db, args) {
+    const { namespace, agent_role } = args;
+    const limit = args.limit || 10;
+    // Recent memories for this agent+namespace
+    const recentMemories = db.prepare(`
+    SELECT * FROM memories
+    WHERE namespace = ? ${agent_role ? "AND agent_role = ?" : ""}
+      AND status = 'active'
+    ORDER BY occurred_at DESC LIMIT ?
+  `).all(...(agent_role ? [namespace, agent_role, limit] : [namespace, limit]));
+    // Active semantic memories (facts/knowledge) for this namespace
+    const knowledge = db.prepare(`
+    SELECT * FROM memories
+    WHERE namespace = ? AND memory_type = 'semantic' AND status = 'active'
+    ORDER BY confidence DESC, access_count DESC LIMIT ?
+  `).all(namespace, limit);
+    // Active procedural memories (how-to) for this namespace
+    const procedures = db.prepare(`
+    SELECT * FROM memories
+    WHERE namespace = ? AND memory_type = 'procedural' AND status = 'active'
+    ORDER BY access_count DESC LIMIT ?
+  `).all(namespace, limit);
+    // Related entities
+    const entities = db.prepare(`
+    SELECT e.*, (SELECT COUNT(*) FROM relations r WHERE r.source_entity_id = e.id OR r.target_entity_id = e.id) as relation_count
+    FROM entities e
+    WHERE e.namespace = ?
+    ORDER BY relation_count DESC LIMIT ?
+  `).all(namespace, limit);
+    // Recent episode summaries
+    const episodeSummaries = db.prepare(`
+    SELECT DISTINCT session_id, summary, MAX(created_at) as last_at
+    FROM episodes
+    WHERE namespace = ? AND summary IS NOT NULL
+    GROUP BY session_id
+    ORDER BY last_at DESC LIMIT 5
+  `).all(namespace);
+    // Document count
+    const docCount = db.prepare("SELECT COUNT(*) as count FROM documents WHERE namespace = ?").get(namespace).count;
+    // Global memories (cross-project)
+    const globalMemories = db.prepare(`
+    SELECT * FROM memories
+    WHERE scope = 'global' AND status = 'active'
+    ORDER BY confidence DESC, occurred_at DESC LIMIT 5
+  `).all();
+    // Check if summarization needed
+    const threeDaysAgo = new Date(Date.now() - 3 * 24 * 60 * 60 * 1000).toISOString();
+    const staleCount = db.prepare(`
+    SELECT COUNT(*) as count FROM memories
+    WHERE namespace = ? ${agent_role ? "AND agent_role = ?" : ""}
+      AND status = 'active' AND occurred_at < ?
+  `).get(...(agent_role ? [namespace, agent_role, threeDaysAgo] : [namespace, threeDaysAgo])).count;
+    // Stats
+    const totalMemories = db.prepare("SELECT COUNT(*) as count FROM memories WHERE namespace = ? AND status = 'active'").get(namespace).count;
+    return jsonResult({
+        recent_memories: recentMemories,
+        knowledge,
+        procedures,
+        entities,
+        episode_summaries: episodeSummaries,
+        global_memories: globalMemories,
+        document_count: docCount,
+        total_active_memories: totalMemories,
+        summarization_needed: staleCount >= 20,
+        stale_entry_count: staleCount,
+    });
+}