@jcyamacho/agent-memory 0.0.12 → 0.0.15

package/dist/index.js

@@ -2431,9 +2431,9 @@ var require_validate = __commonJS((exports) => {
     }
   }
   function returnResults(it) {
-    const { gen, schemaEnv, validateName, ValidationError, opts } = it;
+    const { gen, schemaEnv, validateName, ValidationError: ValidationError2, opts } = it;
     if (schemaEnv.$async) {
-      gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError}(${names_1.default.vErrors})`));
+      gen.if((0, codegen_1._)`${names_1.default.errors} === 0`, () => gen.return(names_1.default.data), () => gen.throw((0, codegen_1._)`new ${ValidationError2}(${names_1.default.vErrors})`));
     } else {
       gen.assign((0, codegen_1._)`${validateName}.errors`, names_1.default.vErrors);
       if (opts.unevaluated)
@@ -2783,14 +2783,14 @@ var require_validate = __commonJS((exports) => {
 var require_validation_error = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
 
-  class ValidationError extends Error {
+  class ValidationError2 extends Error {
     constructor(errors3) {
       super("validation failed");
       this.errors = errors3;
       this.ajv = this.validation = true;
     }
   }
-  exports.default = ValidationError;
+  exports.default = ValidationError2;
 });
 
 // node_modules/ajv/dist/compile/ref_error.js
@@ -12464,15 +12464,16 @@ class StdioServerTransport {
   }
 }
 // package.json
-var version2 = "0.0.12";
+var version2 = "0.0.15";
 
 // src/config.ts
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { parseArgs } from "node:util";
 var AGENT_MEMORY_DB_PATH_ENV = "AGENT_MEMORY_DB_PATH";
+var AGENT_MEMORY_MODELS_CACHE_PATH_ENV = "AGENT_MEMORY_MODELS_CACHE_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: {
@@ -12482,12 +12483,146 @@ var resolveConfig = (environment = process.env, argv = process.argv.slice(2)) =>
     strict: false
   });
   return {
-    databasePath: environment[AGENT_MEMORY_DB_PATH_ENV] || join(homedir(), ".config", "agent-memory", "memory.db"),
+    databasePath: resolveDatabasePath(environment),
+    modelsCachePath: resolveModelsCachePath(environment),
     uiMode: Boolean(values.ui),
     uiPort: Number(values.port) || DEFAULT_UI_PORT
   };
-};
+}
+function resolveDatabasePath(environment = process.env) {
+  return environment[AGENT_MEMORY_DB_PATH_ENV] || join(homedir(), ".config", "agent-memory", "memory.db");
+}
+function resolveModelsCachePath(environment = process.env) {
+  return environment[AGENT_MEMORY_MODELS_CACHE_PATH_ENV] || join(homedir(), ".config", "agent-memory", "models");
+}
+
+// src/embedding/service.ts
+import { mkdirSync } from "node:fs";
+import { pipeline, env as transformersEnv } from "@huggingface/transformers";
+
+// src/errors.ts
+class MemoryError extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "MemoryError";
+    this.code = code;
+  }
+}
+
+class ValidationError extends MemoryError {
+  constructor(message) {
+    super("VALIDATION_ERROR", message);
+    this.name = "ValidationError";
+  }
+}
+
+class NotFoundError extends MemoryError {
+  constructor(message) {
+    super("NOT_FOUND", message);
+    this.name = "NotFoundError";
+  }
+}
+
+class PersistenceError extends MemoryError {
+  constructor(message, options) {
+    super("PERSISTENCE_ERROR", message, options);
+    this.name = "PersistenceError";
+  }
+}
+
+// src/embedding/service.ts
+var DEFAULT_EMBEDDING_MODEL = "Xenova/all-MiniLM-L6-v2";
 
+class EmbeddingService {
+  options;
+  extractorPromise;
+  modelsCachePath;
+  constructor(options = {}) {
+    this.options = options;
+    this.modelsCachePath = options.modelsCachePath ?? resolveModelsCachePath();
+  }
+  async createVector(text) {
+    const normalizedText = text.trim();
+    if (!normalizedText) {
+      throw new ValidationError("Text is required.");
+    }
+    const extractor = await this.getExtractor();
+    const embedding = await extractor(normalizedText);
+    return normalizeVector(embedding.tolist());
+  }
+  getExtractor() {
+    if (!this.extractorPromise) {
+      configureModelsCache(this.modelsCachePath);
+      this.extractorPromise = (this.options.createExtractor ?? createDefaultExtractor)();
+    }
+    return this.extractorPromise;
+  }
+}
+function configureModelsCache(modelsCachePath) {
+  mkdirSync(modelsCachePath, { recursive: true });
+  transformersEnv.useFSCache = true;
+  transformersEnv.cacheDir = modelsCachePath;
+}
+async function createDefaultExtractor() {
+  const extractor = await pipeline("feature-extraction", DEFAULT_EMBEDDING_MODEL);
+  return (text) => extractor(text, {
+    pooling: "mean",
+    normalize: true
+  });
+}
+function normalizeVector(value) {
+  if (value.length === 0) {
+    throw new ValidationError("Embedding model returned an empty vector.");
+  }
+  const [firstItem] = value;
+  if (typeof firstItem === "number") {
+    return value.map((item) => {
+      if (typeof item !== "number" || !Number.isFinite(item)) {
+        throw new ValidationError("Embedding model returned a non-numeric vector.");
+      }
+      return item;
+    });
+  }
+  if (Array.isArray(firstItem)) {
+    return normalizeVector(firstItem);
+  }
+  throw new ValidationError("Embedding model returned an unexpected vector shape.");
+}
+// src/embedding/similarity.ts
+function compareVectors(left, right) {
+  validateVector(left, "Left vector");
+  validateVector(right, "Right vector");
+  if (left.length !== right.length) {
+    throw new ValidationError("Vectors must have the same length.");
+  }
+  let dotProduct = 0;
+  let leftMagnitude = 0;
+  let rightMagnitude = 0;
+  for (const [index, leftValue] of left.entries()) {
+    const rightValue = right[index];
+    if (rightValue === undefined) {
+      throw new ValidationError("Vectors must have the same length.");
+    }
+    dotProduct += leftValue * rightValue;
+    leftMagnitude += leftValue * leftValue;
+    rightMagnitude += rightValue * rightValue;
+  }
+  if (leftMagnitude === 0 || rightMagnitude === 0) {
+    throw new ValidationError("Vectors must not have zero magnitude.");
+  }
+  return dotProduct / (Math.sqrt(leftMagnitude) * Math.sqrt(rightMagnitude));
+}
+function validateVector(vector, label) {
+  if (vector.length === 0) {
+    throw new ValidationError(`${label} must not be empty.`);
+  }
+  for (const value of vector) {
+    if (!Number.isFinite(value)) {
+      throw new ValidationError(`${label} must contain only finite numbers.`);
+    }
+  }
+}
 // node_modules/zod/v3/helpers/util.js
 var util;
 (function(util2) {
@@ -19895,39 +20030,8 @@ var EMPTY_COMPLETION_RESULT = {
   }
 };
 
-// src/errors.ts
-class MemoryError extends Error {
-  code;
-  constructor(code, message, options) {
-    super(message, options);
-    this.name = "MemoryError";
-    this.code = code;
-  }
-}
-
-class ValidationError extends MemoryError {
-  constructor(message) {
-    super("VALIDATION_ERROR", message);
-    this.name = "ValidationError";
-  }
-}
-
-class NotFoundError extends MemoryError {
-  constructor(message) {
-    super("NOT_FOUND", message);
-    this.name = "NotFoundError";
-  }
-}
-
-class PersistenceError extends MemoryError {
-  constructor(message, options) {
-    super("PERSISTENCE_ERROR", message, options);
-    this.name = "PersistenceError";
-  }
-}
-
-// src/tools/shared.ts
-var toMcpError = (error2) => {
+// src/mcp/tools/shared.ts
+function toMcpError(error2) {
   if (error2 instanceof McpError) {
     return error2;
   }
@@ -19939,9 +20043,9 @@ var toMcpError = (error2) => {
   }
   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) => {
+function parseOptionalDate(value, fieldName) {
   if (!value) {
     return;
   }
@@ -19950,19 +20054,19 @@ var parseOptionalDate = (value, fieldName) => {
     throw new MemoryError("VALIDATION_ERROR", `${fieldName} must be a valid ISO 8601 datetime.`);
   }
   return date4;
-};
+}
 
-// src/tools/forget.ts
+// 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.")
+  id: string2().describe("The memory id to delete. Use an id returned by `recall`.")
 };
-var registerForgetTool = (server, memoryService) => {
+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.",
+    description: 'Permanently delete a wrong or obsolete memory. Use `revise` instead when the fact still exists and only needs correction. Returns `<memory id="..." deleted="true" />`.',
     inputSchema: forgetInputSchema
   }, async ({ id }) => {
     try {
-      await memoryService.forget({ id });
+      await memory.delete({ id });
       return {
         content: [{ type: "text", text: `<memory id="${id.trim()}" deleted="true" />` }]
       };
@@ -19970,56 +20074,127 @@ var registerForgetTool = (server, memoryService) => {
       throw toMcpError(error2);
     }
   });
-};
-
-// src/memory-service.ts
-import { randomUUID } from "node:crypto";
+}
 
 // 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 EMBEDDING_SIMILARITY_WEIGHT = 5;
 var WORKSPACE_MATCH_WEIGHT = 4;
-var RECENCY_WEIGHT = 1;
-var MAX_COMPOSITE_SCORE = RETRIEVAL_SCORE_WEIGHT + WORKSPACE_MATCH_WEIGHT + RECENCY_WEIGHT;
+var RECENCY_WEIGHT = 2;
+var MAX_COMPOSITE_SCORE = RETRIEVAL_SCORE_WEIGHT + EMBEDDING_SIMILARITY_WEIGHT + WORKSPACE_MATCH_WEIGHT + RECENCY_WEIGHT;
 var GLOBAL_WORKSPACE_SCORE = 0.5;
 var SIBLING_WORKSPACE_SCORE = 0.25;
+function rerankSearchResults(results, workspace, queryEmbedding) {
+  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 embeddingSimilarityScore = computeEmbeddingSimilarityScore(result, queryEmbedding);
+    const workspaceScore = computeWorkspaceScore(result.workspace, normalizedQueryWs);
+    const recencyScore = maxUpdatedAt === minUpdatedAt ? 0 : (result.updatedAt.getTime() - minUpdatedAt) / (maxUpdatedAt - minUpdatedAt);
+    const combinedScore = (result.score * RETRIEVAL_SCORE_WEIGHT + embeddingSimilarityScore * EMBEDDING_SIMILARITY_WEIGHT + workspaceScore * WORKSPACE_MATCH_WEIGHT + recencyScore * RECENCY_WEIGHT) / MAX_COMPOSITE_SCORE;
+    return {
+      ...result,
+      score: toNormalizedScore(combinedScore)
+    };
+  }).sort((a, b) => b.score - a.score);
+}
+function computeEmbeddingSimilarityScore(result, queryEmbedding) {
+  return normalizeCosineSimilarity(compareVectors(result.embedding, queryEmbedding));
+}
+function normalizeWorkspacePath(value) {
+  return value.trim().replaceAll("\\", "/").replace(/\/+/g, "/").split("/").filter(Boolean).join("/");
+}
+function normalizeCosineSimilarity(value) {
+  return (value + 1) / 2;
+}
+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) {
+  embeddingService;
+  constructor(repository, embeddingService) {
     this.repository = repository;
+    this.embeddingService = embeddingService;
   }
-  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(),
+    const memory = await this.repository.create({
       content,
-      workspace: normalizeOptionalString(input.workspace),
-      createdAt: now,
-      updatedAt: now
-    };
-    return this.repository.save(memory);
+      embedding: await this.embeddingService.createVector(content),
+      workspace: normalizeOptionalString(input.workspace)
+    });
+    return toPublicMemoryRecord(memory);
   }
-  async revise(input) {
+  async update(input) {
     const content = input.content.trim();
     if (!content)
       throw new ValidationError("Memory content is required.");
-    return this.repository.update(input.id, content);
+    const memory = await this.repository.update({
+      id: input.id,
+      content,
+      embedding: await this.embeddingService.createVector(content)
+    });
+    return toPublicMemoryRecord(memory);
   }
-  async forget(input) {
+  async delete(input) {
     const id = input.id.trim();
     if (!id)
       throw new ValidationError("Memory id is required.");
-    return this.repository.delete(id);
+    return this.repository.delete({ id });
+  }
+  async get(id) {
+    const memory = await this.repository.get(id);
+    return memory ? toPublicMemoryRecord(memory) : undefined;
+  }
+  async list(input) {
+    const workspace = normalizeOptionalString(input.workspace);
+    const page = await this.repository.list({
+      workspace,
+      workspaceIsNull: workspace ? false : Boolean(input.workspaceIsNull),
+      offset: normalizeOffset(input.offset),
+      limit: normalizeListLimit(input.limit)
+    });
+    return toPublicMemoryPage(page);
+  }
+  async listWorkspaces() {
+    return this.repository.listWorkspaces();
   }
   async search(input) {
     const terms = normalizeTerms(input.terms);
@@ -20034,20 +20209,56 @@ class MemoryService {
       updatedAfter: input.updatedAfter,
       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);
+    const [results, queryEmbedding] = await Promise.all([
+      this.repository.search(normalizedQuery),
+      this.embeddingService.createVector(terms.join(" "))
+    ]);
+    return rerankSearchResults(results, workspace, queryEmbedding).slice(0, requestedLimit).map(toPublicSearchResult);
   }
 }
+function toPublicMemoryRecord(memory) {
+  return {
+    id: memory.id,
+    content: memory.content,
+    workspace: memory.workspace,
+    createdAt: memory.createdAt,
+    updatedAt: memory.updatedAt
+  };
+}
+function toPublicSearchResult(result) {
+  return {
+    id: result.id,
+    content: result.content,
+    score: result.score,
+    workspace: result.workspace,
+    createdAt: result.createdAt,
+    updatedAt: result.updatedAt
+  };
+}
+function toPublicMemoryPage(page) {
+  return {
+    items: page.items.map(toPublicMemoryRecord),
+    hasMore: page.hasMore
+  };
+}
 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;
@@ -20056,77 +20267,37 @@ 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/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."),
-  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.")
+  terms: array(string2()).min(1).describe("Search terms for lexical memory lookup. Pass 2-5 short anchor-heavy terms or exact phrases as separate entries. Prefer identifiers, commands, file paths, package names, and conventions likely to appear verbatim in the memory. Avoid vague words, full sentences, and repeating the workspace name. If recall misses, retry once with overlapping alternate terms."),
+  limit: number2().int().min(1).max(MAX_RECALL_LIMIT).optional().describe("Maximum matches to return. Keep this small when you only need the strongest hits."),
+  workspace: string2().optional().describe("Pass the current working directory. This strongly boosts memories from the active project while still allowing global and cross-workspace matches."),
+  updated_after: string2().optional().describe("Only return memories updated at or after this ISO 8601 timestamp."),
+  updated_before: string2().optional().describe("Only return memories updated at or before this ISO 8601 timestamp.")
 };
-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()}">
+  const score = Number(r.score.toFixed(3)).toString();
+  return `<memory id="${r.id}" score="${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.",
+    description: "Retrieve relevant memories for the current task. Use at conversation start and before design choices, conventions, or edge cases. Query with 2-5 short anchor-heavy terms or exact phrases, not questions or full sentences. `recall` is lexical-first; semantic reranking only reorders lexical matches. If it misses, retry once with overlapping alternate terms. Pass workspace. Returns `<memories>...</memories>` or a no-match hint.",
     inputSchema: recallInputSchema
   }, async ({ terms, limit, workspace, updated_after, updated_before }) => {
     try {
-      const results = await memoryService.search({
+      const results = await memory.search({
         terms,
         limit,
         workspace,
         updatedAfter: parseOptionalDate(updated_after, "updated_after"),
         updatedBefore: parseOptionalDate(updated_before, "updated_before")
       });
-      const text = results.length === 0 ? "No matching memories found." : `<memories>
+      const text = results.length === 0 ? "No matching memories found. Retry once with 1-3 alternate overlapping terms or an exact phrase likely to appear in the memory text. Recall is lexical-first, so semantic reranking cannot rescue a query with no wording overlap." : `<memories>
 ${results.map(toMemoryXml).join(`
 `)}
 </memories>`;
@@ -20137,49 +20308,49 @@ ${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).")
+  content: string2().describe("One durable fact to save. Use a single self-contained sentence or short note with concrete nouns, identifiers, commands, file paths, or exact phrases the agent is likely to reuse."),
+  workspace: string2().optional().describe("Pass the current working directory for project-specific memories. Omit only for truly global memories.")
 };
-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.",
+    description: 'Save one durable memory for later recall. Use when the user states a stable preference, corrects you, or establishes reusable project context not obvious from code or git history. Save one fact per memory. Call `recall` first; use `revise` instead of creating duplicates. Do not store secrets, temporary task state, or codebase facts. Returns `<memory id="..." />`.',
     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/tools/revise.ts
+// 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.")
+  id: string2().describe("The memory id to update. Use an id returned by `recall`."),
+  content: string2().describe("The corrected replacement for that same fact. Keep it to one durable fact.")
 };
-var registerReviseTool = (server, memoryService) => {
+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.",
+    description: 'Replace one existing memory with corrected wording. Use after `recall` when the same fact still applies but details changed. Do not append unrelated facts or merge memories. Returns `<memory id="..." updated_at="..." />`.',
     inputSchema: reviseInputSchema
   }, async ({ id, content }) => {
     try {
-      const memory = await memoryService.revise({ id, content });
+      const revisedMemory = await memory.update({ id, content });
       return {
         content: [
           {
             type: "text",
-            text: `<memory id="${memory.id}" updated_at="${memory.updatedAt.toISOString()}" />`
+            text: `<memory id="${revisedMemory.id}" updated_at="${revisedMemory.updatedAt.toISOString()}" />`
           }
         ]
       };
@@ -20187,103 +20358,278 @@ var registerReviseTool = (server, memoryService) => {
       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."
+  "Use this server for durable memory: user preferences, corrections, decisions, and project context not obvious from code or git history.",
+  "Use `recall` at conversation start and before design choices, conventions, or edge cases.",
+  "Query `recall` with 2-5 short anchor-heavy terms or exact phrases likely to appear verbatim in memory text: identifiers, commands, file paths, and conventions.",
+  "`recall` is lexical-first; semantic reranking only reorders lexical matches.",
+  "If `recall` misses, retry once with overlapping alternate terms.",
+  "Use `remember` for one durable fact when the user states a preference, corrects you, or a reusable project decision becomes clear.",
+  "Call `recall` before `remember`; if the fact already exists, use `revise` instead of creating a duplicate.",
+  "Use `revise` to correct an existing memory and `forget` to remove a wrong or obsolete one.",
+  "Pass workspace for project-scoped calls. Omit it only for truly global memories."
 ].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);
-  registerReviseTool(server, memoryService);
-  registerForgetTool(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";
+// src/sqlite/db.ts
+import { mkdirSync as mkdirSync2 } from "node:fs";
 import { dirname } from "node:path";
 import Database from "better-sqlite3";
-var MEMORY_SCHEMA = `
-  CREATE TABLE IF NOT EXISTS memories (
-    id TEXT PRIMARY KEY,
-    content TEXT NOT NULL,
-    workspace TEXT,
-    created_at INTEGER NOT NULL,
-    updated_at INTEGER NOT NULL
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_memories_created_at ON memories(created_at);
-  CREATE INDEX IF NOT EXISTS idx_memories_workspace ON memories(workspace);
-
-  CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-    content,
-    content = 'memories',
-    content_rowid = 'rowid',
-    tokenize = 'porter unicode61'
-  );
-
-  CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
-    INSERT INTO memories_fts(rowid, content) VALUES (new.rowid, new.content);
-  END;
-
-  CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
-    INSERT INTO memories_fts(memories_fts, rowid, content)
-    VALUES ('delete', old.rowid, old.content);
-  END;
-
-  CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
-    INSERT INTO memories_fts(memories_fts, rowid, content)
-    VALUES ('delete', old.rowid, old.content);
-    INSERT INTO memories_fts(rowid, content) VALUES (new.rowid, new.content);
-  END;
-`;
-var openMemoryDatabase = (databasePath) => {
+
+// src/sqlite/memory-schema.ts
+function createMemoriesTable(database, options) {
+  const embeddingColumn = getEmbeddingColumnSql(options.embeddingColumn);
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS memories (
+      id TEXT PRIMARY KEY,
+      content TEXT NOT NULL,
+      workspace TEXT,
+      ${embeddingColumn}
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+  `);
+}
+function createMemoryIndexes(database) {
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_memories_created_at ON memories(created_at);
+    CREATE INDEX IF NOT EXISTS idx_memories_workspace ON memories(workspace);
+  `);
+}
+function createMemorySearchArtifacts(database, rebuild = false) {
+  database.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+      content,
+      content = 'memories',
+      content_rowid = 'rowid',
+      tokenize = 'porter unicode61'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+      INSERT INTO memories_fts(rowid, content) VALUES (new.rowid, new.content);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, content)
+      VALUES ('delete', old.rowid, old.content);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, content)
+      VALUES ('delete', old.rowid, old.content);
+      INSERT INTO memories_fts(rowid, content) VALUES (new.rowid, new.content);
+    END;
+  `);
+  if (rebuild) {
+    database.exec("INSERT INTO memories_fts(memories_fts) VALUES ('rebuild')");
+  }
+}
+function dropMemorySearchArtifacts(database) {
+  database.exec(`
+    DROP TRIGGER IF EXISTS memories_ai;
+    DROP TRIGGER IF EXISTS memories_ad;
+    DROP TRIGGER IF EXISTS memories_au;
+    DROP TABLE IF EXISTS memories_fts;
+  `);
+}
+function getEmbeddingColumnSql(mode) {
+  switch (mode) {
+    case "omit":
+      return "";
+    case "nullable":
+      return `embedding BLOB,
+      `;
+    case "required":
+      return `embedding BLOB NOT NULL,
+      `;
+  }
+}
+
+// src/sqlite/migrations/001-create-memory-schema.ts
+var createMemorySchemaMigration = {
+  version: 1,
+  async up(database) {
+    createMemoriesTable(database, { embeddingColumn: "omit" });
+    createMemoryIndexes(database);
+    createMemorySearchArtifacts(database);
+  }
+};
+
+// src/sqlite/embedding-codec.ts
+var FLOAT32_BYTE_WIDTH = 4;
+function encodeEmbedding(vector) {
+  const typedArray = Float32Array.from(vector);
+  return new Uint8Array(typedArray.buffer.slice(0));
+}
+function decodeEmbedding(value) {
+  const bytes = toUint8Array(value);
+  if (bytes.byteLength === 0) {
+    throw new Error("Embedding blob is empty.");
+  }
+  if (bytes.byteLength % FLOAT32_BYTE_WIDTH !== 0) {
+    throw new Error("Embedding blob length is not a multiple of 4.");
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const vector = [];
+  for (let offset = 0;offset < bytes.byteLength; offset += FLOAT32_BYTE_WIDTH) {
+    vector.push(view.getFloat32(offset, true));
+  }
+  return vector;
+}
+function toUint8Array(value) {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  throw new Error("Expected embedding blob as Uint8Array or ArrayBuffer.");
+}
+
+// src/sqlite/migrations/002-add-memory-embedding.ts
+function createAddMemoryEmbeddingMigration(embeddingService = new EmbeddingService) {
+  return {
+    version: 2,
+    async up(database) {
+      database.exec("ALTER TABLE memories ADD COLUMN embedding BLOB");
+      const rows = database.prepare("SELECT id, content FROM memories ORDER BY created_at ASC").all();
+      const updateStatement = database.prepare("UPDATE memories SET embedding = ? WHERE id = ?");
+      for (const row of rows) {
+        const embedding = await embeddingService.createVector(row.content);
+        updateStatement.run(encodeEmbedding(embedding), row.id);
+      }
+      const nullRows = database.prepare("SELECT COUNT(*) AS count FROM memories WHERE embedding IS NULL").all();
+      if ((nullRows[0]?.count ?? 0) > 0) {
+        throw new Error("Failed to backfill embeddings for all memories.");
+      }
+      dropMemorySearchArtifacts(database);
+      database.exec("ALTER TABLE memories RENAME TO memories_old");
+      createMemoriesTable(database, { embeddingColumn: "required" });
+      database.exec(`
+        INSERT INTO memories (id, content, workspace, embedding, created_at, updated_at)
+        SELECT id, content, workspace, embedding, created_at, updated_at
+        FROM memories_old
+      `);
+      database.exec("DROP TABLE memories_old");
+      createMemoryIndexes(database);
+      createMemorySearchArtifacts(database, true);
+    }
+  };
+}
+var addMemoryEmbeddingMigration = createAddMemoryEmbeddingMigration();
+
+// src/sqlite/migrations/index.ts
+function createMemoryMigrations(embeddingService = new EmbeddingService) {
+  return [createMemorySchemaMigration, createAddMemoryEmbeddingMigration(embeddingService)];
+}
+var MEMORY_MIGRATIONS = createMemoryMigrations();
+
+// src/sqlite/db.ts
+var PRAGMA_STATEMENTS = [
+  "journal_mode = WAL",
+  "synchronous = NORMAL",
+  "foreign_keys = ON",
+  "busy_timeout = 5000"
+];
+async function openMemoryDatabase(databasePath, options = {}) {
+  let database;
   try {
-    mkdirSync(dirname(databasePath), { recursive: true });
-    const database = new Database(databasePath);
-    initializeMemoryDatabase(database);
+    mkdirSync2(dirname(databasePath), { recursive: true });
+    database = new Database(databasePath);
+    await initializeMemoryDatabase(database, createMemoryMigrations(options.embeddingService));
     return database;
   } catch (error2) {
+    database?.close();
+    if (error2 instanceof PersistenceError) {
+      throw error2;
+    }
     throw new PersistenceError("Failed to initialize the SQLite database.", {
       cause: error2
     });
   }
-};
-var initializeMemoryDatabase = (database) => {
+}
+async function initializeMemoryDatabase(database, migrations = MEMORY_MIGRATIONS) {
+  try {
+    applyPragmas(database);
+    await runSqliteMigrations(database, migrations);
+  } catch (error2) {
+    throw new PersistenceError("Failed to initialize the SQLite database.", {
+      cause: error2
+    });
+  }
+}
+async function runSqliteMigrations(database, migrations) {
+  validateMigrations(migrations);
+  let currentVersion = getUserVersion(database);
+  for (const migration of migrations) {
+    if (migration.version <= currentVersion) {
+      continue;
+    }
+    database.exec("BEGIN");
+    try {
+      await migration.up(database);
+      setUserVersion(database, migration.version);
+      database.exec("COMMIT");
+      currentVersion = migration.version;
+    } catch (error2) {
+      try {
+        database.exec("ROLLBACK");
+      } catch {}
+      throw error2;
+    }
+  }
+}
+function applyPragmas(database) {
   if (database.pragma) {
-    database.pragma("journal_mode = WAL");
-    database.pragma("synchronous = NORMAL");
-    database.pragma("foreign_keys = ON");
-    database.pragma("busy_timeout = 5000");
-  } else {
-    database.exec("PRAGMA journal_mode = WAL");
-    database.exec("PRAGMA synchronous = NORMAL");
-    database.exec("PRAGMA foreign_keys = ON");
-    database.exec("PRAGMA busy_timeout = 5000");
+    for (const statement of PRAGMA_STATEMENTS) {
+      database.pragma(statement);
+    }
+    return;
   }
-  database.exec(MEMORY_SCHEMA);
-};
+  for (const statement of PRAGMA_STATEMENTS) {
+    database.exec(`PRAGMA ${statement}`);
+  }
+}
+function getUserVersion(database) {
+  const rows = database.prepare("PRAGMA user_version").all();
+  return rows[0]?.user_version ?? 0;
+}
+function setUserVersion(database, version3) {
+  database.exec(`PRAGMA user_version = ${version3}`);
+}
+function validateMigrations(migrations) {
+  let previousVersion = 0;
+  for (const migration of migrations) {
+    if (!Number.isInteger(migration.version) || migration.version <= previousVersion) {
+      throw new Error("SQLite migrations must use strictly increasing versions.");
+    }
+    previousVersion = migration.version;
+  }
+}
+// src/sqlite/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;
@@ -20294,6 +20640,7 @@ class SqliteMemoryRepository {
         id,
         content,
         workspace,
+        embedding,
         created_at,
         updated_at
       ) VALUES (
@@ -20301,17 +20648,27 @@ class SqliteMemoryRepository {
         ?,
         ?,
         ?,
+        ?,
         ?
       )
     `);
-    this.findByIdStatement = 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.getStatement = database.prepare("SELECT id, content, workspace, embedding, created_at, updated_at FROM memories WHERE id = ?");
+    this.updateStatement = database.prepare("UPDATE memories SET content = ?, embedding = ?, 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 {
-      this.insertStatement.run(memory.id, memory.content, memory.workspace, memory.createdAt.getTime(), memory.updatedAt.getTime());
+      const now = new Date;
+      const memory = {
+        id: randomUUID(),
+        content: input.content,
+        embedding: input.embedding,
+        workspace: input.workspace,
+        createdAt: now,
+        updatedAt: now
+      };
+      this.insertStatement.run(memory.id, memory.content, memory.workspace, encodeEmbedding(memory.embedding), memory.createdAt.getTime(), memory.updatedAt.getTime());
       return memory;
     } catch (error2) {
       throw new PersistenceError("Failed to save memory.", { cause: error2 });
@@ -20320,6 +20677,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 >= ?");
@@ -20329,12 +20687,13 @@ 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,
           m.content,
           m.workspace,
+          m.embedding,
           m.created_at,
           m.updated_at,
           MAX(0, -bm25(memories_fts)) AS score
@@ -20347,7 +20706,7 @@ class SqliteMemoryRepository {
       const rows = statement.all(...params);
       const maxScore = Math.max(...rows.map((row) => row.score), 0);
       return rows.map((row) => ({
-        ...toMemoryRecord(row),
+        ...toMemoryEntity(row),
         score: toNormalizedScore(maxScore > 0 ? row.score / maxScore : 0)
       }));
     } catch (error2) {
@@ -20356,19 +20715,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;
+      return row ? toMemoryEntity(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);
@@ -20376,49 +20737,49 @@ 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
+        SELECT id, content, workspace, embedding, created_at, updated_at
         FROM memories
         ${whereClause}
         ORDER BY created_at DESC
         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(toMemoryEntity);
       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, encodeEmbedding(input.embedding), 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() {
@@ -20430,25 +20791,22 @@ class SqliteMemoryRepository {
     }
   }
 }
-var toMemoryRecord = (row) => ({
+var toMemoryEntity = (row) => ({
   id: row.id,
   content: row.content,
+  embedding: decodeEmbedding(row.embedding),
   workspace: row.workspace ?? undefined,
   createdAt: new Date(row.created_at),
   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";
 import { Http2ServerRequest as Http2ServerRequest2 } from "http2";
@@ -23441,182 +23799,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: [
+        }, undefined, true, undefined, this),
         /* @__PURE__ */ jsxDEV("div", {
-          class: "card-content",
-          children: memory.content
-        }, undefined, false, 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,
@@ -23624,7 +23988,7 @@ var Page = ({
   currentPage,
   hasMore,
   showCreate
-}) => {
+}) {
   const params = new URLSearchParams;
   if (selectedWorkspace)
     params.set("workspace", selectedWorkspace);
@@ -23743,27 +24107,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,
@@ -23773,132 +24136,84 @@ 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 embeddingService = new EmbeddingService({ modelsCachePath: config2.modelsCachePath });
+var database = await openMemoryDatabase(config2.databasePath, { embeddingService });
+var repository2 = new SqliteMemoryRepository(database);
+var memoryService = new MemoryService(repository2, embeddingService);
 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 {