fossel 1.1.0 → 1.2.0

package/dist/cli.js

@@ -164,6 +164,25 @@ var init_migrate = __esm({
             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;
+      `);
+        }
       }
     ];
   }
@@ -215,6 +234,96 @@ var init_client = __esm({
   }
 });
 
+// src/lib/dedupe.ts
+function normalizeText(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
+}
+function tokenize(text) {
+  return normalizeText(text).split(" ").filter((token) => token.length >= 2);
+}
+function trigrams(text) {
+  const padded = ` ${text} `;
+  const grams = /* @__PURE__ */ new Set();
+  for (let i = 0; i < padded.length - 2; i += 1) {
+    grams.add(padded.slice(i, i + 3));
+  }
+  return grams;
+}
+function jaccard(a, b) {
+  if (a.size === 0 && b.size === 0) {
+    return 1;
+  }
+  let intersection = 0;
+  for (const value of a) {
+    if (b.has(value)) {
+      intersection += 1;
+    }
+  }
+  const union = a.size + b.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+function similarity(a, b) {
+  const normalizedA = normalizeText(a);
+  const normalizedB = normalizeText(b);
+  if (!normalizedA && !normalizedB) {
+    return 1;
+  }
+  if (!normalizedA || !normalizedB) {
+    return 0;
+  }
+  if (normalizedA === normalizedB) {
+    return 1;
+  }
+  const wordScore = jaccard(new Set(tokenize(normalizedA)), new Set(tokenize(normalizedB)));
+  const triScore = jaccard(trigrams(normalizedA), trigrams(normalizedB));
+  return wordScore * 0.55 + triScore * 0.45;
+}
+function findDuplicate(db, repo, note, options = {}) {
+  const threshold = options.threshold ?? DEFAULT_THRESHOLD;
+  const limit = options.candidateLimit ?? DEFAULT_CANDIDATE_LIMIT;
+  const normalized = normalizeText(note);
+  if (!normalized) {
+    return null;
+  }
+  const exact = db.prepare(
+    `
+        SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
+        FROM memories
+        WHERE repo = ? AND note_normalized = ?
+        ORDER BY updated_at DESC
+        LIMIT 1
+      `
+  ).get(repo, normalized);
+  if (exact) {
+    return { memory: exact, similarity: 1 };
+  }
+  const candidates = db.prepare(
+    `
+        SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
+        FROM memories
+        WHERE repo = ?
+        ORDER BY updated_at DESC
+        LIMIT ?
+      `
+  ).all(repo, limit);
+  let best = null;
+  for (const candidate of candidates) {
+    const score = similarity(note, candidate.note);
+    if (score >= threshold && (!best || score > best.similarity)) {
+      best = { memory: candidate, similarity: score };
+    }
+  }
+  return best;
+}
+var DEFAULT_THRESHOLD, DEFAULT_CANDIDATE_LIMIT;
+var init_dedupe = __esm({
+  "src/lib/dedupe.ts"() {
+    "use strict";
+    DEFAULT_THRESHOLD = 0.82;
+    DEFAULT_CANDIDATE_LIMIT = 200;
+  }
+});
+
 // src/lib/repo.ts
 import { spawnSync } from "child_process";
 import { basename } from "path";
@@ -341,7 +450,7 @@ function resolveRepoArg(input, cwd, db) {
 }
 function mergeRepoKeys(db, from, to) {
   if (from === to) {
-    return { movedAliases: 0, movedMemories: 0 };
+    return { movedAliases: 0, movedMemories: 0, rewrittenNotes: 0 };
   }
   const tx = db.transaction(() => {
     const aliasResult = db.prepare("UPDATE repo_aliases SET canonical = ? WHERE canonical = ?").run(to, from);
@@ -358,15 +467,79 @@ function mergeRepoKeys(db, from, to) {
       movedMemories += result.changes;
     }
     movedMemories += updateMemories.run(to, from).changes;
+    const rewrittenNotes = rewriteStaleRepoMentions(db, from, to);
     upsertAlias(db, from, to);
     upsertAlias(db, to, to);
     return {
       movedAliases: aliasResult.changes,
-      movedMemories
+      movedMemories,
+      rewrittenNotes
     };
   });
   return tx();
 }
+function tokenBoundaryReplace(text, from, to) {
+  const escaped = from.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`(^|[^\\w/-])(${escaped})(?=$|[^\\w/-])`, "g");
+  return text.replace(pattern, (_match, prefix) => `${prefix}${to}`);
+}
+function rewriteStaleRepoMentions(db, from, to) {
+  const candidates = db.prepare(
+    `
+        SELECT rowid AS row_id, note, metadata_json
+        FROM memories
+        WHERE note LIKE ?
+      `
+  ).all(`%${from}%`);
+  if (candidates.length === 0) {
+    return 0;
+  }
+  const update = db.prepare(
+    `
+      UPDATE memories
+      SET note = ?, note_normalized = ?, metadata_json = ?, updated_at = ?
+      WHERE rowid = ?
+    `
+  );
+  const now = Math.floor(Date.now() / 1e3);
+  let rewritten = 0;
+  for (const row of candidates) {
+    const next = tokenBoundaryReplace(row.note, from, to);
+    if (next === row.note) {
+      continue;
+    }
+    const normalized = next.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
+    let metadata;
+    try {
+      const parsed = JSON.parse(row.metadata_json);
+      metadata = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    } catch {
+      metadata = {};
+    }
+    metadata.changelog = metadata.changelog ?? [];
+    metadata.changelog.push({
+      at: now,
+      action: "alias_rewrite",
+      previous_note: row.note,
+      rewrote_alias: from
+    });
+    update.run(next, normalized, JSON.stringify(metadata), now, row.row_id);
+    rewritten += 1;
+  }
+  return rewritten;
+}
+function findMemoriesMentioningAlias(db, alias, canonical) {
+  const rows = db.prepare(
+    `
+        SELECT rowid AS row_id, repo, note
+        FROM memories
+        WHERE repo = ? AND note LIKE ?
+      `
+  ).all(canonical, `%${alias}%`);
+  const escaped = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`(^|[^\\w/-])${escaped}(?=$|[^\\w/-])`);
+  return rows.filter((row) => pattern.test(row.note));
+}
 var REMOTE_PATTERNS;
 var init_repo = __esm({
   "src/lib/repo.ts"() {
@@ -384,6 +557,170 @@ var init_repo = __esm({
   }
 });
 
+// src/lib/embeddings.ts
+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 tokenize2(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 = tokenize2(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)
+  );
+}
+var EMBEDDING_DIM, EMBEDDING_VERSION;
+var init_embeddings = __esm({
+  "src/lib/embeddings.ts"() {
+    "use strict";
+    EMBEDDING_DIM = 256;
+    EMBEDDING_VERSION = 1;
+  }
+});
+
+// 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);
+}
+var init_vector_index = __esm({
+  "src/lib/vector-index.ts"() {
+    "use strict";
+    init_embeddings();
+  }
+});
+
 // src/lib/context.ts
 function parseTags(raw) {
   try {
@@ -393,6 +730,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) {
@@ -403,11 +743,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(
@@ -422,7 +770,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
@@ -431,13 +782,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(
@@ -451,15 +809,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);
 }
@@ -522,6 +914,8 @@ var init_context = __esm({
   "src/lib/context.ts"() {
     "use strict";
     init_client();
+    init_embeddings();
+    init_vector_index();
     SECTION_TITLES = {
       convention: "Conventions",
       bug_fix: "Bug Fixes",
@@ -533,93 +927,17 @@ var init_context = __esm({
   }
 });
 
-// src/lib/dedupe.ts
-function normalizeText(text) {
-  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
-}
-function tokenize(text) {
-  return normalizeText(text).split(" ").filter((token) => token.length >= 2);
-}
-function trigrams(text) {
-  const padded = ` ${text} `;
-  const grams = /* @__PURE__ */ new Set();
-  for (let i = 0; i < padded.length - 2; i += 1) {
-    grams.add(padded.slice(i, i + 3));
-  }
-  return grams;
-}
-function jaccard(a, b) {
-  if (a.size === 0 && b.size === 0) {
-    return 1;
-  }
-  let intersection = 0;
-  for (const value of a) {
-    if (b.has(value)) {
-      intersection += 1;
-    }
-  }
-  const union = a.size + b.size - intersection;
-  return union === 0 ? 0 : intersection / union;
-}
-function similarity(a, b) {
-  const normalizedA = normalizeText(a);
-  const normalizedB = normalizeText(b);
-  if (!normalizedA && !normalizedB) {
-    return 1;
-  }
-  if (!normalizedA || !normalizedB) {
-    return 0;
-  }
-  if (normalizedA === normalizedB) {
-    return 1;
-  }
-  const wordScore = jaccard(new Set(tokenize(normalizedA)), new Set(tokenize(normalizedB)));
-  const triScore = jaccard(trigrams(normalizedA), trigrams(normalizedB));
-  return wordScore * 0.55 + triScore * 0.45;
-}
-function findDuplicate(db, repo, note, options = {}) {
-  const threshold = options.threshold ?? DEFAULT_THRESHOLD;
-  const limit = options.candidateLimit ?? DEFAULT_CANDIDATE_LIMIT;
-  const normalized = normalizeText(note);
-  if (!normalized) {
-    return null;
-  }
-  const exact = db.prepare(
-    `
-        SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
-        FROM memories
-        WHERE repo = ? AND note_normalized = ?
-        ORDER BY updated_at DESC
-        LIMIT 1
-      `
-  ).get(repo, normalized);
-  if (exact) {
-    return { memory: exact, similarity: 1 };
-  }
-  const candidates = db.prepare(
-    `
-        SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
-        FROM memories
-        WHERE repo = ?
-        ORDER BY updated_at DESC
-        LIMIT ?
-      `
-  ).all(repo, limit);
-  let best = null;
-  for (const candidate of candidates) {
-    const score = similarity(note, candidate.note);
-    if (score >= threshold && (!best || score > best.similarity)) {
-      best = { memory: candidate, similarity: score };
-    }
+// src/lib/workspace.ts
+function getWorkspaceRoot() {
+  const fromEnv = process.env.FOSSEL_WORKSPACE?.trim();
+  if (fromEnv) {
+    return fromEnv;
   }
-  return best;
+  return process.cwd();
 }
-var DEFAULT_THRESHOLD, DEFAULT_CANDIDATE_LIMIT;
-var init_dedupe = __esm({
-  "src/lib/dedupe.ts"() {
+var init_workspace = __esm({
+  "src/lib/workspace.ts"() {
     "use strict";
-    DEFAULT_THRESHOLD = 0.82;
-    DEFAULT_CANDIDATE_LIMIT = 200;
   }
 });
 
@@ -666,7 +984,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
@@ -798,6 +1116,7 @@ var init_dedupe_repo = __esm({
     init_client();
     init_dedupe();
     init_repo();
+    init_workspace();
     dedupeRepoInputSchema = {
       repo: z.string().trim().min(1).optional(),
       threshold: z.number().min(0.5).max(1).default(0.85),
@@ -806,20 +1125,55 @@ var init_dedupe_repo = __esm({
   }
 });
 
+// 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;
+}
+var init_memory = __esm({
+  "src/lib/memory.ts"() {
+    "use strict";
+  }
+});
+
 // src/tools/delete.ts
 import { z as z2 } from "zod";
 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: [
@@ -830,15 +1184,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}).`
             }
           ]
         };
@@ -862,8 +1216,12 @@ var init_delete = __esm({
   "src/tools/delete.ts"() {
     "use strict";
     init_client();
+    init_memory();
     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)])
     };
   }
 });
@@ -880,7 +1238,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,
@@ -917,6 +1275,7 @@ var init_get_context = __esm({
     init_client();
     init_context();
     init_repo();
+    init_workspace();
     getContextInputSchema = {
       repo: z3.string().trim().min(1).optional(),
       query: z3.string().trim().min(1).optional(),
@@ -949,7 +1308,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
@@ -1020,6 +1379,7 @@ var init_get_repo = __esm({
     "use strict";
     init_client();
     init_repo();
+    init_workspace();
     getRepoContextInputSchema = {
       repo: z4.string().trim().min(1).optional(),
       limit: z4.number().int().positive().max(100).default(10)
@@ -1029,7 +1389,7 @@ var init_get_repo = __esm({
 
 // src/tools/pin.ts
 import { z as z5 } from "zod";
-function setPinnedState(memoryId, pinned) {
+function setPinnedState(rowId, pinned) {
   const db = getDb();
   const now = Math.floor(Date.now() / 1e3);
   const updateResult = db.prepare(
@@ -1038,7 +1398,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;
   }
@@ -1048,7 +1408,7 @@ function setPinnedState(memoryId, pinned) {
         FROM memories
         WHERE rowid = ?
       `
-  ).get(memoryId);
+  ).get(rowId);
 }
 function registerPinMemoryTool(server) {
   server.registerTool(
@@ -1059,7 +1419,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,
@@ -1103,7 +1476,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,
@@ -1143,8 +1529,10 @@ var init_pin = __esm({
   "src/tools/pin.ts"() {
     "use strict";
     init_client();
+    init_memory();
     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)])
     };
   }
 });
@@ -1528,7 +1916,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);
@@ -1566,6 +1954,7 @@ function registerRememberTool(server) {
             now,
             existing.row_id
           );
+          indexMemoryEmbedding(db, existing.row_id, longerNote);
           return {
             content: [
               {
@@ -1606,6 +1995,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: [
             {
@@ -1637,6 +2029,8 @@ var init_remember = __esm({
     init_dedupe();
     init_inference();
     init_repo();
+    init_vector_index();
+    init_workspace();
     rememberInputSchema = {
       note: z6.string().trim().min(1, "note is required"),
       repo: z6.string().trim().min(1).optional(),
@@ -1658,7 +2052,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,
@@ -1696,6 +2090,7 @@ var init_resolve_repo = __esm({
     "use strict";
     init_client();
     init_repo();
+    init_workspace();
     resolveRepoInputSchema = {
       cwd: z7.string().trim().min(1).optional()
     };
@@ -1704,12 +2099,20 @@ var init_resolve_repo = __esm({
 
 // src/tools/search.ts
 import { z as z8 } from "zod";
-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 {
@@ -1719,37 +2122,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: [
@@ -1767,11 +2206,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}`
             }
@@ -1797,7 +2237,11 @@ var init_search = __esm({
   "src/tools/search.ts"() {
     "use strict";
     init_client();
+    init_context();
+    init_embeddings();
     init_repo();
+    init_vector_index();
+    init_workspace();
     searchMemoryInputSchema = {
       query: z8.string().trim().min(1, "query is required"),
       repo: z8.string().trim().min(1).optional(),
@@ -1819,7 +2263,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(
@@ -1847,6 +2291,9 @@ function registerStoreContextTool(server) {
               WHERE id = ?
             `
         ).get(id);
+        if (stored) {
+          indexMemoryEmbedding(db, stored.row_id, note);
+        }
         return {
           content: [
             {
@@ -1877,6 +2324,8 @@ var init_store = __esm({
     init_client();
     init_dedupe();
     init_repo();
+    init_vector_index();
+    init_workspace();
     storeContextInputSchema = {
       repo: z9.string().trim().min(1).optional(),
       type: z9.enum(MEMORY_TYPES),
@@ -1898,7 +2347,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
@@ -1962,6 +2411,7 @@ var init_summarize = __esm({
     "use strict";
     init_client();
     init_repo();
+    init_workspace();
     summarizeRepoContextInputSchema = {
       repo: z10.string().trim().min(1).optional()
     };
@@ -2006,7 +2456,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 }) => {
@@ -2023,14 +2473,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: [
@@ -2041,6 +2485,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;
@@ -2052,7 +2503,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(
             `
@@ -2060,7 +2512,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(
           `
@@ -2068,7 +2520,7 @@ function registerUpdateMemoryTool(server) {
               FROM memories
               WHERE rowid = ?
             `
-        ).get(id);
+        ).get(existing.row_id);
         if (!updated) {
           return {
             isError: true,
@@ -2109,8 +2561,12 @@ var init_update = __esm({
     "use strict";
     init_client();
     init_dedupe();
+    init_memory();
+    init_vector_index();
     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()
     };
@@ -2143,7 +2599,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,
@@ -2180,7 +2636,7 @@ async function startServer() {
   initDb(dbPath);
   const server = new McpServer({
     name: "fossel",
-    version: "1.1.0"
+    version: "1.2.0"
   });
   registerRememberTool(server);
   registerGetContextTool(server);
@@ -2205,6 +2661,7 @@ var init_index = __esm({
     init_client();
     init_context();
     init_repo();
+    init_workspace();
     init_dedupe_repo();
     init_delete();
     init_get_context();
@@ -2230,13 +2687,14 @@ var init_index = __esm({
 
 // src/cli.ts
 init_client();
+init_dedupe();
 init_repo();
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
 import { statSync } from "fs";
 import { nanoid as nanoid3 } from "nanoid";
 var DEFAULT_DB_PATH = join2(homedir2(), ".fossel", "memory.db");
-var INIT_MEMORY_TEXT = "Fossel is active for this repo. Use store_context to save context.";
+var INIT_MEMORY_TEXT = "Fossel is active for this repo. Say 'remember this' or call get_context to retrieve repo memories.";
 function resolveDbPath2() {
   return process.env.FOSSEL_DB_PATH?.trim() || DEFAULT_DB_PATH;
 }
@@ -2260,7 +2718,7 @@ function ensureSampleMemoryIfEmpty(repo) {
     "[]",
     now,
     now,
-    INIT_MEMORY_TEXT.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim()
+    normalizeText(INIT_MEMORY_TEXT)
   );
   return true;
 }
@@ -2269,7 +2727,12 @@ var MCP_CONFIG_SNIPPET = JSON.stringify(
     mcpServers: {
       fossel: {
         command: "npx",
-        args: ["-y", "fossel"]
+        args: ["-y", "fossel"],
+        // FOSSEL_WORKSPACE pins the workspace root so the server detects the
+        // right repo even when the IDE launches MCP servers from another cwd.
+        env: {
+          FOSSEL_WORKSPACE: "${workspaceFolder}"
+        }
       }
     }
   },
@@ -2293,7 +2756,44 @@ function findMergeCandidates(canonical) {
     return otherTail === tail || otherTail === canonical || row.repo === tail;
   });
 }
-function runInit() {
+function autoDedupeExact(repo) {
+  const db = getDb();
+  const groups = db.prepare(
+    `
+        SELECT note_normalized, type, COUNT(*) AS count
+        FROM memories
+        WHERE repo = ? AND note_normalized != ''
+        GROUP BY note_normalized, type
+        HAVING COUNT(*) > 1
+      `
+  ).all(repo);
+  if (groups.length === 0) {
+    return 0;
+  }
+  let removed = 0;
+  const tx = db.transaction(() => {
+    for (const group of groups) {
+      const rows = db.prepare(
+        `
+            SELECT rowid AS row_id, pinned, updated_at
+            FROM memories
+            WHERE repo = ? AND note_normalized = ? AND type = ?
+            ORDER BY pinned DESC, updated_at DESC, rowid DESC
+          `
+      ).all(repo, group.note_normalized, group.type);
+      const [keep, ...rest] = rows;
+      if (!keep) continue;
+      const drop = db.prepare("DELETE FROM memories WHERE rowid = ?");
+      for (const row of rest) {
+        drop.run(row.row_id);
+        removed += 1;
+      }
+    }
+  });
+  tx();
+  return removed;
+}
+function runInit(options) {
   const dbPath = resolveDbPath2();
   initDb(dbPath);
   const db = getDb();
@@ -2301,12 +2801,18 @@ function runInit() {
   const candidates = findMergeCandidates(resolved.canonical);
   let mergedAliases = 0;
   let mergedMemories = 0;
+  let rewrittenNotes = 0;
   for (const candidate of candidates) {
     const result = mergeRepoKeys(db, candidate.repo, resolved.canonical);
     mergedAliases += result.movedAliases;
     mergedMemories += result.movedMemories;
+    rewrittenNotes += result.rewrittenNotes;
   }
   const sampleAdded = ensureSampleMemoryIfEmpty(resolved.canonical);
+  let autoMerged = 0;
+  if (options.autoDedupe) {
+    autoMerged = autoDedupeExact(resolved.canonical);
+  }
   const countRow = db.prepare("SELECT COUNT(*) AS count FROM memories WHERE repo = ?").get(resolved.canonical);
   console.log("Fossel \u2014 local-first MCP memory for your repos.\n");
   console.log(`Canonical repo key: ${resolved.canonical}`);
@@ -2318,12 +2824,16 @@ function runInit() {
     console.log(`  aliases: ${resolved.aliases.join(", ")}`);
   }
   console.log("");
-  if (mergedAliases > 0 || mergedMemories > 0) {
+  if (mergedAliases > 0 || mergedMemories > 0 || rewrittenNotes > 0) {
     console.log(
-      `Merged ${mergedMemories} memory row(s) and ${mergedAliases} alias row(s) into ${resolved.canonical}.`
+      `Merged ${mergedMemories} memory row(s), ${mergedAliases} alias row(s), and rewrote ${rewrittenNotes} stale mention(s) into ${resolved.canonical}.`
     );
     console.log("");
   }
+  if (autoMerged > 0) {
+    console.log(`Auto-deduped ${autoMerged} exact duplicate row(s).`);
+    console.log("");
+  }
   console.log("MCP config (Cursor: ~/.cursor/mcp.json, Claude Desktop: settings):");
   console.log(MCP_CONFIG_SNIPPET);
   console.log("");
@@ -2339,9 +2849,11 @@ function runInit() {
   console.log("  resolve_repo       \u2014 show which repo key Fossel will use");
   console.log("  store_context      \u2014 explicit save (advanced)");
   console.log("  dedupe_repo        \u2014 merge near-duplicate memories");
+  console.log("");
+  console.log("Set FOSSEL_WORKSPACE in your MCP config to your project root if Fossel detects the wrong repo.");
   closeDb();
 }
-function runDoctor() {
+function gatherDoctorReport() {
   const dbPath = resolveDbPath2();
   const lines = [];
   let ok = true;
@@ -2366,6 +2878,22 @@ function runDoctor() {
   } else {
     lines.push("No sibling repo keys.");
   }
+  const staleMentions = [];
+  for (const alias of resolved.aliases) {
+    if (alias === resolved.canonical) continue;
+    const found2 = findMemoriesMentioningAlias(db, alias, resolved.canonical);
+    for (const row of found2) {
+      staleMentions.push({ alias, row_id: row.row_id, note: row.note });
+    }
+  }
+  if (staleMentions.length > 0) {
+    ok = false;
+    lines.push(
+      `\u26A0 ${staleMentions.length} memory note(s) still mention a deprecated repo key. Run \`fossel doctor --fix\` to rewrite them.`
+    );
+  } else {
+    lines.push("No memory notes reference deprecated repo keys.");
+  }
   const duplicateRows = db.prepare(
     `
         SELECT note_normalized, COUNT(*) AS count
@@ -2379,7 +2907,7 @@ function runDoctor() {
     ok = false;
     const total = duplicateRows.reduce((sum, row) => sum + row.count - 1, 0);
     lines.push(
-      `\u26A0 ${duplicateRows.length} duplicate clusters covering ${total} extra row(s). Run \`dedupe_repo\` with apply=true.`
+      `\u26A0 ${duplicateRows.length} duplicate clusters covering ${total} extra row(s). Run \`fossel doctor --fix\` (or \`dedupe_repo\` with apply=true) to merge.`
     );
   } else {
     lines.push("No exact-duplicate memory clusters.");
@@ -2393,7 +2921,13 @@ function runDoctor() {
       "Claude",
       "claude_desktop_config.json"
     ),
-    join2(homedir2(), "Library", "Application Support", "Claude", "claude_desktop_config.json")
+    join2(
+      homedir2(),
+      "Library",
+      "Application Support",
+      "Claude",
+      "claude_desktop_config.json"
+    )
   ];
   const found = mcpConfigCandidates.filter((path) => {
     try {
@@ -2411,13 +2945,41 @@ function runDoctor() {
   }
   const totalRow = db.prepare("SELECT COUNT(*) AS count FROM memories").get();
   lines.push(`Total memories across all repos: ${totalRow.count}`);
-  closeDb();
-  console.log(lines.join("\n"));
+  return { ok, lines, duplicateClusters: duplicateRows.length, staleMentions };
+}
+function runDoctor(options) {
+  const report = gatherDoctorReport();
+  console.log(report.lines.join("\n"));
   console.log("");
-  console.log(ok ? "Status: OK" : "Status: needs attention (see \u26A0 lines above)");
-  if (!ok) {
-    process.exitCode = 1;
+  if (!options.fix) {
+    console.log(report.ok ? "Status: OK" : "Status: needs attention (see \u26A0 lines above)");
+    if (!report.ok) {
+      process.exitCode = 1;
+    }
+    closeDb();
+    return;
   }
+  const db = getDb();
+  const resolved = resolveRepo(process.cwd(), db);
+  const candidates = findMergeCandidates(resolved.canonical);
+  let movedMemories = 0;
+  let rewrittenNotes = 0;
+  for (const candidate of candidates) {
+    const result = mergeRepoKeys(db, candidate.repo, resolved.canonical);
+    movedMemories += result.movedMemories;
+    rewrittenNotes += result.rewrittenNotes;
+  }
+  const removed = autoDedupeExact(resolved.canonical);
+  console.log("Applied fixes:");
+  console.log(`  merged repo memory rows:  ${movedMemories}`);
+  console.log(`  rewrote stale mentions:   ${rewrittenNotes}`);
+  console.log(`  removed exact duplicates: ${removed}`);
+  console.log("");
+  console.log("Re-run `fossel doctor` to verify.");
+  closeDb();
+}
+function parseFlag(args, name) {
+  return args.includes(`--${name}`);
 }
 async function main() {
   const command = process.argv[2];
@@ -2427,15 +2989,18 @@ async function main() {
     return;
   }
   if (command === "init") {
-    runInit();
+    const args = process.argv.slice(3);
+    const autoDedupe = !parseFlag(args, "no-dedupe");
+    runInit({ autoDedupe });
     return;
   }
   if (command === "doctor") {
-    runDoctor();
+    const args = process.argv.slice(3);
+    runDoctor({ fix: parseFlag(args, "fix") });
     return;
   }
   console.error(`Unknown command: ${command}`);
-  console.error("Usage: fossel [init | doctor]");
+  console.error("Usage: fossel [init [--no-dedupe] | doctor [--fix]]");
   process.exit(1);
 }
 main().catch((error) => {