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

package/src/tools/store.ts

@@ -1,115 +1,122 @@
 import type Database from "better-sqlite3";
-import { contentHash, now, jsonResult, errorResult } from "../db.ts";
+import { contentHash, now, jsonResult, errorResult, touchAccess } from "../db.ts";
+import { embed, storeVector, deleteVector } from "../embeddings.ts";
 
 export const storeTools = [
   {
-    name: "memory.store",
+    name: "memory.remember",
     description:
-      "Store a new memory entry. Deduplicates via content hash — returns existing entry if duplicate detected.",
+      "Store a new memory. Automatically embeds for semantic search. Deduplicates via content hash. Supports semantic (facts/knowledge), episodic (events/history), and procedural (how-to/workflows) types.",
     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)" },
+        memory_type: { type: "string", enum: ["semantic", "episodic", "procedural"], description: "Type: semantic (facts), episodic (events), procedural (how-to)" },
+        title: { type: "string", description: "Short summary" },
+        content: { type: "string", description: "Full content (markdown)" },
+        scope: { type: "string", enum: ["global", "user", "project", "session"], description: "Scope (default: project)" },
+        namespace: { type: "string", description: "Scope identifier — project name, user id, session id" },
+        agent_role: { type: "string", description: "Agent role storing this memory" },
+        task_id: { type: "string", description: "Task ID reference" },
+        pr_number: { type: "number", description: "PR number" },
+        run_id: { type: "string", description: "Run identifier" },
+        tags: { type: "array", items: { type: "string" }, description: "Tags" },
+        metadata: { type: "object", description: "Custom metadata" },
+        confidence: { type: "number", description: "Confidence score 0.0-1.0 (default 1.0)" },
+        occurred_at: { type: "string", description: "ISO 8601 date (default: now)" },
       },
-      required: ["entry_type", "agent_role", "project", "title", "body"],
+      required: ["memory_type", "title", "content"],
     },
   },
   {
     name: "memory.update",
-    description: "Update an existing memory entry by ID.",
+    description: "Update an existing memory 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" },
+        id: { type: "number", description: "Memory ID" },
+        title: { type: "string" },
+        content: { type: "string" },
+        status: { type: "string", enum: ["active", "summarized", "archived"] },
+        confidence: { type: "number" },
+        tags: { type: "array", items: { type: "string" } },
+        metadata: { type: "object" },
+        superseded_by: { type: "number", description: "ID of memory that replaces this one" },
       },
       required: ["id"],
     },
   },
   {
-    name: "memory.archive",
-    description: "Bulk archive entries by filter. At least one filter required.",
+    name: "memory.forget",
+    description: "Archive memories. Soft delete — they remain queryable with status filter.",
     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" },
+        ids: { type: "array", items: { type: "number" }, description: "Specific IDs to archive" },
+        agent_role: { type: "string", description: "Archive all for this role" },
+        namespace: { type: "string", description: "Archive all in this namespace" },
+        before: { type: "string", description: "Archive entries 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.remember") return memoryRemember(db, args);
   if (name === "memory.update") return memoryUpdate(db, args);
-  if (name === "memory.archive") return memoryArchive(db, args);
+  if (name === "memory.forget") return memoryForget(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);
+async function memoryRemember(db: Database.Database, args: any) {
+  const { memory_type, title, content } = args;
+  const scope = args.scope || "project";
+  const hash = contentHash(memory_type, scope, args.namespace || "", title, content);
 
-  const existing = db.prepare("SELECT id FROM memory_entries WHERE content_hash = ?").get(hash) as any;
+  const existing = db.prepare("SELECT id FROM memories WHERE content_hash = ?").get(hash) as any;
   if (existing) {
+    touchAccess(db, existing.id);
     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', ?, ?, ?, ?, ?, ?)
+    INSERT INTO memories (memory_type, scope, namespace, agent_role, title, content, task_id, pr_number, run_id, status, confidence, 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
+    memory_type, scope, args.namespace || null, args.agent_role || null,
+    title, content,
+    args.task_id || null, args.pr_number || null, args.run_id || null,
+    args.confidence ?? 1.0,
+    JSON.stringify(args.tags || []), JSON.stringify(args.metadata || {}),
+    ts, args.occurred_at || ts, ts, hash
   );
 
-  return jsonResult({ id: result.lastInsertRowid, created: true });
+  const id = Number(result.lastInsertRowid);
+
+  // Embed asynchronously
+  try {
+    const embedding = await embed(`${title}\n${content}`);
+    storeVector(db, "vec_memories", id, embedding);
+  } catch (e) {
+    console.error(`[ao-memory] Embedding failed for memory ${id}:`, e);
+  }
+
+  return jsonResult({ id, created: true });
 }
 
-function memoryUpdate(db: Database.Database, args: any) {
+async 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 entry = db.prepare("SELECT * FROM memories WHERE id = ?").get(id) as any;
+  if (!entry) return errorResult(`Memory ${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.content !== undefined) { sets.push("content = ?"); vals.push(updates.content); }
+  if (updates.status !== undefined) { sets.push("status = ?"); vals.push(updates.status); }
+  if (updates.confidence !== undefined) { sets.push("confidence = ?"); vals.push(updates.confidence); }
+  if (updates.superseded_by !== undefined) { sets.push("superseded_by = ?"); vals.push(updates.superseded_by); }
   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 };
@@ -117,44 +124,45 @@ function memoryUpdate(db: Database.Database, args: any) {
   }
 
   if (sets.length === 0) return errorResult("No fields to update");
-
   sets.push("updated_at = ?"); vals.push(now());
 
-  if (updates.title !== undefined || updates.body !== undefined) {
+  if (updates.title !== undefined || updates.content !== 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);
+    const newContent = updates.content || entry.content;
+    const hash = contentHash(entry.memory_type, entry.scope, entry.namespace || "", newTitle, newContent);
     sets.push("content_hash = ?"); vals.push(hash);
+
+    // Re-embed
+    try {
+      const embedding = await embed(`${newTitle}\n${newContent}`);
+      storeVector(db, "vec_memories", id, embedding);
+    } catch {}
   }
 
   vals.push(id);
-  db.prepare(`UPDATE memory_entries SET ${sets.join(", ")} WHERE id = ?`).run(...vals);
+  db.prepare(`UPDATE memories 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) {
+function memoryForget(db: Database.Database, args: any) {
+  const { ids, agent_role, namespace, before } = args;
+  if (!ids && !agent_role && !namespace && !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 (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 (namespace) { conditions.push("namespace = ?"); vals.push(namespace); }
   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);
+    `UPDATE memories SET status = 'archived', updated_at = ? WHERE ${conditions.join(" AND ")}`
+  ).run(ts, ...vals);
 
   return jsonResult({ archived_count: result.changes });
 }

package/src/tools/summarize.ts

@@ -5,31 +5,29 @@ 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.",
+      "Create a summary of memory entries. Agent provides the summary text. Server creates the summary record and transitions entries to 'summarized'.",
     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)" },
+        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: ["agent_role", "project", "summary_title", "summary_body"],
+      required: ["namespace", "summary_title", "summary_body"],
     },
   },
   {
     name: "memory.cleanup",
-    description:
-      "Identify entries needing summarization or archive old summarized entries. Use dry_run to preview without changes.",
+    description: "Identify stale entries needing summarization or archive old summarized entries.",
     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)" },
+        min_entries: { type: "number", description: "Min entries per scope to trigger (default 10)" },
+        dry_run: { type: "boolean", description: "Preview only (default true)" },
       },
     },
   },
@@ -42,58 +40,44 @@ export function handleSummarize(db: Database.Database, name: string, args: any)
 }
 
 function memorySummarize(db: Database.Database, args: any) {
-  const { agent_role, project, entry_type, summary_title, summary_body } = args;
+  const { namespace, agent_role, summary_title, summary_body } = args;
 
-  const summarize = db.transaction(() => {
+  const result = 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 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 memory_entries WHERE ${conditions.join(" AND ")} ORDER BY occurred_at ASC`
+        `SELECT id FROM memories WHERE ${conditions.join(" AND ")}`
       ).all(...vals) as any[];
       entryIds = rows.map(r => r.id);
     }
 
-    if (entryIds.length === 0) {
-      return { error: "No entries to summarize" };
-    }
+    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(",")})`
+    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) 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(",");
+    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 memory_entries SET status = 'summarized', updated_at = ? WHERE id IN (${placeholders})`
+      `UPDATE memories SET status = 'summarized', updated_at = ? WHERE id IN (${entryIds.map(() => "?").join(",")})`
     ).run(ts, ...entryIds);
 
-    return {
-      summary_id: result.lastInsertRowid,
-      entries_summarized: entryIds.length,
-      date_from: entries.date_from,
-      date_to: entries.date_to,
-    };
-  });
+    return { summary_id: Number(sumResult.lastInsertRowid), entries_summarized: entryIds.length };
+  })();
 
-  const result = summarize();
   if ((result as any).error) return errorResult((result as any).error);
   return jsonResult(result);
 }
@@ -105,36 +89,26 @@ function memoryCleanup(db: Database.Database, args: any) {
 
   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,
+    SELECT namespace, agent_role, 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
+    FROM memories WHERE status = 'active' AND occurred_at < ?
+    GROUP BY namespace, agent_role
     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;
+  const needsArchival = (db.prepare(
+    "SELECT COUNT(*) as c FROM memories WHERE status = 'summarized' AND updated_at < ?"
+  ).get(archivalCutoff) as any).c;
 
+  let archived = 0;
   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);
+    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: dryRun ? 0 : needsArchival,
-    dry_run: dryRun,
-  });
+  return jsonResult({ needs_summarization: needsSummarization, needs_archival: needsArchival, archived, dry_run: dryRun });
 }

package/src/tools/patterns.ts

@@ -1,165 +0,0 @@
-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 });
-}