fossel 1.1.0 → 1.2.0

package/dist/index.js

@@ -138,6 +138,25 @@ var migrations = [
         tx(rows);
       }
     }
+  },
+  {
+    name: "007_add_memory_embeddings",
+    apply: (db) => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS memory_embeddings (
+          memory_rowid INTEGER PRIMARY KEY,
+          dim INTEGER NOT NULL,
+          version INTEGER NOT NULL,
+          vector BLOB NOT NULL,
+          updated_at INTEGER NOT NULL
+        );
+
+        CREATE TRIGGER IF NOT EXISTS memories_embeddings_ad
+        AFTER DELETE ON memories BEGIN
+          DELETE FROM memory_embeddings WHERE memory_rowid = old.rowid;
+        END;
+      `);
+    }
   }
 ];
 function runMigrations(db) {
@@ -195,6 +214,158 @@ function getDb() {
   return dbInstance;
 }
 
+// src/lib/embeddings.ts
+var EMBEDDING_DIM = 256;
+var EMBEDDING_VERSION = 1;
+function embeddingsEnabled() {
+  const value = process.env.FOSSEL_EMBEDDINGS?.trim().toLowerCase();
+  return value === "1" || value === "true" || value === "on" || value === "yes";
+}
+function fnv1a(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i += 1) {
+    hash ^= str.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim().split(" ").filter((token) => token.length >= 2);
+}
+function embedText(text) {
+  const vector = new Float32Array(EMBEDDING_DIM);
+  const tokens = tokenize(text);
+  if (tokens.length === 0) {
+    return vector;
+  }
+  const addFeature = (feature, weight) => {
+    const h = fnv1a(feature);
+    const index = h % EMBEDDING_DIM;
+    const sign = (fnv1a(`#${feature}`) & 1) === 0 ? 1 : -1;
+    vector[index] += sign * weight;
+  };
+  for (let i = 0; i < tokens.length; i += 1) {
+    addFeature(tokens[i], 1);
+    if (i + 1 < tokens.length) {
+      addFeature(`${tokens[i]} ${tokens[i + 1]}`, 0.6);
+    }
+  }
+  let norm = 0;
+  for (let i = 0; i < EMBEDDING_DIM; i += 1) {
+    norm += vector[i] * vector[i];
+  }
+  norm = Math.sqrt(norm);
+  if (norm > 0) {
+    for (let i = 0; i < EMBEDDING_DIM; i += 1) {
+      vector[i] /= norm;
+    }
+  }
+  return vector;
+}
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    return 0;
+  }
+  let dot = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    dot += a[i] * b[i];
+  }
+  return dot;
+}
+function vectorToBuffer(vector) {
+  return Buffer.from(vector.buffer, vector.byteOffset, vector.byteLength);
+}
+function bufferToVector(buffer) {
+  const copy = Buffer.from(buffer);
+  return new Float32Array(
+    copy.buffer,
+    copy.byteOffset,
+    Math.floor(copy.byteLength / 4)
+  );
+}
+
+// src/lib/vector-index.ts
+function indexMemoryEmbedding(db, rowId, note) {
+  if (!embeddingsEnabled()) {
+    return;
+  }
+  const vector = embedText(note);
+  db.prepare(
+    `
+      INSERT INTO memory_embeddings (memory_rowid, dim, version, vector, updated_at)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(memory_rowid) DO UPDATE SET
+        dim = excluded.dim,
+        version = excluded.version,
+        vector = excluded.vector,
+        updated_at = excluded.updated_at
+    `
+  ).run(
+    rowId,
+    EMBEDDING_DIM,
+    EMBEDDING_VERSION,
+    vectorToBuffer(vector),
+    Math.floor(Date.now() / 1e3)
+  );
+}
+function backfillRepoEmbeddings(db, repo) {
+  if (!embeddingsEnabled()) {
+    return 0;
+  }
+  const rows = db.prepare(
+    `
+        SELECT m.rowid AS row_id, m.note
+        FROM memories AS m
+        LEFT JOIN memory_embeddings AS e ON e.memory_rowid = m.rowid
+        WHERE m.repo = ?
+          AND (e.memory_rowid IS NULL OR e.version != ? OR e.dim != ?)
+      `
+  ).all(repo, EMBEDDING_VERSION, EMBEDDING_DIM);
+  if (rows.length === 0) {
+    return 0;
+  }
+  const tx = db.transaction((batch) => {
+    for (const row of batch) {
+      indexMemoryEmbedding(db, row.row_id, row.note);
+    }
+  });
+  tx(rows);
+  return rows.length;
+}
+function vectorSearch(db, repo, query, limit) {
+  if (!embeddingsEnabled()) {
+    return [];
+  }
+  backfillRepoEmbeddings(db, repo);
+  const queryVector = embedText(query);
+  let queryNorm = 0;
+  for (let i = 0; i < queryVector.length; i += 1) {
+    queryNorm += queryVector[i] * queryVector[i];
+  }
+  if (queryNorm === 0) {
+    return [];
+  }
+  const rows = db.prepare(
+    `
+        SELECT m.rowid AS row_id, m.id, m.repo, m.type, m.note, m.tags,
+               m.created_at, m.updated_at, m.pinned, e.vector AS vector
+        FROM memory_embeddings AS e
+        JOIN memories AS m ON m.rowid = e.memory_rowid
+        WHERE m.repo = ? AND e.dim = ? AND e.version = ?
+      `
+  ).all(repo, EMBEDDING_DIM, EMBEDDING_VERSION);
+  const scored = [];
+  for (const row of rows) {
+    const { vector, ...memory } = row;
+    const score = cosineSimilarity(queryVector, bufferToVector(vector));
+    if (score > 0) {
+      scored.push({ ...memory, score });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, limit);
+}
+
 // src/lib/context.ts
 var SECTION_TITLES = {
   convention: "Conventions",
@@ -212,6 +383,9 @@ function parseTags(raw) {
     return [];
   }
 }
+function normalizeNoteForReadDedupe(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
+}
 function buildFtsQuery(query) {
   const terms = query.trim().split(/\s+/).map((term) => term.replace(/"/g, '""')).filter((term) => term.length > 0);
   if (terms.length === 0) {
@@ -222,11 +396,19 @@ function buildFtsQuery(query) {
 function fetchRepoContext(db, repo, limit, query) {
   const rows = [];
   const seen = /* @__PURE__ */ new Set();
+  const seenNormalized = /* @__PURE__ */ new Set();
   const push = (memory, source, rank) => {
     if (seen.has(memory.row_id)) {
       return;
     }
+    const normalized = normalizeNoteForReadDedupe(memory.note);
+    if (normalized && seenNormalized.has(normalized)) {
+      return;
+    }
     seen.add(memory.row_id);
+    if (normalized) {
+      seenNormalized.add(normalized);
+    }
     rows.push({ ...memory, source, rank });
   };
   const pinned = db.prepare(
@@ -241,7 +423,10 @@ function fetchRepoContext(db, repo, limit, query) {
   for (const row of pinned) {
     push(row, "pinned");
   }
-  if (rows.length < limit) {
+  const pushRecent = () => {
+    if (rows.length >= limit) {
+      return;
+    }
     const recent = db.prepare(
       `
           SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
@@ -250,13 +435,20 @@ function fetchRepoContext(db, repo, limit, query) {
           ORDER BY updated_at DESC
           LIMIT ?
         `
-    ).all(repo, limit - rows.length);
+    ).all(repo, limit);
     for (const row of recent) {
       push(row, "recent");
+      if (rows.length >= limit) {
+        break;
+      }
     }
+  };
+  if (!query) {
+    pushRecent();
   }
   if (query && rows.length < limit) {
     const ftsQuery = buildFtsQuery(query);
+    const ftsRows = [];
     if (ftsQuery) {
       try {
         const matches = db.prepare(
@@ -270,15 +462,49 @@ function fetchRepoContext(db, repo, limit, query) {
               LIMIT ?
             `
         ).all(ftsQuery, repo, limit);
-        for (const row of matches) {
-          push(row, "search", row.rank);
-          if (rows.length >= limit) {
-            break;
+        ftsRows.push(...matches);
+      } catch {
+      }
+    }
+    const vectorRows = embeddingsEnabled() ? vectorSearch(db, repo, query, limit) : [];
+    if (vectorRows.length > 0) {
+      const RRF_K = 60;
+      const fused = /* @__PURE__ */ new Map();
+      const accumulate = (list, rankOf) => {
+        list.forEach((memory, index) => {
+          const contribution = 1 / (RRF_K + index + 1);
+          const prior = fused.get(memory.row_id);
+          if (prior) {
+            prior.score += contribution;
+          } else {
+            fused.set(memory.row_id, {
+              memory,
+              score: contribution,
+              rank: rankOf?.(memory, index)
+            });
           }
+        });
+      };
+      accumulate(ftsRows, (m) => m.rank);
+      accumulate(vectorRows);
+      const ordered = Array.from(fused.values()).sort(
+        (a, b) => b.score - a.score
+      );
+      for (const { memory, rank } of ordered) {
+        push(memory, "search", rank);
+        if (rows.length >= limit) {
+          break;
+        }
+      }
+    } else {
+      for (const row of ftsRows) {
+        push(row, "search", row.rank);
+        if (rows.length >= limit) {
+          break;
         }
-      } catch {
       }
     }
+    pushRecent();
   }
   return rows.slice(0, limit);
 }
@@ -472,6 +698,15 @@ function resolveRepoArg(input, cwd, db) {
   };
 }
 
+// src/lib/workspace.ts
+function getWorkspaceRoot() {
+  const fromEnv = process.env.FOSSEL_WORKSPACE?.trim();
+  if (fromEnv) {
+    return fromEnv;
+  }
+  return process.cwd();
+}
+
 // src/tools/dedupe-repo.ts
 import { z } from "zod";
 
@@ -481,7 +716,7 @@ var DEFAULT_CANDIDATE_LIMIT = 200;
 function normalizeText(text) {
   return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
 }
-function tokenize(text) {
+function tokenize2(text) {
   return normalizeText(text).split(" ").filter((token) => token.length >= 2);
 }
 function trigrams(text) {
@@ -517,7 +752,7 @@ function similarity(a, b) {
   if (normalizedA === normalizedB) {
     return 1;
   }
-  const wordScore = jaccard(new Set(tokenize(normalizedA)), new Set(tokenize(normalizedB)));
+  const wordScore = jaccard(new Set(tokenize2(normalizedA)), new Set(tokenize2(normalizedB)));
   const triScore = jaccard(trigrams(normalizedA), trigrams(normalizedB));
   return wordScore * 0.55 + triScore * 0.45;
 }
@@ -606,7 +841,7 @@ function registerDedupeRepoTool(server) {
     async ({ repo, threshold, apply }) => {
       try {
         const db = getDb();
-        const resolved = resolveRepoArg(repo, process.cwd(), db);
+        const resolved = resolveRepoArg(repo, getWorkspaceRoot(), db);
         const rows = db.prepare(
           `
               SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned, metadata_json
@@ -734,21 +969,56 @@ Re-run with apply=true to merge.`
 
 // src/tools/delete.ts
 import { z as z2 } from "zod";
+
+// src/lib/memory.ts
+function findMemoryByAnyId(db, input) {
+  const numeric = typeof input === "number" ? input : Number(input);
+  const isNumericId = Number.isInteger(numeric) && numeric > 0 && String(numeric) === String(input).trim();
+  if (isNumericId) {
+    const row = db.prepare(
+      `
+          SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
+          FROM memories
+          WHERE rowid = ?
+        `
+    ).get(numeric);
+    if (row) {
+      return row;
+    }
+  }
+  const stringInput = String(input).trim();
+  if (stringInput.length === 0) {
+    return null;
+  }
+  const stringRow = db.prepare(
+    `
+        SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
+        FROM memories
+        WHERE id = ?
+      `
+  ).get(stringInput);
+  return stringRow ?? null;
+}
+
+// src/tools/delete.ts
 var deleteMemoryInputSchema = {
-  id: z2.string().trim().min(1, "id is required")
+  // Accept either the numeric row_id or the legacy nanoid string. Tools used
+  // to disagree about which form to take; this unifies them so callers can
+  // paste whichever id they have in front of them.
+  id: z2.union([z2.number().int().positive(), z2.string().trim().min(1)])
 };
 function registerDeleteMemoryTool(server) {
   server.registerTool(
     "delete_memory",
     {
-      description: "Delete a memory from storage by id.",
+      description: "Delete a memory from storage by id. Accepts either the numeric row id or the legacy string id.",
       inputSchema: deleteMemoryInputSchema
     },
     async ({ id }) => {
       try {
         const db = getDb();
-        const row = db.prepare("SELECT id FROM memories WHERE id = ?").get(id);
-        if (!row) {
+        const memory = findMemoryByAnyId(db, id);
+        if (!memory) {
           return {
             isError: true,
             content: [
@@ -759,15 +1029,15 @@ function registerDeleteMemoryTool(server) {
             ]
           };
         }
-        const deleteTx = db.transaction((memoryId) => {
-          db.prepare("DELETE FROM memories WHERE id = ?").run(memoryId);
+        const deleteTx = db.transaction((rowId) => {
+          db.prepare("DELETE FROM memories WHERE rowid = ?").run(rowId);
         });
-        deleteTx(id);
+        deleteTx(memory.row_id);
         return {
           content: [
             {
               type: "text",
-              text: `Deleted memory ${id}.`
+              text: `Deleted memory ${memory.row_id} (legacy: ${memory.id}).`
             }
           ]
         };
@@ -805,7 +1075,7 @@ function registerGetContextTool(server) {
     async ({ repo, query, limit, format }) => {
       try {
         const db = getDb();
-        const resolved = resolveRepoArg(repo, process.cwd(), db);
+        const resolved = resolveRepoArg(repo, getWorkspaceRoot(), db);
         const rows = fetchRepoContext(db, resolved.canonical, limit, query);
         const text = formatContext(rows, {
           repo: resolved.canonical,
@@ -863,7 +1133,7 @@ function registerGetRepoContextTool(server) {
     async ({ repo, limit }) => {
       try {
         const db = getDb();
-        const resolved = resolveRepoArg(repo, process.cwd(), db);
+        const resolved = resolveRepoArg(repo, getWorkspaceRoot(), db);
         const rows = db.prepare(
           `
               SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
@@ -932,9 +1202,10 @@ ${sections.join("\n\n")}`
 // src/tools/pin.ts
 import { z as z5 } from "zod";
 var pinInputSchema = {
-  id: z5.number().int().positive()
+  // Accept numeric row_id or legacy string id for parity with the other tools.
+  id: z5.union([z5.number().int().positive(), z5.string().trim().min(1)])
 };
-function setPinnedState(memoryId, pinned) {
+function setPinnedState(rowId, pinned) {
   const db = getDb();
   const now = Math.floor(Date.now() / 1e3);
   const updateResult = db.prepare(
@@ -943,7 +1214,7 @@ function setPinnedState(memoryId, pinned) {
         SET pinned = ?, updated_at = ?
         WHERE rowid = ?
       `
-  ).run(pinned, now, memoryId);
+  ).run(pinned, now, rowId);
   if (updateResult.changes === 0) {
     return null;
   }
@@ -953,7 +1224,7 @@ function setPinnedState(memoryId, pinned) {
         FROM memories
         WHERE rowid = ?
       `
-  ).get(memoryId);
+  ).get(rowId);
 }
 function registerPinMemoryTool(server) {
   server.registerTool(
@@ -964,7 +1235,20 @@ function registerPinMemoryTool(server) {
     },
     async ({ id }) => {
       try {
-        const memory = setPinnedState(id, 1);
+        const db = getDb();
+        const target = findMemoryByAnyId(db, id);
+        if (!target) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Memory ${id} not found.`
+              }
+            ]
+          };
+        }
+        const memory = setPinnedState(target.row_id, 1);
         if (!memory) {
           return {
             isError: true,
@@ -1008,7 +1292,20 @@ function registerUnpinMemoryTool(server) {
     },
     async ({ id }) => {
       try {
-        const memory = setPinnedState(id, 0);
+        const db = getDb();
+        const target = findMemoryByAnyId(db, id);
+        if (!target) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Memory ${id} not found.`
+              }
+            ]
+          };
+        }
+        const memory = setPinnedState(target.row_id, 0);
         if (!memory) {
           return {
             isError: true,
@@ -1425,7 +1722,7 @@ function registerRememberTool(server) {
     async ({ note, repo, type, tags }) => {
       try {
         const db = getDb();
-        const resolved = resolveRepoArg(repo, process.cwd(), db);
+        const resolved = resolveRepoArg(repo, getWorkspaceRoot(), db);
         const inferred = inferMemoryFromNote(note);
         const finalType = type ?? inferred.type;
         const finalTags = mergeTagLists2(tags, inferred.tags).slice(0, 5);
@@ -1463,6 +1760,7 @@ function registerRememberTool(server) {
             now,
             existing.row_id
           );
+          indexMemoryEmbedding(db, existing.row_id, longerNote);
           return {
             content: [
               {
@@ -1503,6 +1801,9 @@ function registerRememberTool(server) {
           normalizeText(note)
         );
         const inserted = db.prepare("SELECT rowid AS row_id FROM memories WHERE id = ?").get(id);
+        if (inserted) {
+          indexMemoryEmbedding(db, inserted.row_id, note);
+        }
         return {
           content: [
             {
@@ -1542,7 +1843,7 @@ function registerResolveRepoTool(server) {
     async ({ cwd }) => {
       try {
         const db = getDb();
-        const target = cwd?.trim() || process.cwd();
+        const target = cwd?.trim() || getWorkspaceRoot();
         const resolved = resolveRepo(target, db);
         const payload = {
           canonical: resolved.canonical,
@@ -1582,12 +1883,20 @@ var searchMemoryInputSchema = {
   repo: z8.string().trim().min(1).optional(),
   limit: z8.number().int().positive().max(50).default(5)
 };
-function normalizeFtsQuery(query) {
-  const terms = query.trim().split(/\s+/).map((term) => term.replaceAll('"', '""')).filter(Boolean);
-  if (terms.length === 0) {
-    throw new Error("query must contain searchable text");
+function tokenizeQuery(query) {
+  return query.toLowerCase().replace(/["()]/g, " ").split(/[\s/_\-.,;:!?]+/).map((token) => token.replace(/[^a-z0-9*]/g, "")).filter((token) => token.length >= 2);
+}
+function buildFtsQuery2(tokens) {
+  if (tokens.length === 0) {
+    return null;
   }
-  return terms.map((term) => `"${term}"`).join(" AND ");
+  return tokens.map((token) => `"${token.replace(/"/g, '""')}"`).join(" AND ");
+}
+function buildFtsQueryOr(tokens) {
+  if (tokens.length === 0) {
+    return null;
+  }
+  return tokens.map((token) => `"${token.replace(/"/g, '""')}"`).join(" OR ");
 }
 function parseTags4(raw) {
   try {
@@ -1597,37 +1906,73 @@ function parseTags4(raw) {
     return [];
   }
 }
+function runFts(ftsQuery, resolvedRepo, limit) {
+  const db = getDb();
+  try {
+    if (resolvedRepo) {
+      return db.prepare(
+        `
+            SELECT m.rowid AS row_id, m.id, m.repo, m.type, m.note, m.tags,
+                   m.created_at, m.updated_at, m.pinned, bm25(memories_fts) AS rank
+            FROM memories_fts
+            JOIN memories AS m ON m.rowid = memories_fts.rowid
+            WHERE memories_fts MATCH ? AND m.repo = ?
+            ORDER BY rank
+            LIMIT ?
+          `
+      ).all(ftsQuery, resolvedRepo, limit);
+    }
+    return db.prepare(
+      `
+          SELECT m.rowid AS row_id, m.id, m.repo, m.type, m.note, m.tags,
+                 m.created_at, m.updated_at, m.pinned, bm25(memories_fts) AS rank
+          FROM memories_fts
+          JOIN memories AS m ON m.rowid = memories_fts.rowid
+          WHERE memories_fts MATCH ?
+          ORDER BY rank
+          LIMIT ?
+        `
+    ).all(ftsQuery, limit);
+  } catch {
+    return [];
+  }
+}
 function registerSearchMemoryTool(server) {
   server.registerTool(
     "search_memory",
     {
-      description: "Search memories using full-text search with optional repository filtering.",
+      description: "Search memories using full-text search with optional repository filtering. Falls back to recent + pinned context when the query has no exact matches.",
       inputSchema: searchMemoryInputSchema
     },
     async ({ query, repo, limit }) => {
       try {
         const db = getDb();
-        const ftsQuery = normalizeFtsQuery(query);
-        const resolvedRepo = repo ? resolveRepoArg(repo, process.cwd(), db).canonical : void 0;
-        const rows = resolvedRepo ? db.prepare(
-          `
-                  SELECT m.rowid AS row_id, m.id, m.repo, m.type, m.note, m.tags, m.created_at, m.updated_at, m.pinned, bm25(memories_fts) AS rank
-                  FROM memories_fts
-                  JOIN memories AS m ON m.rowid = memories_fts.rowid
-                  WHERE memories_fts MATCH ? AND m.repo = ?
-                  ORDER BY rank
-                  LIMIT ?
-                `
-        ).all(ftsQuery, resolvedRepo, limit) : db.prepare(
-          `
-                  SELECT m.rowid AS row_id, m.id, m.repo, m.type, m.note, m.tags, m.created_at, m.updated_at, m.pinned, bm25(memories_fts) AS rank
-                  FROM memories_fts
-                  JOIN memories AS m ON m.rowid = memories_fts.rowid
-                  WHERE memories_fts MATCH ?
-                  ORDER BY rank
-                  LIMIT ?
-                `
-        ).all(ftsQuery, limit);
+        const tokens = tokenizeQuery(query);
+        const resolvedRepo = repo ? resolveRepoArg(repo, getWorkspaceRoot(), db).canonical : void 0;
+        const andQuery = buildFtsQuery2(tokens);
+        let rows = [];
+        if (andQuery) {
+          rows = runFts(andQuery, resolvedRepo, limit);
+        }
+        if (rows.length === 0 && tokens.length > 1) {
+          const orQuery = buildFtsQueryOr(tokens);
+          if (orQuery) {
+            rows = runFts(orQuery, resolvedRepo, limit);
+          }
+        }
+        if (rows.length === 0 && resolvedRepo && embeddingsEnabled()) {
+          const semantic = vectorSearch(db, resolvedRepo, query, limit);
+          rows = semantic.map(({ score, ...row }) => ({
+            ...row,
+            rank: score
+          }));
+        }
+        let usedFallback = false;
+        if (rows.length === 0 && resolvedRepo) {
+          const fallback = fetchRepoContext(db, resolvedRepo, limit);
+          rows = fallback.map((row) => ({ ...row, rank: 0 }));
+          usedFallback = fallback.length > 0;
+        }
         if (rows.length === 0) {
           return {
             content: [
@@ -1645,11 +1990,12 @@ function registerSearchMemoryTool(server) {
           return `${index + 1}. [${row.repo}] ${row.type} (${row.row_id} | legacy: ${row.id})
 ${pinPrefix}${row.note}${tagsText}`;
         }).join("\n\n");
+        const header = usedFallback ? `No exact match for "${query}"${resolvedRepo ? ` in ${resolvedRepo}` : ""}; showing recent + pinned context:` : `Search results for "${query}"${resolvedRepo ? ` in ${resolvedRepo}` : ""}:`;
         return {
           content: [
             {
               type: "text",
-              text: `Search results for "${query}"${resolvedRepo ? ` in ${resolvedRepo}` : ""}:
+              text: `${header}
 
 ${formatted}`
             }
@@ -1690,7 +2036,7 @@ function registerStoreContextTool(server) {
     async ({ repo, type, note, tags }) => {
       try {
         const db = getDb();
-        const resolved = resolveRepoArg(repo, process.cwd(), db);
+        const resolved = resolveRepoArg(repo, getWorkspaceRoot(), db);
         const now = Math.floor(Date.now() / 1e3);
         const id = nanoid2();
         const normalizedTags = Array.from(
@@ -1718,6 +2064,9 @@ function registerStoreContextTool(server) {
               WHERE id = ?
             `
         ).get(id);
+        if (stored) {
+          indexMemoryEmbedding(db, stored.row_id, note);
+        }
         return {
           content: [
             {
@@ -1765,7 +2114,7 @@ function registerSummarizeRepoContextTool(server) {
     async ({ repo }) => {
       try {
         const db = getDb();
-        const resolved = resolveRepoArg(repo, process.cwd(), db);
+        const resolved = resolveRepoArg(repo, getWorkspaceRoot(), db);
         const rows = db.prepare(
           `
               SELECT rowid AS row_id, type, note, pinned
@@ -1827,7 +2176,9 @@ ${entries.join("\n")}`);
 // src/tools/update.ts
 import { z as z11 } from "zod";
 var updateMemoryInputSchema = {
-  id: z11.number().int().positive(),
+  // Accept numeric row_id or legacy string id so callers can paste whichever
+  // form they have.
+  id: z11.union([z11.number().int().positive(), z11.string().trim().min(1)]),
   content: z11.string().trim().min(1).optional(),
   memory_type: z11.enum(MEMORY_TYPES).optional()
 };
@@ -1859,7 +2210,7 @@ function registerUpdateMemoryTool(server) {
   server.registerTool(
     "update_memory",
     {
-      description: "Update an existing memory by numeric id with partial fields.",
+      description: "Update an existing memory by id (numeric or legacy string) with partial fields.",
       inputSchema: updateMemoryInputSchema
     },
     async ({ id, content, memory_type }) => {
@@ -1876,14 +2227,8 @@ function registerUpdateMemoryTool(server) {
           };
         }
         const db = getDb();
-        const existing = db.prepare(
-          `
-              SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
-              FROM memories
-              WHERE rowid = ?
-            `
-        ).get(id);
-        if (!existing) {
+        const target = findMemoryByAnyId(db, id);
+        if (!target) {
           return {
             isError: true,
             content: [
@@ -1894,6 +2239,13 @@ function registerUpdateMemoryTool(server) {
             ]
           };
         }
+        const existing = db.prepare(
+          `
+              SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
+              FROM memories
+              WHERE rowid = ?
+            `
+        ).get(target.row_id);
         const now = Math.floor(Date.now() / 1e3);
         const nextType = memory_type ?? existing.type;
         const nextNote = content ?? existing.note;
@@ -1905,7 +2257,8 @@ function registerUpdateMemoryTool(server) {
               SET type = ?, note = ?, note_normalized = ?, updated_at = ?
               WHERE rowid = ?
             `
-          ).run(nextType, nextNote, nextNormalized, now, id);
+          ).run(nextType, nextNote, nextNormalized, now, existing.row_id);
+          indexMemoryEmbedding(db, existing.row_id, nextNote);
         } else {
           db.prepare(
             `
@@ -1913,7 +2266,7 @@ function registerUpdateMemoryTool(server) {
               SET type = ?, note = ?, updated_at = ?
               WHERE rowid = ?
             `
-          ).run(nextType, nextNote, now, id);
+          ).run(nextType, nextNote, now, existing.row_id);
         }
         const updated = db.prepare(
           `
@@ -1921,7 +2274,7 @@ function registerUpdateMemoryTool(server) {
               FROM memories
               WHERE rowid = ?
             `
-        ).get(id);
+        ).get(existing.row_id);
         if (!updated) {
           return {
             isError: true,
@@ -1973,7 +2326,7 @@ function registerStartupContextResource(server) {
     async (uri) => {
       try {
         const db = getDb();
-        const resolved = resolveRepo(process.cwd(), db);
+        const resolved = resolveRepo(getWorkspaceRoot(), db);
         const rows = fetchRepoContext(db, resolved.canonical, 5);
         const text = formatContext(rows, {
           repo: resolved.canonical,
@@ -2010,7 +2363,7 @@ async function startServer() {
   initDb(dbPath);
   const server = new McpServer({
     name: "fossel",
-    version: "1.1.0"
+    version: "1.2.0"
   });
   registerRememberTool(server);
   registerGetContextTool(server);