@jcyamacho/agent-memory 0.0.11 → 0.0.13

package/README.md

@@ -3,10 +3,12 @@
 Persistent memory for MCP-powered coding agents.
 
 `agent-memory` is a stdio MCP server that gives your LLM durable memory backed
-by SQLite. It exposes two tools:
+by SQLite. It exposes four tools:
 
 - `remember` -> save facts, decisions, preferences, and project context
 - `recall` -> retrieve the most relevant memories later
+- `revise` -> update an existing memory when it becomes outdated
+- `forget` -> delete a memory that is no longer relevant
 
 Use it when your agent should remember preferences, project facts, and prior
 decisions across sessions.
@@ -66,7 +68,10 @@ Optional LLM instructions to reinforce the MCP's built-in guidance:
 Use `recall` at the start of every conversation and again mid-task before
 making design choices or picking conventions. Use `remember` when the user
 corrects your approach, a key decision is established, or you learn project
-context not obvious from the code. Always pass workspace.
+context not obvious from the code. Before saving, recall to check whether a
+memory about the same fact already exists -- if so, use `revise` to update
+it instead of creating a duplicate. Use `forget` to remove memories that
+are wrong or no longer relevant. Always pass workspace.
 ```
 
 ## What It Stores
@@ -92,8 +97,7 @@ Opens at `http://localhost:6580`. Use `--port` to change:
 npx -y @jcyamacho/agent-memory --ui --port 9090
 ```
 
-The web UI uses the same database as the MCP server. LLM tools remain
-append-only; the web UI is the only way to edit or delete memories.
+The web UI uses the same database as the MCP server.
 
 ## Tools
 
@@ -127,6 +131,31 @@ Output:
 
 - `results[]` with `id`, `content`, `score`, `workspace`, and `updated_at`
 
+### `revise`
+
+Update the content of an existing memory.
+
+Inputs:
+
+- `id` -> the memory id from a previous recall result
+- `content` -> replacement content for the memory
+
+Output:
+
+- `id`, `updated_at`
+
+### `forget`
+
+Permanently delete a memory.
+
+Inputs:
+
+- `id` -> the memory id from a previous recall result
+
+Output:
+
+- `id`, `deleted`
+
 ## How Ranking Works
 
 `recall` uses a multi-signal ranking system to surface the most relevant

package/dist/index.js

@@ -12464,7 +12464,7 @@ class StdioServerTransport {
   }
 }
 // package.json
-var version2 = "0.0.11";
+var version2 = "0.0.13";
 
 // src/config.ts
 import { homedir } from "node:os";
@@ -12472,7 +12472,7 @@ import { join } from "node:path";
 import { parseArgs } from "node:util";
 var AGENT_MEMORY_DB_PATH_ENV = "AGENT_MEMORY_DB_PATH";
 var DEFAULT_UI_PORT = 6580;
-var resolveConfig = (environment = process.env, argv = process.argv.slice(2)) => {
+function resolveConfig(environment = process.env, argv = process.argv.slice(2)) {
   const { values } = parseArgs({
     args: argv,
     options: {
@@ -12486,7 +12486,7 @@ var resolveConfig = (environment = process.env, argv = process.argv.slice(2)) =>
     uiMode: Boolean(values.ui),
     uiPort: Number(values.port) || DEFAULT_UI_PORT
   };
-};
+}
 
 // node_modules/zod/v3/helpers/util.js
 var util;
@@ -19895,9 +19895,6 @@ var EMPTY_COMPLETION_RESULT = {
   }
 };
 
-// src/memory-service.ts
-import { randomUUID } from "node:crypto";
-
 // src/errors.ts
 class MemoryError extends Error {
   code;
@@ -19929,39 +19926,152 @@ class PersistenceError extends MemoryError {
   }
 }
 
+// src/mcp/tools/shared.ts
+function toMcpError(error2) {
+  if (error2 instanceof McpError) {
+    return error2;
+  }
+  if (error2 instanceof MemoryError) {
+    if (error2.code === "VALIDATION_ERROR" || error2.code === "NOT_FOUND") {
+      return new McpError(ErrorCode.InvalidParams, error2.message);
+    }
+    return new McpError(ErrorCode.InternalError, error2.message);
+  }
+  const message = error2 instanceof Error ? error2.message : "Unknown server error.";
+  return new McpError(ErrorCode.InternalError, message);
+}
+var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function parseOptionalDate(value, fieldName) {
+  if (!value) {
+    return;
+  }
+  const date4 = new Date(value);
+  if (Number.isNaN(date4.getTime())) {
+    throw new MemoryError("VALIDATION_ERROR", `${fieldName} must be a valid ISO 8601 datetime.`);
+  }
+  return date4;
+}
+
+// src/mcp/tools/forget.ts
+var forgetInputSchema = {
+  id: string2().describe("The id of the memory to delete. Use the id returned by a previous recall result.")
+};
+function registerForgetTool(server, memory) {
+  server.registerTool("forget", {
+    description: "Permanently delete a memory that is wrong, obsolete, or no longer relevant. Pass the memory id from a previous recall result.",
+    inputSchema: forgetInputSchema
+  }, async ({ id }) => {
+    try {
+      await memory.delete({ id });
+      return {
+        content: [{ type: "text", text: `<memory id="${id.trim()}" deleted="true" />` }]
+      };
+    } catch (error2) {
+      throw toMcpError(error2);
+    }
+  });
+}
+
 // src/memory.ts
 var toNormalizedScore = (value) => value;
 
-// src/memory-service.ts
-var DEFAULT_LIMIT = 15;
-var MAX_LIMIT = 50;
-var RECALL_CANDIDATE_LIMIT_MULTIPLIER = 3;
+// src/ranking.ts
 var RETRIEVAL_SCORE_WEIGHT = 8;
 var WORKSPACE_MATCH_WEIGHT = 4;
 var RECENCY_WEIGHT = 1;
 var MAX_COMPOSITE_SCORE = RETRIEVAL_SCORE_WEIGHT + WORKSPACE_MATCH_WEIGHT + RECENCY_WEIGHT;
 var GLOBAL_WORKSPACE_SCORE = 0.5;
 var SIBLING_WORKSPACE_SCORE = 0.25;
+function rerankSearchResults(results, workspace) {
+  if (results.length <= 1) {
+    return results;
+  }
+  const normalizedQueryWs = workspace ? normalizeWorkspacePath(workspace) : undefined;
+  const updatedAtTimes = results.map((result) => result.updatedAt.getTime());
+  const minUpdatedAt = Math.min(...updatedAtTimes);
+  const maxUpdatedAt = Math.max(...updatedAtTimes);
+  return results.map((result) => {
+    const workspaceScore = computeWorkspaceScore(result.workspace, normalizedQueryWs);
+    const recencyScore = maxUpdatedAt === minUpdatedAt ? 0 : (result.updatedAt.getTime() - minUpdatedAt) / (maxUpdatedAt - minUpdatedAt);
+    const combinedScore = (result.score * RETRIEVAL_SCORE_WEIGHT + workspaceScore * WORKSPACE_MATCH_WEIGHT + recencyScore * RECENCY_WEIGHT) / MAX_COMPOSITE_SCORE;
+    return {
+      ...result,
+      score: toNormalizedScore(combinedScore)
+    };
+  }).sort((a, b) => b.score - a.score);
+}
+function normalizeWorkspacePath(value) {
+  return value.trim().replaceAll("\\", "/").replace(/\/+/g, "/").split("/").filter(Boolean).join("/");
+}
+function computeWorkspaceScore(memoryWs, queryWs) {
+  if (!queryWs) {
+    return 0;
+  }
+  if (!memoryWs) {
+    return GLOBAL_WORKSPACE_SCORE;
+  }
+  const normalizedMemoryWs = normalizeWorkspacePath(memoryWs);
+  if (normalizedMemoryWs === queryWs) {
+    return 1;
+  }
+  const queryLastSlashIndex = queryWs.lastIndexOf("/");
+  const memoryLastSlashIndex = normalizedMemoryWs.lastIndexOf("/");
+  if (queryLastSlashIndex <= 0 || memoryLastSlashIndex <= 0) {
+    return 0;
+  }
+  const queryParent = queryWs.slice(0, queryLastSlashIndex);
+  const memoryParent = normalizedMemoryWs.slice(0, memoryLastSlashIndex);
+  return memoryParent === queryParent ? SIBLING_WORKSPACE_SCORE : 0;
+}
+
+// src/memory-service.ts
+var DEFAULT_RECALL_LIMIT = 15;
+var MAX_RECALL_LIMIT = 50;
+var RECALL_CANDIDATE_LIMIT_MULTIPLIER = 3;
+var DEFAULT_LIST_LIMIT = 15;
+var MAX_LIST_LIMIT = 100;
 
 class MemoryService {
   repository;
   constructor(repository) {
     this.repository = repository;
   }
-  async save(input) {
+  async create(input) {
     const content = input.content.trim();
     if (!content) {
       throw new ValidationError("Memory content is required.");
     }
-    const now = new Date;
-    const memory = {
-      id: randomUUID(),
+    return this.repository.create({
       content,
-      workspace: normalizeOptionalString(input.workspace),
-      createdAt: now,
-      updatedAt: now
-    };
-    return this.repository.save(memory);
+      workspace: normalizeOptionalString(input.workspace)
+    });
+  }
+  async update(input) {
+    const content = input.content.trim();
+    if (!content)
+      throw new ValidationError("Memory content is required.");
+    return this.repository.update({ id: input.id, content });
+  }
+  async delete(input) {
+    const id = input.id.trim();
+    if (!id)
+      throw new ValidationError("Memory id is required.");
+    return this.repository.delete({ id });
+  }
+  async get(id) {
+    return this.repository.get(id);
+  }
+  async list(input) {
+    const workspace = normalizeOptionalString(input.workspace);
+    return this.repository.list({
+      workspace,
+      workspaceIsNull: workspace ? false : Boolean(input.workspaceIsNull),
+      offset: normalizeOffset(input.offset),
+      limit: normalizeListLimit(input.limit)
+    });
+  }
+  async listWorkspaces() {
+    return this.repository.listWorkspaces();
   }
   async search(input) {
     const terms = normalizeTerms(input.terms);
@@ -19977,19 +20087,27 @@ class MemoryService {
       updatedBefore: input.updatedBefore
     };
     const results = await this.repository.search(normalizedQuery);
-    const reranked = rerankSearchResults(results, workspace);
-    return reranked.sort((a, b) => b.score - a.score).slice(0, requestedLimit);
+    return rerankSearchResults(results, workspace).slice(0, requestedLimit);
   }
 }
 function normalizeLimit(value) {
   if (value === undefined) {
-    return DEFAULT_LIMIT;
+    return DEFAULT_RECALL_LIMIT;
   }
-  if (!Number.isInteger(value) || value < 1 || value > MAX_LIMIT) {
-    throw new ValidationError(`Limit must be an integer between 1 and ${MAX_LIMIT}.`);
+  if (!Number.isInteger(value) || value < 1 || value > MAX_RECALL_LIMIT) {
+    throw new ValidationError(`Limit must be an integer between 1 and ${MAX_RECALL_LIMIT}.`);
   }
   return value;
 }
+function normalizeOffset(value) {
+  return Number.isInteger(value) && value && value > 0 ? value : 0;
+}
+function normalizeListLimit(value) {
+  if (!Number.isInteger(value) || value === undefined) {
+    return DEFAULT_LIST_LIMIT;
+  }
+  return Math.min(Math.max(value, 1), MAX_LIST_LIMIT);
+}
 function normalizeOptionalString(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : undefined;
@@ -19998,96 +20116,29 @@ function normalizeTerms(terms) {
   const normalizedTerms = terms.map((term) => term.trim()).filter(Boolean);
   return [...new Set(normalizedTerms)];
 }
-function normalizeWorkspacePath(value) {
-  return value.trim().replaceAll("\\", "/").replace(/\/+/g, "/").split("/").filter(Boolean).join("/");
-}
-function computeWorkspaceScore(memoryWs, queryWs) {
-  if (!queryWs) {
-    return 0;
-  }
-  if (!memoryWs) {
-    return GLOBAL_WORKSPACE_SCORE;
-  }
-  const normalizedMemoryWs = normalizeWorkspacePath(memoryWs);
-  if (normalizedMemoryWs === queryWs) {
-    return 1;
-  }
-  const queryLastSlashIndex = queryWs.lastIndexOf("/");
-  const memoryLastSlashIndex = normalizedMemoryWs.lastIndexOf("/");
-  if (queryLastSlashIndex <= 0 || memoryLastSlashIndex <= 0) {
-    return 0;
-  }
-  const queryParent = queryWs.slice(0, queryLastSlashIndex);
-  const memoryParent = normalizedMemoryWs.slice(0, memoryLastSlashIndex);
-  return memoryParent === queryParent ? SIBLING_WORKSPACE_SCORE : 0;
-}
-function rerankSearchResults(results, workspace) {
-  if (results.length <= 1) {
-    return results;
-  }
-  const normalizedQueryWs = workspace ? normalizeWorkspacePath(workspace) : undefined;
-  const updatedAtTimes = results.map((result) => result.updatedAt.getTime());
-  const minUpdatedAt = Math.min(...updatedAtTimes);
-  const maxUpdatedAt = Math.max(...updatedAtTimes);
-  return results.map((result) => {
-    const workspaceScore = computeWorkspaceScore(result.workspace, normalizedQueryWs);
-    const recencyScore = maxUpdatedAt === minUpdatedAt ? 0 : (result.updatedAt.getTime() - minUpdatedAt) / (maxUpdatedAt - minUpdatedAt);
-    const combinedScore = (result.score * RETRIEVAL_SCORE_WEIGHT + workspaceScore * WORKSPACE_MATCH_WEIGHT + recencyScore * RECENCY_WEIGHT) / MAX_COMPOSITE_SCORE;
-    return {
-      ...result,
-      score: toNormalizedScore(combinedScore)
-    };
-  });
-}
 
-// src/tools/shared.ts
-var toMcpError = (error2) => {
-  if (error2 instanceof McpError) {
-    return error2;
-  }
-  if (error2 instanceof MemoryError) {
-    if (error2.code === "VALIDATION_ERROR") {
-      return new McpError(ErrorCode.InvalidParams, error2.message);
-    }
-    return new McpError(ErrorCode.InternalError, error2.message);
-  }
-  const message = error2 instanceof Error ? error2.message : "Unknown server error.";
-  return new McpError(ErrorCode.InternalError, message);
-};
-var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-var parseOptionalDate = (value, fieldName) => {
-  if (!value) {
-    return;
-  }
-  const date4 = new Date(value);
-  if (Number.isNaN(date4.getTime())) {
-    throw new MemoryError("VALIDATION_ERROR", `${fieldName} must be a valid ISO 8601 datetime.`);
-  }
-  return date4;
-};
-
-// src/tools/recall.ts
+// src/mcp/tools/recall.ts
 var recallInputSchema = {
   terms: array(string2()).min(1).describe("Search terms used to find relevant memories. Pass 2-5 short, distinctive items as separate array entries. Be specific: instead of 'preferences' or 'context', name the actual topic -- e.g. 'error handling', 'commit format', 'testing strategy'. Do not repeat the project or workspace name here -- use the workspace parameter for project scoping. Avoid full sentences."),
-  limit: number2().int().min(1).max(MAX_LIMIT).optional().describe("Maximum number of matches to return. Keep this small when you only need the strongest hits."),
+  limit: number2().int().min(1).max(MAX_RECALL_LIMIT).optional().describe("Maximum number of matches to return. Keep this small when you only need the strongest hits."),
   workspace: string2().optional().describe("Always pass the current working directory. Biases ranking toward the active project while still allowing cross-workspace matches. Memories saved without a workspace are treated as global and rank between matching and non-matching results."),
   updated_after: string2().optional().describe("Only return memories updated at or after this ISO 8601 timestamp. Use it when you need to narrow recall to newer context."),
   updated_before: string2().optional().describe("Only return memories updated at or before this ISO 8601 timestamp. Use it when you need to narrow recall to older context.")
 };
-var toMemoryXml = (r) => {
+function toMemoryXml(r) {
   const workspace = r.workspace ? ` workspace="${escapeXml(r.workspace)}"` : "";
   const content = escapeXml(r.content);
   return `<memory id="${r.id}" score="${r.score}"${workspace} updated_at="${r.updatedAt.toISOString()}">
 ${content}
 </memory>`;
-};
-var registerRecallTool = (server, memoryService) => {
+}
+function registerRecallTool(server, memory) {
   server.registerTool("recall", {
     description: "Search memories for prior decisions, corrections, and context that cannot be derived from code or git history. Call at the start of every conversation and again mid-task when you are about to make a design choice, pick a convention, or handle an edge case that the user may have guided before. Always pass workspace.",
     inputSchema: recallInputSchema
   }, async ({ terms, limit, workspace, updated_after, updated_before }) => {
     try {
-      const results = await memoryService.search({
+      const results = await memory.search({
         terms,
         limit,
         workspace,
@@ -20105,51 +20156,82 @@ ${results.map(toMemoryXml).join(`
       throw toMcpError(error2);
     }
   });
-};
+}
 
-// src/tools/remember.ts
+// src/mcp/tools/remember.ts
 var rememberInputSchema = {
   content: string2().describe("The fact, preference, decision, or context to remember. Use a single self-contained sentence or short note. One fact per memory."),
   workspace: string2().optional().describe("Always pass the current working directory to scope this memory to a project. Omit only when the memory applies across all projects (global preference).")
 };
-var registerRememberTool = (server, memoryService) => {
+function registerRememberTool(server, memory) {
   server.registerTool("remember", {
     description: "Save durable context for later recall. Use this when the user corrects your approach, states a preference, a key decision or convention is established, or you learn project context not obvious from the code. Store one concise fact per memory. Do not store secrets, ephemeral task state, or information already in the codebase.",
     inputSchema: rememberInputSchema
   }, async ({ content, workspace }) => {
     try {
-      const memory = await memoryService.save({
+      const savedMemory = await memory.create({
         content,
         workspace
       });
       return {
-        content: [{ type: "text", text: `<memory id="${memory.id}" />` }]
+        content: [{ type: "text", text: `<memory id="${savedMemory.id}" />` }]
       };
     } catch (error2) {
       throw toMcpError(error2);
     }
   });
+}
+
+// src/mcp/tools/revise.ts
+var reviseInputSchema = {
+  id: string2().describe("The id of the memory to update. Use the id returned by a previous recall result."),
+  content: string2().describe("The replacement content for the memory. Use a single self-contained sentence or short note. One fact per memory.")
 };
+function registerReviseTool(server, memory) {
+  server.registerTool("revise", {
+    description: "Update the content of an existing memory. Use when a previously saved memory is outdated or inaccurate and needs correction rather than deletion. Pass the memory id from a previous recall result.",
+    inputSchema: reviseInputSchema
+  }, async ({ id, content }) => {
+    try {
+      const revisedMemory = await memory.update({ id, content });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `<memory id="${revisedMemory.id}" updated_at="${revisedMemory.updatedAt.toISOString()}" />`
+          }
+        ]
+      };
+    } catch (error2) {
+      throw toMcpError(error2);
+    }
+  });
+}
 
-// src/mcp-server.ts
+// src/mcp/server.ts
 var SERVER_INSTRUCTIONS = [
   "Stores decisions, corrections, and context that cannot be derived from code or git history.",
   "Use `recall` at the start of every conversation and again mid-task before making design choices or picking conventions the user may have guided before.",
   "Use `remember` when the user corrects your approach, states a preference, a key decision is established, or you learn project context not obvious from the code.",
+  "Before saving a new memory, recall to check whether a memory about the same fact already exists. If so, use `revise` to update it instead of creating a duplicate.",
+  "Use `revise` when a previously saved memory is outdated or inaccurate and needs correction rather than deletion.",
+  "Use `forget` to remove memories that are wrong, obsolete, or no longer relevant.",
   "Always pass workspace (the current working directory) to scope results to the active project.",
   "Omit workspace only when saving a memory that applies across all projects."
 ].join(" ");
-var createMcpServer = (memoryService, version3) => {
+function createMcpServer(memory, version3) {
   const server = new McpServer({
     name: "agent-memory",
     version: version3
   }, {
     instructions: SERVER_INSTRUCTIONS
   });
-  registerRememberTool(server, memoryService);
-  registerRecallTool(server, memoryService);
+  registerRememberTool(server, memory);
+  registerRecallTool(server, memory);
+  registerReviseTool(server, memory);
+  registerForgetTool(server, memory);
   return server;
-};
+}
 
 // src/sqlite-db.ts
 import { mkdirSync } from "node:fs";
@@ -20189,7 +20271,7 @@ var MEMORY_SCHEMA = `
     INSERT INTO memories_fts(rowid, content) VALUES (new.rowid, new.content);
   END;
 `;
-var openMemoryDatabase = (databasePath) => {
+function openMemoryDatabase(databasePath) {
   try {
     mkdirSync(dirname(databasePath), { recursive: true });
     const database = new Database(databasePath);
@@ -20200,8 +20282,8 @@ var openMemoryDatabase = (databasePath) => {
       cause: error2
     });
   }
-};
-var initializeMemoryDatabase = (database) => {
+}
+function initializeMemoryDatabase(database) {
   if (database.pragma) {
     database.pragma("journal_mode = WAL");
     database.pragma("synchronous = NORMAL");
@@ -20214,13 +20296,17 @@ var initializeMemoryDatabase = (database) => {
     database.exec("PRAGMA busy_timeout = 5000");
   }
   database.exec(MEMORY_SCHEMA);
-};
+}
+
+// src/sqlite-memory-repository.ts
+import { randomUUID } from "node:crypto";
+var DEFAULT_SEARCH_LIMIT = 15;
+var DEFAULT_LIST_LIMIT2 = 15;
 
-// src/sqlite-repository.ts
 class SqliteMemoryRepository {
   database;
   insertStatement;
-  findByIdStatement;
+  getStatement;
   updateStatement;
   deleteStatement;
   listWorkspacesStatement;
@@ -20241,13 +20327,21 @@ class SqliteMemoryRepository {
         ?
       )
     `);
-    this.findByIdStatement = database.prepare("SELECT id, content, workspace, created_at, updated_at FROM memories WHERE id = ?");
+    this.getStatement = database.prepare("SELECT id, content, workspace, created_at, updated_at FROM memories WHERE id = ?");
     this.updateStatement = database.prepare("UPDATE memories SET content = ?, updated_at = ? WHERE id = ?");
     this.deleteStatement = database.prepare("DELETE FROM memories WHERE id = ?");
     this.listWorkspacesStatement = database.prepare("SELECT DISTINCT workspace FROM memories WHERE workspace IS NOT NULL ORDER BY workspace");
   }
-  async save(memory) {
+  async create(input) {
     try {
+      const now = new Date;
+      const memory = {
+        id: randomUUID(),
+        content: input.content,
+        workspace: input.workspace,
+        createdAt: now,
+        updatedAt: now
+      };
       this.insertStatement.run(memory.id, memory.content, memory.workspace, memory.createdAt.getTime(), memory.updatedAt.getTime());
       return memory;
     } catch (error2) {
@@ -20257,6 +20351,7 @@ class SqliteMemoryRepository {
   async search(query) {
     try {
       const whereParams = [toFtsQuery(query.terms)];
+      const limit = query.limit ?? DEFAULT_SEARCH_LIMIT;
       const whereClauses = ["memories_fts MATCH ?"];
       if (query.updatedAfter) {
         whereClauses.push("m.updated_at >= ?");
@@ -20266,7 +20361,7 @@ class SqliteMemoryRepository {
         whereClauses.push("m.updated_at <= ?");
         whereParams.push(query.updatedBefore.getTime());
       }
-      const params = [...whereParams, query.limit];
+      const params = [...whereParams, limit];
       const statement = this.database.prepare(`
         SELECT
           m.id,
@@ -20293,19 +20388,21 @@ class SqliteMemoryRepository {
       });
     }
   }
-  async findById(id) {
+  async get(id) {
     try {
-      const rows = this.findByIdStatement.all(id);
+      const rows = this.getStatement.all(id);
       const row = rows[0];
       return row ? toMemoryRecord(row) : undefined;
     } catch (error2) {
       throw new PersistenceError("Failed to find memory.", { cause: error2 });
     }
   }
-  async findAll(options) {
+  async list(options) {
     try {
       const whereClauses = [];
       const params = [];
+      const offset = options.offset ?? 0;
+      const limit = options.limit ?? DEFAULT_LIST_LIMIT2;
       if (options.workspace) {
         whereClauses.push("workspace = ?");
         params.push(options.workspace);
@@ -20313,8 +20410,8 @@ class SqliteMemoryRepository {
         whereClauses.push("workspace IS NULL");
       }
       const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
-      const limit = options.limit + 1;
-      params.push(limit, options.offset);
+      const queryLimit = limit + 1;
+      params.push(queryLimit, offset);
       const statement = this.database.prepare(`
         SELECT id, content, workspace, created_at, updated_at
         FROM memories
@@ -20323,39 +20420,39 @@ class SqliteMemoryRepository {
         LIMIT ? OFFSET ?
       `);
       const rows = statement.all(...params);
-      const hasMore = rows.length > options.limit;
-      const items = (hasMore ? rows.slice(0, options.limit) : rows).map(toMemoryRecord);
+      const hasMore = rows.length > limit;
+      const items = (hasMore ? rows.slice(0, limit) : rows).map(toMemoryRecord);
       return { items, hasMore };
     } catch (error2) {
       throw new PersistenceError("Failed to list memories.", { cause: error2 });
     }
   }
-  async update(id, content) {
+  async update(input) {
     let result;
     try {
       const now = Date.now();
-      result = this.updateStatement.run(content, now, id);
+      result = this.updateStatement.run(input.content, now, input.id);
     } catch (error2) {
       throw new PersistenceError("Failed to update memory.", { cause: error2 });
     }
     if (result.changes === 0) {
-      throw new NotFoundError(`Memory not found: ${id}`);
+      throw new NotFoundError(`Memory not found: ${input.id}`);
     }
-    const memory = await this.findById(id);
+    const memory = await this.get(input.id);
     if (!memory) {
-      throw new NotFoundError(`Memory not found after update: ${id}`);
+      throw new NotFoundError(`Memory not found after update: ${input.id}`);
     }
     return memory;
   }
-  async delete(id) {
+  async delete(input) {
     let result;
     try {
-      result = this.deleteStatement.run(id);
+      result = this.deleteStatement.run(input.id);
     } catch (error2) {
       throw new PersistenceError("Failed to delete memory.", { cause: error2 });
     }
     if (result.changes === 0) {
-      throw new NotFoundError(`Memory not found: ${id}`);
+      throw new NotFoundError(`Memory not found: ${input.id}`);
     }
   }
   async listWorkspaces() {
@@ -20375,16 +20472,13 @@ var toMemoryRecord = (row) => ({
   updatedAt: new Date(row.updated_at)
 });
 var toFtsQuery = (terms) => terms.map(toFtsTerm).join(" OR ");
-var toFtsTerm = (term) => {
+function toFtsTerm(term) {
   const escaped = term.replaceAll('"', '""');
   if (term.includes(" ")) {
     return `"${escaped}"`;
   }
   return `"${escaped}"*`;
-};
-
-// src/ui/server.tsx
-import { randomUUID as randomUUID2 } from "node:crypto";
+}
 
 // node_modules/@hono/node-server/dist/index.mjs
 import { createServer as createServerHTTP } from "http";
@@ -23378,182 +23472,188 @@ function jsxDEV(tag, props, key) {
 }
 
 // src/ui/components/create-form.tsx
-var CreateForm = ({ workspace }) => /* @__PURE__ */ jsxDEV("div", {
-  class: "form-card",
-  children: /* @__PURE__ */ jsxDEV("form", {
-    method: "post",
-    action: "/memories",
-    children: [
-      /* @__PURE__ */ jsxDEV("div", {
-        class: "field",
-        children: [
-          /* @__PURE__ */ jsxDEV("label", {
-            for: "new-content",
-            children: "Content"
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV("textarea", {
-            id: "new-content",
-            name: "content",
-            placeholder: "Fact, preference, decision...",
-            required: true
-          }, undefined, false, undefined, this)
-        ]
-      }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsxDEV("div", {
-        class: "field",
-        children: [
-          /* @__PURE__ */ jsxDEV("label", {
-            for: "new-workspace",
-            children: "Workspace (optional)"
-          }, undefined, false, undefined, this),
-          /* @__PURE__ */ jsxDEV("input", {
-            id: "new-workspace",
-            name: "workspace",
-            type: "text",
-            placeholder: "/path/to/project",
-            value: workspace && workspace !== NO_WORKSPACE_FILTER ? workspace : ""
-          }, undefined, false, undefined, this)
-        ]
-      }, undefined, true, undefined, this),
-      /* @__PURE__ */ jsxDEV("div", {
-        class: "form-actions",
-        children: /* @__PURE__ */ jsxDEV("button", {
-          type: "submit",
-          class: "primary",
-          children: "Save"
-        }, undefined, false, undefined, this)
-      }, undefined, false, undefined, this)
-    ]
-  }, undefined, true, undefined, this)
-}, undefined, false, undefined, this);
-
-// src/ui/components/memory-card.tsx
-var MemoryCard = ({ memory, editing, showWorkspace, returnUrl }) => /* @__PURE__ */ jsxDEV("div", {
-  class: "card",
-  children: [
-    /* @__PURE__ */ jsxDEV("div", {
-      class: "card-header",
-      children: /* @__PURE__ */ jsxDEV("div", {
-        class: "card-meta",
-        children: [
-          showWorkspace && memory.workspace && /* @__PURE__ */ jsxDEV(Fragment, {
-            children: [
-              /* @__PURE__ */ jsxDEV("span", {
-                class: "badge",
-                children: memory.workspace
-              }, undefined, false, undefined, this),
-              " "
-            ]
-          }, undefined, true, undefined, this),
-          memory.updatedAt.toLocaleString()
-        ]
-      }, undefined, true, undefined, this)
-    }, undefined, false, undefined, this),
-    editing ? /* @__PURE__ */ jsxDEV("form", {
+function CreateForm({ workspace }) {
+  return /* @__PURE__ */ jsxDEV("div", {
+    class: "form-card",
+    children: /* @__PURE__ */ jsxDEV("form", {
       method: "post",
-      action: `/memories/${encodeURIComponent(memory.id)}/update`,
+      action: "/memories",
       children: [
-        /* @__PURE__ */ jsxDEV("input", {
-          type: "hidden",
-          name: "returnUrl",
-          value: returnUrl
-        }, undefined, false, undefined, this),
-        /* @__PURE__ */ jsxDEV("textarea", {
-          name: "content",
-          required: true,
-          children: memory.content
-        }, undefined, false, undefined, this),
         /* @__PURE__ */ jsxDEV("div", {
-          class: "card-actions",
+          class: "field",
           children: [
-            /* @__PURE__ */ jsxDEV("button", {
-              type: "submit",
-              class: "primary",
-              children: "Save"
+            /* @__PURE__ */ jsxDEV("label", {
+              for: "new-content",
+              children: "Content"
             }, undefined, false, undefined, this),
-            /* @__PURE__ */ jsxDEV("a", {
-              href: returnUrl,
-              class: "btn",
-              children: "Cancel"
+            /* @__PURE__ */ jsxDEV("textarea", {
+              id: "new-content",
+              name: "content",
+              placeholder: "Fact, preference, decision...",
+              required: true
             }, undefined, false, undefined, this)
           ]
-        }, undefined, true, undefined, this)
-      ]
-    }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV(Fragment, {
-      children: [
-        /* @__PURE__ */ jsxDEV("div", {
-          class: "card-content",
-          children: memory.content
-        }, undefined, false, undefined, this),
+        }, undefined, true, undefined, this),
         /* @__PURE__ */ jsxDEV("div", {
-          class: "card-actions",
+          class: "field",
           children: [
-            /* @__PURE__ */ jsxDEV("a", {
-              href: `${returnUrl}${returnUrl.includes("?") ? "&" : "?"}edit=${encodeURIComponent(memory.id)}`,
-              class: "btn",
-              children: "Edit"
+            /* @__PURE__ */ jsxDEV("label", {
+              for: "new-workspace",
+              children: "Workspace (optional)"
             }, undefined, false, undefined, this),
-            /* @__PURE__ */ jsxDEV("form", {
-              method: "post",
-              action: `/memories/${encodeURIComponent(memory.id)}/delete`,
-              onsubmit: "return confirm('Delete this memory?')",
+            /* @__PURE__ */ jsxDEV("input", {
+              id: "new-workspace",
+              name: "workspace",
+              type: "text",
+              placeholder: "/path/to/project",
+              value: workspace && workspace !== NO_WORKSPACE_FILTER ? workspace : ""
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsxDEV("div", {
+          class: "form-actions",
+          children: /* @__PURE__ */ jsxDEV("button", {
+            type: "submit",
+            class: "primary",
+            children: "Save"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+
+// src/ui/components/memory-card.tsx
+function MemoryCard({ memory, editing, showWorkspace, returnUrl }) {
+  return /* @__PURE__ */ jsxDEV("div", {
+    class: "card",
+    children: [
+      /* @__PURE__ */ jsxDEV("div", {
+        class: "card-header",
+        children: /* @__PURE__ */ jsxDEV("div", {
+          class: "card-meta",
+          children: [
+            showWorkspace && memory.workspace && /* @__PURE__ */ jsxDEV(Fragment, {
               children: [
-                /* @__PURE__ */ jsxDEV("input", {
-                  type: "hidden",
-                  name: "returnUrl",
-                  value: returnUrl
+                /* @__PURE__ */ jsxDEV("span", {
+                  class: "badge",
+                  children: memory.workspace
                 }, undefined, false, undefined, this),
-                /* @__PURE__ */ jsxDEV("button", {
-                  type: "submit",
-                  class: "danger",
-                  children: "Delete"
-                }, undefined, false, undefined, this)
+                " "
               ]
-            }, undefined, true, undefined, this)
+            }, undefined, true, undefined, this),
+            memory.updatedAt.toLocaleString()
           ]
         }, undefined, true, undefined, this)
-      ]
-    }, undefined, true, undefined, this)
-  ]
-}, undefined, true, undefined, this);
+      }, undefined, false, undefined, this),
+      editing ? /* @__PURE__ */ jsxDEV("form", {
+        method: "post",
+        action: `/memories/${encodeURIComponent(memory.id)}/update`,
+        children: [
+          /* @__PURE__ */ jsxDEV("input", {
+            type: "hidden",
+            name: "returnUrl",
+            value: returnUrl
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV("textarea", {
+            name: "content",
+            required: true,
+            children: memory.content
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV("div", {
+            class: "card-actions",
+            children: [
+              /* @__PURE__ */ jsxDEV("button", {
+                type: "submit",
+                class: "primary",
+                children: "Save"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV("a", {
+                href: returnUrl,
+                class: "btn",
+                children: "Cancel"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV(Fragment, {
+        children: [
+          /* @__PURE__ */ jsxDEV("div", {
+            class: "card-content",
+            children: memory.content
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV("div", {
+            class: "card-actions",
+            children: [
+              /* @__PURE__ */ jsxDEV("a", {
+                href: `${returnUrl}${returnUrl.includes("?") ? "&" : "?"}edit=${encodeURIComponent(memory.id)}`,
+                class: "btn",
+                children: "Edit"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV("form", {
+                method: "post",
+                action: `/memories/${encodeURIComponent(memory.id)}/delete`,
+                onsubmit: "return confirm('Delete this memory?')",
+                children: [
+                  /* @__PURE__ */ jsxDEV("input", {
+                    type: "hidden",
+                    name: "returnUrl",
+                    value: returnUrl
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV("button", {
+                    type: "submit",
+                    class: "danger",
+                    children: "Delete"
+                  }, undefined, false, undefined, this)
+                ]
+              }, undefined, true, undefined, this)
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
 
 // src/ui/components/sidebar.tsx
-var Sidebar = ({ workspaces, selected }) => /* @__PURE__ */ jsxDEV("nav", {
-  class: "sidebar",
-  children: [
-    /* @__PURE__ */ jsxDEV("h2", {
-      children: "Workspaces"
-    }, undefined, false, undefined, this),
-    /* @__PURE__ */ jsxDEV("a", {
-      href: "/",
-      class: `sidebar-item all-item${selected === null ? " active" : ""}`,
-      children: "All"
-    }, undefined, false, undefined, this),
-    /* @__PURE__ */ jsxDEV("a", {
-      href: `/?workspace=${NO_WORKSPACE_FILTER}`,
-      class: `sidebar-item no-ws-item${selected === NO_WORKSPACE_FILTER ? " active" : ""}`,
-      children: "No workspace"
-    }, undefined, false, undefined, this),
-    workspaces.map((ws) => /* @__PURE__ */ jsxDEV("a", {
-      href: `/?workspace=${encodeURIComponent(ws)}`,
-      class: `sidebar-item ws-item${selected === ws ? " active" : ""}`,
-      title: ws,
-      children: /* @__PURE__ */ jsxDEV("span", {
-        children: ws.replace(/\/$/, "")
-      }, undefined, false, undefined, this)
-    }, undefined, false, undefined, this))
-  ]
-}, undefined, true, undefined, this);
+function Sidebar({ workspaces, selected }) {
+  return /* @__PURE__ */ jsxDEV("nav", {
+    class: "sidebar",
+    children: [
+      /* @__PURE__ */ jsxDEV("h2", {
+        children: "Workspaces"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV("a", {
+        href: "/",
+        class: `sidebar-item all-item${selected === null ? " active" : ""}`,
+        children: "All"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV("a", {
+        href: `/?workspace=${NO_WORKSPACE_FILTER}`,
+        class: `sidebar-item no-ws-item${selected === NO_WORKSPACE_FILTER ? " active" : ""}`,
+        children: "No workspace"
+      }, undefined, false, undefined, this),
+      workspaces.map((ws) => /* @__PURE__ */ jsxDEV("a", {
+        href: `/?workspace=${encodeURIComponent(ws)}`,
+        class: `sidebar-item ws-item${selected === ws ? " active" : ""}`,
+        title: ws,
+        children: /* @__PURE__ */ jsxDEV("span", {
+          children: ws.replace(/\/$/, "")
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this))
+    ]
+  }, undefined, true, undefined, this);
+}
 
 // src/ui/components/page.tsx
-var buildUrl = (base, overrides) => {
+function buildUrl(base, overrides) {
   const url = new URL(base, "http://localhost");
   for (const [key, value] of Object.entries(overrides)) {
     url.searchParams.set(key, value);
   }
   return `${url.pathname}${url.search}`;
-};
-var Page = ({
+}
+function Page({
   memories,
   workspaces,
   selectedWorkspace,
@@ -23561,7 +23661,7 @@ var Page = ({
   currentPage,
   hasMore,
   showCreate
-}) => {
+}) {
   const params = new URLSearchParams;
   if (selectedWorkspace)
     params.set("workspace", selectedWorkspace);
@@ -23680,27 +23780,26 @@ var Page = ({
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
-};
+}
 
-// src/ui/server.tsx
-var DEFAULT_LIST_LIMIT = 15;
-var MAX_LIST_LIMIT = 100;
-var startWebServer = (repository, options) => {
+// src/ui/routes/page-routes.tsx
+var DEFAULT_LIST_LIMIT3 = 15;
+function createPageRoutes(memory) {
   const app = new Hono2;
-  app.get("/", async (c) => {
+  async function renderPage(c) {
     const workspace = c.req.query("workspace") ?? null;
     const pageNum = Math.max(Number(c.req.query("page")) || 1, 1);
     const editingId = c.req.query("edit") ?? null;
     const showCreate = c.req.query("create") === "1";
     const isNoWorkspace = workspace === NO_WORKSPACE_FILTER;
     const wsFilter = workspace && !isNoWorkspace ? workspace : undefined;
-    const page = await repository.findAll({
+    const page = await memory.list({
       workspace: wsFilter,
       workspaceIsNull: isNoWorkspace,
-      offset: (pageNum - 1) * DEFAULT_LIST_LIMIT,
-      limit: DEFAULT_LIST_LIMIT
+      offset: (pageNum - 1) * DEFAULT_LIST_LIMIT3,
+      limit: DEFAULT_LIST_LIMIT3
     });
-    const workspaces = await repository.listWorkspaces();
+    const workspaces = await memory.listWorkspaces();
     return c.html(/* @__PURE__ */ jsxDEV(Page, {
       memories: page.items,
       workspaces,
@@ -23710,132 +23809,83 @@ var startWebServer = (repository, options) => {
       hasMore: page.hasMore,
       showCreate
     }, undefined, false, undefined, this));
-  });
-  app.post("/memories", async (c) => {
+  }
+  async function createMemory(c) {
     const form2 = await c.req.parseBody();
-    const content = typeof form2.content === "string" ? form2.content.trim() : "";
-    const workspace = typeof form2.workspace === "string" ? form2.workspace.trim() || undefined : undefined;
-    if (content) {
-      const now = new Date;
-      await repository.save({ id: randomUUID2(), content, workspace, createdAt: now, updatedAt: now });
+    const content = typeof form2.content === "string" ? form2.content : "";
+    const workspace = typeof form2.workspace === "string" ? form2.workspace : undefined;
+    try {
+      await memory.create({ content, workspace });
+    } catch (error2) {
+      if (!(error2 instanceof ValidationError)) {
+        throw error2;
+      }
     }
-    const wsParam = workspace ? `/?workspace=${encodeURIComponent(workspace)}` : "/";
+    const wsParam = workspace?.trim() ? `/?workspace=${encodeURIComponent(workspace.trim())}` : "/";
     return c.redirect(wsParam);
-  });
-  app.post("/memories/:id/update", async (c) => {
+  }
+  async function updateMemory(c) {
     const form2 = await c.req.parseBody();
-    const content = typeof form2.content === "string" ? form2.content.trim() : "";
+    const content = typeof form2.content === "string" ? form2.content : "";
     const returnUrl = safeReturnUrl(form2.returnUrl);
-    if (content) {
-      try {
-        await repository.update(c.req.param("id"), content);
-      } catch (error2) {
-        if (!(error2 instanceof NotFoundError))
-          throw error2;
-      }
+    const id = c.req.param("id") ?? "";
+    try {
+      await memory.update({ id, content });
+    } catch (error2) {
+      if (!(error2 instanceof NotFoundError) && !(error2 instanceof ValidationError))
+        throw error2;
     }
     return c.redirect(returnUrl);
-  });
-  app.post("/memories/:id/delete", async (c) => {
+  }
+  async function deleteMemory(c) {
     const form2 = await c.req.parseBody();
     const returnUrl = safeReturnUrl(form2.returnUrl);
+    const id = c.req.param("id") ?? "";
     try {
-      await repository.delete(c.req.param("id"));
+      await memory.delete({ id });
     } catch (error2) {
       if (!(error2 instanceof NotFoundError))
         throw error2;
     }
     return c.redirect(returnUrl);
-  });
-  app.get("/api/workspaces", async (c) => {
-    const workspaces = await repository.listWorkspaces();
-    return c.json({ workspaces });
-  });
-  app.get("/api/memories", async (c) => {
-    const workspace = c.req.query("workspace");
-    const limitParam = c.req.query("limit");
-    const limit = Math.min(Math.max(Number(limitParam) || DEFAULT_LIST_LIMIT, 1), MAX_LIST_LIMIT);
-    const offset = Math.max(Number(c.req.query("offset")) || 0, 0);
-    const page = await repository.findAll({ workspace, offset, limit });
-    return c.json({ items: page.items.map(toMemoryJson), hasMore: page.hasMore });
-  });
-  app.get("/api/memories/:id", async (c) => {
-    const memory = await repository.findById(c.req.param("id"));
-    if (!memory)
-      return c.json({ error: "Memory not found." }, 404);
-    return c.json(toMemoryJson(memory));
-  });
-  app.post("/api/memories", async (c) => {
-    const body = await c.req.json().catch(() => null);
-    if (!body)
-      return c.json({ error: "Invalid JSON." }, 400);
-    const content = typeof body.content === "string" ? body.content.trim() : "";
-    if (!content)
-      return c.json({ error: "Content is required." }, 400);
-    const workspace = typeof body.workspace === "string" ? body.workspace.trim() || undefined : undefined;
-    const now = new Date;
-    const memory = await repository.save({ id: randomUUID2(), content, workspace, createdAt: now, updatedAt: now });
-    return c.json(toMemoryJson(memory), 201);
-  });
-  app.patch("/api/memories/:id", async (c) => {
-    const body = await c.req.json().catch(() => null);
-    if (!body)
-      return c.json({ error: "Invalid JSON." }, 400);
-    const content = typeof body.content === "string" ? body.content.trim() : "";
-    if (!content)
-      return c.json({ error: "Content is required." }, 400);
-    try {
-      const updated = await repository.update(c.req.param("id"), content);
-      return c.json(toMemoryJson(updated));
-    } catch (error2) {
-      if (error2 instanceof NotFoundError)
-        return c.json({ error: "Memory not found." }, 404);
-      throw error2;
-    }
-  });
-  app.delete("/api/memories/:id", async (c) => {
-    try {
-      await repository.delete(c.req.param("id"));
-      return c.body(null, 204);
-    } catch (error2) {
-      if (error2 instanceof NotFoundError)
-        return c.json({ error: "Memory not found." }, 404);
-      throw error2;
-    }
-  });
-  return serve({ fetch: app.fetch, port: options.port });
-};
-var safeReturnUrl = (value) => {
+  }
+  app.get("/", renderPage);
+  app.post("/memories", createMemory);
+  app.post("/memories/:id/update", updateMemory);
+  app.post("/memories/:id/delete", deleteMemory);
+  return app;
+}
+function safeReturnUrl(value) {
   if (typeof value === "string" && value.startsWith("/"))
     return value;
   return "/";
-};
-var toMemoryJson = (memory) => ({
-  id: memory.id,
-  content: memory.content,
-  workspace: memory.workspace ?? null,
-  created_at: memory.createdAt.toISOString(),
-  updated_at: memory.updatedAt.toISOString()
-});
+}
+
+// src/ui/server.tsx
+function startWebServer(memory, options) {
+  const app = new Hono2;
+  app.route("/", createPageRoutes(memory));
+  return serve({ fetch: app.fetch, port: options.port });
+}
 
 // src/index.ts
 var config2 = resolveConfig();
 var database = openMemoryDatabase(config2.databasePath);
 var repository = new SqliteMemoryRepository(database);
+var memoryService = new MemoryService(repository);
 if (config2.uiMode) {
-  const server = startWebServer(repository, { port: config2.uiPort });
-  const addr = server.address();
-  const port = typeof addr === "object" && addr ? addr.port : config2.uiPort;
-  console.log(`agent-memory UI running at http://localhost:${port}`);
-  const shutdown = () => {
+  let shutdown = function() {
     server.close();
     database.close();
     process.exit(0);
   };
+  const server = startWebServer(memoryService, { port: config2.uiPort });
+  const addr = server.address();
+  const port = typeof addr === "object" && addr ? addr.port : config2.uiPort;
+  console.log(`agent-memory UI running at http://localhost:${port}`);
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
 } else {
-  const memoryService = new MemoryService(repository);
   const server = createMcpServer(memoryService, version2);
   const transport = new StdioServerTransport;
   try {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jcyamacho/agent-memory",
   "main": "dist/index.js",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "bin": {
     "agent-memory": "dist/index.js"
   },