fossel 1.0.9 → 1.1.1

package/dist/cli.js

@@ -14,6 +14,9 @@ function hasColumn(db, tableName, columnName) {
   const columns = db.prepare(`PRAGMA table_info(${tableName})`).all();
   return columns.some((column) => column.name === columnName);
 }
+function normalizeNoteForMigration(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
+}
 function runMigrations(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS migrations (
@@ -108,6 +111,59 @@ var init_migrate = __esm({
         `);
           }
         }
+      },
+      {
+        name: "004_add_repo_aliases",
+        apply: (db) => {
+          db.exec(`
+        CREATE TABLE IF NOT EXISTS repo_aliases (
+          alias TEXT PRIMARY KEY,
+          canonical TEXT NOT NULL,
+          created_at INTEGER NOT NULL
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_repo_aliases_canonical
+          ON repo_aliases (canonical);
+      `);
+        }
+      },
+      {
+        name: "005_add_memories_metadata_json",
+        apply: (db) => {
+          if (!hasColumn(db, "memories", "metadata_json")) {
+            db.exec(`
+          ALTER TABLE memories
+          ADD COLUMN metadata_json TEXT NOT NULL DEFAULT '{}';
+        `);
+          }
+        }
+      },
+      {
+        name: "006_add_memories_note_normalized",
+        apply: (db) => {
+          if (!hasColumn(db, "memories", "note_normalized")) {
+            db.exec(`
+          ALTER TABLE memories
+          ADD COLUMN note_normalized TEXT NOT NULL DEFAULT '';
+        `);
+          }
+          db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_memories_note_normalized
+          ON memories (repo, note_normalized);
+      `);
+          const rows = db.prepare("SELECT rowid AS row_id, note FROM memories WHERE note_normalized = ''").all();
+          if (rows.length > 0) {
+            const update = db.prepare(
+              "UPDATE memories SET note_normalized = ? WHERE rowid = ?"
+            );
+            const tx = db.transaction((batch) => {
+              for (const row of batch) {
+                update.run(normalizeNoteForMigration(row.note), row.row_id);
+              }
+            });
+            tx(rows);
+          }
+        }
       }
     ];
   }
@@ -159,50 +215,664 @@ var init_client = __esm({
   }
 });
 
-// src/tools/delete.ts
+// 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";
+function normalizeGitRemote(remoteUrl) {
+  const trimmed = remoteUrl.trim();
+  if (!trimmed) {
+    return null;
+  }
+  for (const pattern of REMOTE_PATTERNS) {
+    const match = pattern.exec(trimmed);
+    if (!match) {
+      continue;
+    }
+    const path = match[2]?.replace(/^\/+/, "").replace(/\\/g, "/").replace(/\.git$/i, "").replace(/\/+$/, "");
+    if (!path) {
+      continue;
+    }
+    return path;
+  }
+  return null;
+}
+function readGitRemote(cwd) {
+  const result = spawnSync("git", ["remote", "get-url", "origin"], {
+    cwd,
+    encoding: "utf8"
+  });
+  if (result.status !== 0) {
+    return null;
+  }
+  const value = result.stdout.trim();
+  return value.length > 0 ? value : null;
+}
+function detectFolderName(cwd) {
+  const name = basename(cwd);
+  return name.length > 0 ? name : cwd;
+}
+function fetchAliases(db, canonical) {
+  const rows = db.prepare("SELECT alias FROM repo_aliases WHERE canonical = ? ORDER BY alias").all(canonical);
+  return rows.map((row) => row.alias);
+}
+function upsertAlias(db, alias, canonical) {
+  const trimmed = alias.trim();
+  const target = canonical.trim();
+  if (!trimmed || !target) {
+    return;
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  db.prepare(
+    `
+      INSERT INTO repo_aliases (alias, canonical, created_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(alias) DO UPDATE SET canonical = excluded.canonical
+    `
+  ).run(trimmed, target, now);
+}
+function lookupAlias(db, alias) {
+  const row = db.prepare("SELECT alias, canonical FROM repo_aliases WHERE alias = ?").get(alias);
+  return row ?? null;
+}
+function resolveRepo(cwd, db) {
+  const gitRemote = readGitRemote(cwd);
+  const fromRemote = gitRemote ? normalizeGitRemote(gitRemote) : null;
+  const folder = detectFolderName(cwd);
+  let canonical;
+  let source;
+  if (fromRemote) {
+    canonical = fromRemote;
+    source = "git-remote";
+  } else {
+    canonical = folder;
+    source = "folder";
+  }
+  upsertAlias(db, canonical, canonical);
+  if (folder && folder !== canonical) {
+    const existing = lookupAlias(db, folder);
+    if (!existing) {
+      upsertAlias(db, folder, canonical);
+    }
+  }
+  return {
+    canonical,
+    cwd,
+    gitRemote,
+    source,
+    aliases: fetchAliases(db, canonical)
+  };
+}
+function resolveRepoArg(input, cwd, db) {
+  const trimmed = input?.trim();
+  if (!trimmed) {
+    return resolveRepo(cwd, db);
+  }
+  const aliasRow = lookupAlias(db, trimmed);
+  if (aliasRow) {
+    return {
+      canonical: aliasRow.canonical,
+      cwd,
+      gitRemote: null,
+      source: "alias",
+      aliases: fetchAliases(db, aliasRow.canonical)
+    };
+  }
+  const workspace = resolveRepo(cwd, db);
+  if (workspace.canonical && workspace.canonical !== trimmed) {
+    const tail = workspace.canonical.split("/").at(-1) ?? workspace.canonical;
+    const inputTail = trimmed.split("/").at(-1) ?? trimmed;
+    if (tail === inputTail || tail === trimmed || inputTail === workspace.canonical) {
+      upsertAlias(db, trimmed, workspace.canonical);
+      return {
+        ...workspace,
+        source: "alias",
+        aliases: fetchAliases(db, workspace.canonical)
+      };
+    }
+  }
+  upsertAlias(db, trimmed, trimmed);
+  return {
+    canonical: trimmed,
+    cwd,
+    gitRemote: null,
+    source: "input",
+    aliases: fetchAliases(db, trimmed)
+  };
+}
+function mergeRepoKeys(db, from, to) {
+  if (from === to) {
+    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);
+    const aliasesToReassign = db.prepare("SELECT alias FROM repo_aliases WHERE canonical = ?").all(to);
+    let movedMemories = 0;
+    const updateMemories = db.prepare(
+      "UPDATE memories SET repo = ? WHERE repo = ?"
+    );
+    for (const { alias } of aliasesToReassign) {
+      if (alias === to) {
+        continue;
+      }
+      const result = updateMemories.run(to, alias);
+      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,
+      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"() {
+    "use strict";
+    REMOTE_PATTERNS = [
+      // git@github.com:owner/repo.git, git@gitlab.com:group/sub/repo.git
+      /^[^@\s]+@([^:]+):([^\s]+?)(?:\.git)?$/,
+      // ssh://git@github.com/owner/repo.git
+      /^ssh:\/\/[^@/]+@([^/]+)\/([^\s]+?)(?:\.git)?$/,
+      // https://github.com/owner/repo.git, http://gitlab.com/group/sub/repo
+      /^https?:\/\/(?:[^@/]+@)?([^/]+)\/([^\s]+?)(?:\.git)?$/,
+      // git://github.com/owner/repo.git
+      /^git:\/\/([^/]+)\/([^\s]+?)(?:\.git)?$/
+    ];
+  }
+});
+
+// src/lib/context.ts
+function parseTags(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
+  } catch {
+    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) {
+    return null;
+  }
+  return terms.map((term) => `"${term}"`).join(" AND ");
+}
+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(
+    `
+        SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
+        FROM memories
+        WHERE repo = ? AND pinned = 1
+        ORDER BY updated_at DESC
+        LIMIT ?
+      `
+  ).all(repo, limit);
+  for (const row of pinned) {
+    push(row, "pinned");
+  }
+  if (rows.length < limit) {
+    const recent = db.prepare(
+      `
+          SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
+          FROM memories
+          WHERE repo = ? AND pinned = 0
+          ORDER BY updated_at DESC
+          LIMIT ?
+        `
+    ).all(repo, limit - rows.length);
+    for (const row of recent) {
+      push(row, "recent");
+    }
+  }
+  if (query && rows.length < limit) {
+    const ftsQuery = buildFtsQuery(query);
+    if (ftsQuery) {
+      try {
+        const matches = 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, repo, limit);
+        for (const row of matches) {
+          push(row, "search", row.rank);
+          if (rows.length >= limit) {
+            break;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return rows.slice(0, limit);
+}
+function formatContext(rows, options) {
+  const { repo, query, format = "text" } = options;
+  if (rows.length === 0) {
+    if (format === "markdown") {
+      return `# Fossel context: ${repo}
+
+No memories found${query ? ` for "${query}"` : ""}.`;
+    }
+    return `No memories found for ${repo}${query ? ` matching "${query}"` : ""}.`;
+  }
+  if (format === "markdown") {
+    return formatMarkdown(rows, repo, query);
+  }
+  return formatText(rows, repo, query);
+}
+function formatMarkdown(rows, repo, query) {
+  const sections = [`# Fossel context: ${repo}`];
+  if (query) {
+    sections.push(`Query: \`${query}\``);
+  }
+  const pinned = rows.filter((row) => row.pinned === 1);
+  if (pinned.length > 0) {
+    sections.push(["## \u{1F4CC} Pinned", ...pinned.map(renderMarkdownRow)].join("\n"));
+  }
+  for (const type of MEMORY_TYPES) {
+    const entries = rows.filter((row) => row.pinned !== 1 && row.type === type);
+    if (entries.length === 0) {
+      continue;
+    }
+    sections.push(
+      [`## ${SECTION_TITLES[type]}`, ...entries.map(renderMarkdownRow)].join("\n")
+    );
+  }
+  return sections.join("\n\n");
+}
+function renderMarkdownRow(row) {
+  const tags = parseTags(row.tags);
+  const tagSuffix = tags.length > 0 ? ` _(${tags.join(", ")})_` : "";
+  return `- (${row.row_id}) ${row.note}${tagSuffix}`;
+}
+function formatText(rows, repo, query) {
+  const header = query ? `Repository context for ${repo} (query: "${query}")` : `Repository context for ${repo}`;
+  const lines = [header, `Total: ${rows.length}`, ""];
+  for (const row of rows) {
+    const tags = parseTags(row.tags);
+    const tagSuffix = tags.length > 0 ? ` [tags: ${tags.join(", ")}]` : "";
+    const pinPrefix = row.pinned ? "\u{1F4CC} " : "";
+    const sourceLabel = row.source === "search" ? " [match]" : "";
+    lines.push(
+      `- (${row.row_id} | ${row.type})${sourceLabel} ${pinPrefix}${row.note}${tagSuffix}`
+    );
+  }
+  return lines.join("\n");
+}
+var SECTION_TITLES;
+var init_context = __esm({
+  "src/lib/context.ts"() {
+    "use strict";
+    init_client();
+    SECTION_TITLES = {
+      convention: "Conventions",
+      bug_fix: "Bug Fixes",
+      reviewer_pattern: "Reviewer Patterns",
+      decision: "Decisions",
+      issue: "Issues",
+      general: "General"
+    };
+  }
+});
+
+// src/lib/workspace.ts
+function getWorkspaceRoot() {
+  const fromEnv = process.env.FOSSEL_WORKSPACE?.trim();
+  if (fromEnv) {
+    return fromEnv;
+  }
+  return process.cwd();
+}
+var init_workspace = __esm({
+  "src/lib/workspace.ts"() {
+    "use strict";
+  }
+});
+
+// src/tools/dedupe-repo.ts
 import { z } from "zod";
-function registerDeleteMemoryTool(server) {
+function parseTags2(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function parseMetadata(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return {};
+}
+function mergeTagLists(...lists) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const list of lists) {
+    for (const value of list) {
+      const trimmed = value.trim().toLowerCase();
+      if (!trimmed || seen.has(trimmed)) continue;
+      seen.add(trimmed);
+      out.push(trimmed);
+    }
+  }
+  return out;
+}
+function registerDedupeRepoTool(server) {
   server.registerTool(
-    "delete_memory",
+    "dedupe_repo",
     {
-      description: "Delete a memory from storage by id.",
-      inputSchema: deleteMemoryInputSchema
+      description: "Scan a repository for near-duplicate memories. Returns a plan by default; pass apply=true to merge duplicates into the most recently updated row, appending a changelog entry to metadata_json.",
+      inputSchema: dedupeRepoInputSchema
     },
-    async ({ id }) => {
+    async ({ repo, threshold, apply }) => {
       try {
         const db = getDb();
-        const row = db.prepare("SELECT id FROM memories WHERE id = ?").get(id);
-        if (!row) {
+        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
+              FROM memories
+              WHERE repo = ?
+              ORDER BY updated_at DESC
+            `
+        ).all(resolved.canonical);
+        if (rows.length < 2) {
           return {
-            isError: true,
             content: [
               {
                 type: "text",
-                text: `Memory ${id} not found.`
+                text: `No duplicates possible: only ${rows.length} memory in ${resolved.canonical}.`
+              }
+            ]
+          };
+        }
+        const consumed = /* @__PURE__ */ new Set();
+        const plan = [];
+        for (let i = 0; i < rows.length; i += 1) {
+          const keep = rows[i];
+          if (!keep || consumed.has(keep.row_id)) continue;
+          for (let j = i + 1; j < rows.length; j += 1) {
+            const other = rows[j];
+            if (!other || consumed.has(other.row_id)) continue;
+            if (other.type !== keep.type) continue;
+            const score = similarity(keep.note, other.note);
+            if (score >= threshold) {
+              plan.push({ keep: keep.row_id, drop: other.row_id, similarity: score });
+              consumed.add(other.row_id);
+            }
+          }
+        }
+        if (plan.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No duplicates \u2265 ${threshold} found in ${resolved.canonical} (${rows.length} memories scanned).`
+              }
+            ]
+          };
+        }
+        if (!apply) {
+          const lines = plan.map(
+            (entry) => `- keep ${entry.keep}, drop ${entry.drop} (similarity ${entry.similarity.toFixed(2)})`
+          );
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Dry run for ${resolved.canonical}. Found ${plan.length} duplicate pair(s):
+${lines.join("\n")}
+
+Re-run with apply=true to merge.`
               }
             ]
           };
         }
-        const deleteTx = db.transaction((memoryId) => {
-          db.prepare("DELETE FROM memories WHERE id = ?").run(memoryId);
+        const byId = new Map(rows.map((row) => [row.row_id, row]));
+        const now = Math.floor(Date.now() / 1e3);
+        let merged = 0;
+        const tx = db.transaction((entries) => {
+          for (const entry of entries) {
+            const keep = byId.get(entry.keep);
+            const drop = byId.get(entry.drop);
+            if (!keep || !drop) continue;
+            const longerNote = keep.note.length >= drop.note.length ? keep.note : drop.note;
+            const mergedTags = mergeTagLists(parseTags2(keep.tags), parseTags2(drop.tags));
+            const metadata = parseMetadata(keep.metadata_json);
+            const changelog = metadata.changelog ?? [];
+            changelog.push({
+              at: now,
+              action: "deduped",
+              similarity: Number(entry.similarity.toFixed(3)),
+              merged_from: drop.row_id,
+              previous_note: drop.note
+            });
+            metadata.changelog = changelog;
+            db.prepare(
+              `
+                UPDATE memories
+                SET note = ?, note_normalized = ?, tags = ?, metadata_json = ?, updated_at = ?,
+                    pinned = CASE WHEN pinned = 1 OR ? = 1 THEN 1 ELSE pinned END
+                WHERE rowid = ?
+              `
+            ).run(
+              longerNote,
+              normalizeText(longerNote),
+              JSON.stringify(mergedTags),
+              JSON.stringify(metadata),
+              now,
+              drop.pinned,
+              keep.row_id
+            );
+            db.prepare("DELETE FROM memories WHERE rowid = ?").run(drop.row_id);
+            merged += 1;
+          }
         });
-        deleteTx(id);
+        tx(plan);
         return {
           content: [
             {
               type: "text",
-              text: `Deleted memory ${id}.`
+              text: `Merged ${merged} duplicate pair(s) in ${resolved.canonical}.`
             }
           ]
         };
       } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error while deleting memory.";
+        const message = error instanceof Error ? error.message : "Unknown error while deduping repo.";
         return {
           isError: true,
           content: [
             {
               type: "text",
-              text: `Failed to delete memory: ${message}`
+              text: `Failed to dedupe repo: ${message}`
             }
           ]
         };
@@ -210,20 +880,185 @@ function registerDeleteMemoryTool(server) {
     }
   );
 }
-var deleteMemoryInputSchema;
-var init_delete = __esm({
-  "src/tools/delete.ts"() {
+var dedupeRepoInputSchema;
+var init_dedupe_repo = __esm({
+  "src/tools/dedupe-repo.ts"() {
     "use strict";
     init_client();
-    deleteMemoryInputSchema = {
-      id: z.string().trim().min(1, "id is required")
+    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),
+      apply: z.boolean().default(false)
     };
   }
 });
 
-// src/tools/get-repo.ts
-import { z as z2 } from "zod";
-function parseTags(raw) {
+// 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. Accepts either the numeric row id or the legacy string id.",
+      inputSchema: deleteMemoryInputSchema
+    },
+    async ({ id }) => {
+      try {
+        const db = getDb();
+        const memory = findMemoryByAnyId(db, id);
+        if (!memory) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Memory ${id} not found.`
+              }
+            ]
+          };
+        }
+        const deleteTx = db.transaction((rowId) => {
+          db.prepare("DELETE FROM memories WHERE rowid = ?").run(rowId);
+        });
+        deleteTx(memory.row_id);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Deleted memory ${memory.row_id} (legacy: ${memory.id}).`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error while deleting memory.";
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Failed to delete memory: ${message}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+var deleteMemoryInputSchema;
+var init_delete = __esm({
+  "src/tools/delete.ts"() {
+    "use strict";
+    init_client();
+    init_memory();
+    deleteMemoryInputSchema = {
+      // 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)])
+    };
+  }
+});
+
+// src/tools/get-context.ts
+import { z as z3 } from "zod";
+function registerGetContextTool(server) {
+  server.registerTool(
+    "get_context",
+    {
+      description: "Unified retrieval tool. Returns pinned memories first, then recent ones, then FTS matches when a query is provided. Default limit is tuned for direct injection into an LLM system prompt. Use format='markdown' for a PR-ready brief.",
+      inputSchema: getContextInputSchema
+    },
+    async ({ repo, query, limit, format }) => {
+      try {
+        const db = getDb();
+        const resolved = resolveRepoArg(repo, getWorkspaceRoot(), db);
+        const rows = fetchRepoContext(db, resolved.canonical, limit, query);
+        const text = formatContext(rows, {
+          repo: resolved.canonical,
+          query,
+          format
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error while fetching context.";
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Failed to fetch context: ${message}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+var getContextInputSchema;
+var init_get_context = __esm({
+  "src/tools/get-context.ts"() {
+    "use strict";
+    init_client();
+    init_context();
+    init_repo();
+    init_workspace();
+    getContextInputSchema = {
+      repo: z3.string().trim().min(1).optional(),
+      query: z3.string().trim().min(1).optional(),
+      limit: z3.number().int().positive().max(50).default(8),
+      format: z3.enum(["text", "markdown"]).default("text")
+    };
+  }
+});
+
+// src/tools/get-repo.ts
+import { z as z4 } from "zod";
+function parseTags3(raw) {
   try {
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
@@ -238,12 +1073,13 @@ function registerGetRepoContextTool(server) {
   server.registerTool(
     "get_repo_context",
     {
-      description: "Get recent memories for a repository grouped by memory type.",
+      description: "Get recent memories for a repository grouped by memory type. The repo argument is resolved to a canonical key automatically; omit it to use the current workspace.",
       inputSchema: getRepoContextInputSchema
     },
     async ({ repo, limit }) => {
       try {
         const db = getDb();
+        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
@@ -252,20 +1088,20 @@ function registerGetRepoContextTool(server) {
               ORDER BY pinned DESC, updated_at DESC
               LIMIT ?
             `
-        ).all(repo, limit);
+        ).all(resolved.canonical, limit);
         if (rows.length === 0) {
           return {
             content: [
               {
                 type: "text",
-                text: `No memories found for ${repo}.`
+                text: `No memories found for ${resolved.canonical}.`
               }
             ]
           };
         }
         const grouped = /* @__PURE__ */ new Map();
         for (const memory of rows) {
-          const tags = parseTags(memory.tags);
+          const tags = parseTags3(memory.tags);
           const tagSuffix = tags.length > 0 ? ` [tags: ${tags.join(", ")}]` : "";
           const pinPrefix = memory.pinned ? "\u{1F4CC} Pinned " : "";
           const item = `- (${memory.row_id} | legacy: ${memory.id}) ${pinPrefix}${memory.note}${tagSuffix}`;
@@ -286,7 +1122,7 @@ ${entries.join("\n")}`);
           content: [
             {
               type: "text",
-              text: `Repository context for ${repo}
+              text: `Repository context for ${resolved.canonical}
 Total memories: ${rows.length}
 
 ${sections.join("\n\n")}`
@@ -313,73 +1149,638 @@ var init_get_repo = __esm({
   "src/tools/get-repo.ts"() {
     "use strict";
     init_client();
+    init_repo();
+    init_workspace();
     getRepoContextInputSchema = {
-      repo: z2.string().trim().min(1, "repo is required"),
-      limit: z2.number().int().positive().max(100).default(10)
+      repo: z4.string().trim().min(1).optional(),
+      limit: z4.number().int().positive().max(100).default(10)
+    };
+  }
+});
+
+// src/tools/pin.ts
+import { z as z5 } from "zod";
+function setPinnedState(rowId, pinned) {
+  const db = getDb();
+  const now = Math.floor(Date.now() / 1e3);
+  const updateResult = db.prepare(
+    `
+        UPDATE memories
+        SET pinned = ?, updated_at = ?
+        WHERE rowid = ?
+      `
+  ).run(pinned, now, rowId);
+  if (updateResult.changes === 0) {
+    return null;
+  }
+  return db.prepare(
+    `
+        SELECT rowid AS row_id, note, pinned
+        FROM memories
+        WHERE rowid = ?
+      `
+  ).get(rowId);
+}
+function registerPinMemoryTool(server) {
+  server.registerTool(
+    "pin_memory",
+    {
+      description: "Pin a memory to keep it at the top of repository context.",
+      inputSchema: pinInputSchema
+    },
+    async ({ id }) => {
+      try {
+        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,
+            content: [
+              {
+                type: "text",
+                text: `Memory ${id} not found.`
+              }
+            ]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Pinned memory ${memory.row_id}: ${memory.note}`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error while pinning memory.";
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Failed to pin memory: ${message}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerUnpinMemoryTool(server) {
+  server.registerTool(
+    "unpin_memory",
+    {
+      description: "Unpin a previously pinned memory.",
+      inputSchema: pinInputSchema
+    },
+    async ({ id }) => {
+      try {
+        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,
+            content: [
+              {
+                type: "text",
+                text: `Memory ${id} not found.`
+              }
+            ]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Unpinned memory ${memory.row_id}.`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error while unpinning memory.";
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Failed to unpin memory: ${message}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+var pinInputSchema;
+var init_pin = __esm({
+  "src/tools/pin.ts"() {
+    "use strict";
+    init_client();
+    init_memory();
+    pinInputSchema = {
+      // 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)])
     };
   }
-});
-
-// src/tools/pin.ts
-import { z as z3 } from "zod";
-function setPinnedState(memoryId, pinned) {
-  const db = getDb();
-  const now = Math.floor(Date.now() / 1e3);
-  const updateResult = db.prepare(
-    `
-        UPDATE memories
-        SET pinned = ?, updated_at = ?
-        WHERE rowid = ?
-      `
-  ).run(pinned, now, memoryId);
-  if (updateResult.changes === 0) {
-    return null;
+});
+
+// src/lib/inference.ts
+function inferMemoryType(text) {
+  const scores = /* @__PURE__ */ new Map();
+  for (const rule of TYPE_RULES) {
+    let score = 0;
+    for (const { pattern, weight } of rule.patterns) {
+      if (pattern.test(text)) {
+        score += weight;
+      }
+    }
+    if (score > 0) {
+      scores.set(rule.type, (scores.get(rule.type) ?? 0) + score);
+    }
+  }
+  if (AUTH_KEYWORDS.test(text)) {
+    if (CHOICE_KEYWORDS.test(text)) {
+      scores.set("decision", (scores.get("decision") ?? 0) + 3);
+    } else {
+      scores.set("convention", (scores.get("convention") ?? 0) + 2);
+    }
+  }
+  if (scores.size === 0) {
+    return "convention";
+  }
+  let bestType = "convention";
+  let bestScore = -1;
+  for (const [type, score] of scores) {
+    if (score > bestScore) {
+      bestType = type;
+      bestScore = score;
+    }
+  }
+  return bestType;
+}
+function extractKeywordTags(text) {
+  const found = [];
+  for (const { tag, pattern } of TAG_KEYWORDS) {
+    if (pattern.test(text)) {
+      found.push(tag);
+    }
+  }
+  return found;
+}
+function extractIdentifierTags(text) {
+  const tokens = /* @__PURE__ */ new Set();
+  const pathLike = text.match(/\/(?:[a-z0-9_-]+\/?){1,4}/gi);
+  if (pathLike) {
+    for (const segment of pathLike) {
+      for (const part of segment.split("/")) {
+        if (part.length >= 3 && /^[a-z0-9_-]+$/i.test(part)) {
+          tokens.add(part.toLowerCase());
+        }
+      }
+    }
+  }
+  const fileLike = text.match(/\b[a-z0-9_.-]+\.(?:ts|tsx|js|jsx|py|go|rb|rs|java|kt|sql|md|json|yml|yaml)\b/gi);
+  if (fileLike) {
+    for (const file of fileLike) {
+      const base = file.split(".").slice(0, -1).join(".");
+      if (base.length >= 3) {
+        tokens.add(base.toLowerCase());
+      }
+    }
+  }
+  return Array.from(tokens);
+}
+function extractSalientWords(text, limit) {
+  const words = text.toLowerCase().replace(/[^a-z0-9\s/_-]/g, " ").split(/\s+/).filter((word) => word.length >= 4 && !STOP_WORDS.has(word));
+  const counts = /* @__PURE__ */ new Map();
+  for (const word of words) {
+    counts.set(word, (counts.get(word) ?? 0) + 1);
+  }
+  return Array.from(counts.entries()).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, limit).map(([word]) => word);
+}
+function inferTags(text) {
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (value) => {
+    const normalized = value.trim().toLowerCase();
+    if (!normalized || seen.has(normalized)) {
+      return;
+    }
+    seen.add(normalized);
+    ordered.push(normalized);
+  };
+  for (const tag of extractKeywordTags(text)) {
+    push(tag);
+  }
+  for (const tag of extractIdentifierTags(text)) {
+    push(tag);
+  }
+  if (ordered.length < 5) {
+    for (const word of extractSalientWords(text, 8)) {
+      push(word);
+      if (ordered.length >= 5) {
+        break;
+      }
+    }
+  }
+  return ordered.slice(0, 5);
+}
+function inferMemoryFromNote(text) {
+  return {
+    type: inferMemoryType(text),
+    tags: inferTags(text)
+  };
+}
+var TYPE_RULES, AUTH_KEYWORDS, CHOICE_KEYWORDS, TAG_KEYWORDS, STOP_WORDS;
+var init_inference = __esm({
+  "src/lib/inference.ts"() {
+    "use strict";
+    TYPE_RULES = [
+      {
+        type: "bug_fix",
+        patterns: [
+          { pattern: /\broot cause\b/i, weight: 4 },
+          { pattern: /\bregression\b/i, weight: 4 },
+          { pattern: /\bhotfix\b/i, weight: 4 },
+          { pattern: /\bfix(?:ed|es|ing)?\b/i, weight: 3 },
+          { pattern: /\bbugs?\b/i, weight: 2 },
+          { pattern: /\bcrash(?:ed|es|ing)?\b/i, weight: 2 },
+          { pattern: /\bbroken\b/i, weight: 2 },
+          { pattern: /\bworkaround\b/i, weight: 2 }
+        ]
+      },
+      {
+        type: "issue",
+        patterns: [
+          { pattern: /\bissue\s*#\d+/i, weight: 5 },
+          { pattern: /\bticket\s*#?\w+/i, weight: 4 },
+          { pattern: /\bjira[-\s]?\w+/i, weight: 4 },
+          { pattern: /\bgh[-\s]?\d+/i, weight: 3 },
+          { pattern: /#\d{2,}/i, weight: 2 }
+        ]
+      },
+      {
+        type: "decision",
+        patterns: [
+          { pattern: /\bdecided not to\b/i, weight: 5 },
+          { pattern: /\bdecided to\b/i, weight: 4 },
+          { pattern: /\bwe chose\b/i, weight: 4 },
+          { pattern: /\bchose\s+\w+\s+over\b/i, weight: 4 },
+          { pattern: /\barchitecture\b/i, weight: 3 },
+          { pattern: /\bdecision\b/i, weight: 3 },
+          { pattern: /\btrade[- ]?off\b/i, weight: 2 },
+          { pattern: /\brfc\b/i, weight: 2 },
+          { pattern: /\b(?:adopted|migrated to)\b/i, weight: 2 }
+        ]
+      },
+      {
+        type: "reviewer_pattern",
+        patterns: [
+          { pattern: /\breviewer(?:s)?\s+(?:prefer|want|expect|require)/i, weight: 5 },
+          { pattern: /\bpr\s+style\b/i, weight: 4 },
+          { pattern: /\bcode review\b/i, weight: 3 },
+          { pattern: /\bprefer(?:s|red)?\b/i, weight: 2 },
+          { pattern: /\breview comment\b/i, weight: 2 }
+        ]
+      },
+      {
+        type: "convention",
+        patterns: [
+          { pattern: /\bconvention\b/i, weight: 4 },
+          { pattern: /\balways\b/i, weight: 2 },
+          { pattern: /\bnever\b/i, weight: 2 },
+          { pattern: /\bstandard\b/i, weight: 2 },
+          { pattern: /\bstyle guide\b/i, weight: 3 },
+          { pattern: /\buse\b\s+\w+\s+\bfor\b/i, weight: 1 }
+        ]
+      }
+    ];
+    AUTH_KEYWORDS = /\b(?:auth|jwt|oauth|token|login|logout|session|sso|saml)\b/i;
+    CHOICE_KEYWORDS = /\b(?:chose|choose|decided|prefer|switched|migrated|adopted|over|instead of)\b/i;
+    TAG_KEYWORDS = [
+      { tag: "auth", pattern: /\b(?:auth|authentication|authorization)\b/i },
+      { tag: "jwt", pattern: /\bjwt\b/i },
+      { tag: "oauth", pattern: /\boauth\b/i },
+      { tag: "session", pattern: /\bsession(?:s)?\b/i },
+      { tag: "api", pattern: /\bapi\b/i },
+      { tag: "rest", pattern: /\brest(?:ful)?\b/i },
+      { tag: "graphql", pattern: /\bgraphql\b/i },
+      { tag: "websocket", pattern: /\bweb[- ]?socket(?:s)?\b/i },
+      { tag: "database", pattern: /\b(?:database|db|sqlite|postgres|mysql|mongo)\b/i },
+      { tag: "migration", pattern: /\bmigration(?:s)?\b/i },
+      { tag: "schema", pattern: /\bschema\b/i },
+      { tag: "frontend", pattern: /\b(?:frontend|ui|react|vue|svelte|next\.js|nextjs)\b/i },
+      { tag: "backend", pattern: /\b(?:backend|server|node\.js|nodejs|express|fastify)\b/i },
+      { tag: "testing", pattern: /\b(?:test|tests|testing|jest|vitest|pytest|rspec)\b/i },
+      { tag: "ci", pattern: /\b(?:ci|cd|pipeline|github actions|gitlab ci)\b/i },
+      { tag: "deployment", pattern: /\b(?:deploy|deployment|release|rollout)\b/i },
+      { tag: "performance", pattern: /\b(?:performance|perf|latency|throughput)\b/i },
+      { tag: "security", pattern: /\b(?:security|vuln|cve|xss|csrf|injection)\b/i },
+      { tag: "logging", pattern: /\b(?:log|logging|telemetry|tracing)\b/i },
+      { tag: "config", pattern: /\b(?:config|configuration|env|environment)\b/i },
+      { tag: "routing", pattern: /\b(?:route|routing|router|endpoint)\b/i },
+      { tag: "build", pattern: /\b(?:build|webpack|vite|tsup|rollup|esbuild)\b/i },
+      { tag: "docs", pattern: /\b(?:docs|documentation|readme)\b/i }
+    ];
+    STOP_WORDS = /* @__PURE__ */ new Set([
+      "the",
+      "a",
+      "an",
+      "and",
+      "or",
+      "but",
+      "is",
+      "are",
+      "was",
+      "were",
+      "be",
+      "been",
+      "being",
+      "to",
+      "of",
+      "in",
+      "on",
+      "for",
+      "with",
+      "by",
+      "at",
+      "from",
+      "as",
+      "that",
+      "this",
+      "it",
+      "we",
+      "our",
+      "you",
+      "your",
+      "i",
+      "my",
+      "they",
+      "their",
+      "them",
+      "he",
+      "she",
+      "his",
+      "her",
+      "if",
+      "then",
+      "than",
+      "so",
+      "do",
+      "does",
+      "did",
+      "done",
+      "not",
+      "no",
+      "yes",
+      "can",
+      "will",
+      "would",
+      "should",
+      "could",
+      "may",
+      "might",
+      "must",
+      "have",
+      "has",
+      "had",
+      "just",
+      "also",
+      "use",
+      "used",
+      "using",
+      "want",
+      "wants",
+      "wanted",
+      "need",
+      "needs",
+      "needed",
+      "like",
+      "now",
+      "new",
+      "old",
+      "good",
+      "bad",
+      "make",
+      "makes",
+      "made",
+      "get",
+      "gets",
+      "got",
+      "set",
+      "sets",
+      "go",
+      "going",
+      "into",
+      "over",
+      "under",
+      "through",
+      "because",
+      "when",
+      "where",
+      "while",
+      "there",
+      "here",
+      "what",
+      "which",
+      "who",
+      "why",
+      "how",
+      "live",
+      "lives",
+      "living",
+      "keep",
+      "kept",
+      "keeps",
+      "take",
+      "takes",
+      "took",
+      "taken",
+      "say",
+      "says",
+      "said",
+      "tell",
+      "tells",
+      "told",
+      "know",
+      "knows",
+      "known",
+      "knew",
+      "redirect",
+      "redirects",
+      "redirected",
+      "redirecting",
+      "user",
+      "users",
+      "page",
+      "pages"
+    ]);
+  }
+});
+
+// src/tools/remember.ts
+import { nanoid } from "nanoid";
+import { z as z6 } from "zod";
+function mergeTagLists2(...lists) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const list of lists) {
+    if (!list) continue;
+    for (const raw of list) {
+      const value = raw.trim().toLowerCase();
+      if (!value || seen.has(value)) continue;
+      seen.add(value);
+      out.push(value);
+    }
+  }
+  return out;
+}
+function parseStoredTags(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
+  } catch {
+    return [];
   }
-  return db.prepare(
-    `
-        SELECT rowid AS row_id, note, pinned
-        FROM memories
-        WHERE rowid = ?
-      `
-  ).get(memoryId);
 }
-function registerPinMemoryTool(server) {
+function parseStoredMetadata(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return {};
+}
+function registerRememberTool(server) {
   server.registerTool(
-    "pin_memory",
+    "remember",
     {
-      description: "Pin a memory to keep it at the top of repository context.",
-      inputSchema: pinInputSchema
+      description: "Save a memory using only a natural-language note. Fossel infers memory_type, generates tags, resolves the repo, and merges into an existing memory when the note is a near-duplicate. Prefer this tool over store_context for everyday use.",
+      inputSchema: rememberInputSchema
     },
-    async ({ id }) => {
+    async ({ note, repo, type, tags }) => {
       try {
-        const memory = setPinnedState(id, 1);
-        if (!memory) {
+        const db = getDb();
+        const resolved = resolveRepoArg(repo, getWorkspaceRoot(), db);
+        const inferred = inferMemoryFromNote(note);
+        const finalType = type ?? inferred.type;
+        const finalTags = mergeTagLists2(tags, inferred.tags).slice(0, 5);
+        const now = Math.floor(Date.now() / 1e3);
+        const duplicate = findDuplicate(db, resolved.canonical, note);
+        if (duplicate) {
+          const existing = duplicate.memory;
+          const existingTags = parseStoredTags(existing.tags);
+          const mergedTags = mergeTagLists2(existingTags, finalTags);
+          const metadata2 = parseStoredMetadata(
+            existing.metadata_json ?? "{}"
+          );
+          const changelog = metadata2.changelog ?? [];
+          changelog.push({
+            at: now,
+            action: "merged",
+            similarity: Number(duplicate.similarity.toFixed(3)),
+            previous_note: existing.note
+          });
+          metadata2.changelog = changelog;
+          const longerNote = note.length > existing.note.length ? note : existing.note;
+          const nextType = type ?? existing.type;
+          db.prepare(
+            `
+              UPDATE memories
+              SET note = ?, note_normalized = ?, tags = ?, type = ?, metadata_json = ?, updated_at = ?
+              WHERE rowid = ?
+            `
+          ).run(
+            longerNote,
+            normalizeText(longerNote),
+            JSON.stringify(mergedTags),
+            nextType,
+            JSON.stringify(metadata2),
+            now,
+            existing.row_id
+          );
           return {
-            isError: true,
             content: [
               {
                 type: "text",
-                text: `Memory ${id} not found.`
+                text: `Merged into memory ${existing.row_id} for ${resolved.canonical} (similarity ${duplicate.similarity.toFixed(2)}, type ${nextType}, tags: ${mergedTags.join(", ") || "none"}).`
               }
             ]
           };
         }
+        const id = nanoid();
+        const metadata = {
+          changelog: [
+            {
+              at: now,
+              action: "created"
+            }
+          ],
+          inferred: {
+            type: inferred.type,
+            tags: inferred.tags,
+            type_overridden: type !== void 0
+          }
+        };
+        db.prepare(
+          `
+            INSERT INTO memories (id, repo, type, note, tags, created_at, updated_at, pinned, metadata_json, note_normalized)
+            VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
+          `
+        ).run(
+          id,
+          resolved.canonical,
+          finalType,
+          note,
+          JSON.stringify(finalTags),
+          now,
+          now,
+          JSON.stringify(metadata),
+          normalizeText(note)
+        );
+        const inserted = db.prepare("SELECT rowid AS row_id FROM memories WHERE id = ?").get(id);
         return {
           content: [
             {
               type: "text",
-              text: `Pinned memory ${memory.row_id}: ${memory.note}`
+              text: `Stored memory ${inserted?.row_id ?? "?"} for ${resolved.canonical} (type ${finalType}, tags: ${finalTags.join(", ") || "none"}).`
             }
           ]
         };
       } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error while pinning memory.";
+        const message = error instanceof Error ? error.message : "Unknown error while remembering note.";
         return {
           isError: true,
           content: [
             {
               type: "text",
-              text: `Failed to pin memory: ${message}`
+              text: `Failed to remember note: ${message}`
             }
           ]
         };
@@ -387,43 +1788,61 @@ function registerPinMemoryTool(server) {
     }
   );
 }
-function registerUnpinMemoryTool(server) {
+var rememberInputSchema;
+var init_remember = __esm({
+  "src/tools/remember.ts"() {
+    "use strict";
+    init_client();
+    init_dedupe();
+    init_inference();
+    init_repo();
+    init_workspace();
+    rememberInputSchema = {
+      note: z6.string().trim().min(1, "note is required"),
+      repo: z6.string().trim().min(1).optional(),
+      type: z6.enum(MEMORY_TYPES).optional(),
+      tags: z6.array(z6.string().trim().min(1)).optional()
+    };
+  }
+});
+
+// src/tools/resolve-repo.ts
+import { z as z7 } from "zod";
+function registerResolveRepoTool(server) {
   server.registerTool(
-    "unpin_memory",
+    "resolve_repo",
     {
-      description: "Unpin a previously pinned memory.",
-      inputSchema: pinInputSchema
+      description: "Return the canonical repo key for a working directory along with any aliases and the detected git remote. Useful for clients that want to display which repo Fossel is targeting before making other tool calls.",
+      inputSchema: resolveRepoInputSchema
     },
-    async ({ id }) => {
+    async ({ cwd }) => {
       try {
-        const memory = setPinnedState(id, 0);
-        if (!memory) {
-          return {
-            isError: true,
-            content: [
-              {
-                type: "text",
-                text: `Memory ${id} not found.`
-              }
-            ]
-          };
-        }
+        const db = getDb();
+        const target = cwd?.trim() || getWorkspaceRoot();
+        const resolved = resolveRepo(target, db);
+        const payload = {
+          canonical: resolved.canonical,
+          aliases: resolved.aliases,
+          cwd: resolved.cwd,
+          gitRemote: resolved.gitRemote,
+          source: resolved.source
+        };
         return {
           content: [
             {
               type: "text",
-              text: `Unpinned memory ${memory.row_id}.`
+              text: JSON.stringify(payload, null, 2)
             }
           ]
         };
       } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error while unpinning memory.";
+        const message = error instanceof Error ? error.message : "Unknown error while resolving repo.";
         return {
           isError: true,
           content: [
             {
               type: "text",
-              text: `Failed to unpin memory: ${message}`
+              text: `Failed to resolve repo: ${message}`
             }
           ]
         };
@@ -431,27 +1850,37 @@ function registerUnpinMemoryTool(server) {
     }
   );
 }
-var pinInputSchema;
-var init_pin = __esm({
-  "src/tools/pin.ts"() {
+var resolveRepoInputSchema;
+var init_resolve_repo = __esm({
+  "src/tools/resolve-repo.ts"() {
     "use strict";
     init_client();
-    pinInputSchema = {
-      id: z3.number().int().positive()
+    init_repo();
+    init_workspace();
+    resolveRepoInputSchema = {
+      cwd: z7.string().trim().min(1).optional()
     };
   }
 });
 
 // src/tools/search.ts
-import { z as z4 } 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");
+import { z as z8 } from "zod";
+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 parseTags2(raw) {
+function buildFtsQueryOr(tokens) {
+  if (tokens.length === 0) {
+    return null;
+  }
+  return tokens.map((token) => `"${token.replace(/"/g, '""')}"`).join(" OR ");
+}
+function parseTags4(raw) {
   try {
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
@@ -459,58 +1888,89 @@ function parseTags2(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 rows = repo ? 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, repo, 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);
+          }
+        }
+        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: [
               {
                 type: "text",
-                text: repo ? `No memories matched "${query}" in ${repo}.` : `No memories matched "${query}".`
+                text: resolvedRepo ? `No memories matched "${query}" in ${resolvedRepo}.` : `No memories matched "${query}".`
               }
             ]
           };
         }
         const formatted = rows.map((row, index) => {
-          const tags = parseTags2(row.tags);
+          const tags = parseTags4(row.tags);
           const tagsText = tags.length > 0 ? ` | tags: ${tags.join(", ")}` : "";
           const pinPrefix = row.pinned ? "\u{1F4CC} Pinned " : "";
           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}"${repo ? ` in ${repo}` : ""}:
+              text: `${header}
 
 ${formatted}`
             }
@@ -536,38 +1996,51 @@ var init_search = __esm({
   "src/tools/search.ts"() {
     "use strict";
     init_client();
+    init_context();
+    init_repo();
+    init_workspace();
     searchMemoryInputSchema = {
-      query: z4.string().trim().min(1, "query is required"),
-      repo: z4.string().trim().min(1).optional(),
-      limit: z4.number().int().positive().max(50).default(5)
+      query: z8.string().trim().min(1, "query is required"),
+      repo: z8.string().trim().min(1).optional(),
+      limit: z8.number().int().positive().max(50).default(5)
     };
   }
 });
 
 // src/tools/store.ts
-import { nanoid } from "nanoid";
-import { z as z5 } from "zod";
+import { nanoid as nanoid2 } from "nanoid";
+import { z as z9 } from "zod";
 function registerStoreContextTool(server) {
   server.registerTool(
     "store_context",
     {
-      description: "Store repository-specific contributor context such as bug fixes, conventions, and decisions.",
+      description: "Store repository-specific contributor context such as bug fixes, conventions, and decisions. The repo argument is resolved to a canonical key automatically; pass it explicitly only when targeting a different repo than the current workspace.",
       inputSchema: storeContextInputSchema
     },
     async ({ repo, type, note, tags }) => {
       try {
         const db = getDb();
+        const resolved = resolveRepoArg(repo, getWorkspaceRoot(), db);
         const now = Math.floor(Date.now() / 1e3);
-        const id = nanoid();
+        const id = nanoid2();
         const normalizedTags = Array.from(
           new Set((tags ?? []).map((tag) => tag.trim()).filter(Boolean))
         );
         db.prepare(
           `
-            INSERT INTO memories (id, repo, type, note, tags, created_at, updated_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
+            INSERT INTO memories (id, repo, type, note, tags, created_at, updated_at, pinned, metadata_json, note_normalized)
+            VALUES (?, ?, ?, ?, ?, ?, ?, 0, '{}', ?)
           `
-        ).run(id, repo, type, note, JSON.stringify(normalizedTags), now, now);
+        ).run(
+          id,
+          resolved.canonical,
+          type,
+          note,
+          JSON.stringify(normalizedTags),
+          now,
+          now,
+          normalizeText(note)
+        );
         const stored = db.prepare(
           `
               SELECT rowid AS row_id, id
@@ -579,7 +2052,7 @@ function registerStoreContextTool(server) {
           content: [
             {
               type: "text",
-              text: `Stored memory ${id} (numeric id: ${stored?.row_id ?? "unknown"}) for ${repo} (${type}).`
+              text: `Stored memory ${id} (numeric id: ${stored?.row_id ?? "unknown"}) for ${resolved.canonical} (${type}).`
             }
           ]
         };
@@ -603,17 +2076,20 @@ var init_store = __esm({
   "src/tools/store.ts"() {
     "use strict";
     init_client();
+    init_dedupe();
+    init_repo();
+    init_workspace();
     storeContextInputSchema = {
-      repo: z5.string().trim().min(1, "repo is required"),
-      type: z5.enum(MEMORY_TYPES),
-      note: z5.string().trim().min(1, "note is required"),
-      tags: z5.array(z5.string().trim().min(1)).optional()
+      repo: z9.string().trim().min(1).optional(),
+      type: z9.enum(MEMORY_TYPES),
+      note: z9.string().trim().min(1, "note is required"),
+      tags: z9.array(z9.string().trim().min(1)).optional()
     };
   }
 });
 
 // src/tools/summarize.ts
-import { z as z6 } from "zod";
+import { z as z10 } from "zod";
 function registerSummarizeRepoContextTool(server) {
   server.registerTool(
     "summarize_repo_context",
@@ -624,6 +2100,7 @@ function registerSummarizeRepoContextTool(server) {
     async ({ repo }) => {
       try {
         const db = getDb();
+        const resolved = resolveRepoArg(repo, getWorkspaceRoot(), db);
         const rows = db.prepare(
           `
               SELECT rowid AS row_id, type, note, pinned
@@ -631,13 +2108,13 @@ function registerSummarizeRepoContextTool(server) {
               WHERE repo = ?
               ORDER BY pinned DESC, updated_at DESC
             `
-        ).all(repo);
+        ).all(resolved.canonical);
         if (rows.length === 0) {
           return {
             content: [
               {
                 type: "text",
-                text: `Fossel Context Summary: ${repo}
+                text: `Fossel Context Summary: ${resolved.canonical}
 
 No memories found.`
               }
@@ -645,7 +2122,7 @@ No memories found.`
           };
         }
         const pinnedLines = rows.filter((row) => row.pinned === 1).map((row) => `- (${row.row_id}) ${row.note}`);
-        const sections = [`Fossel Context Summary: ${repo}`];
+        const sections = [`Fossel Context Summary: ${resolved.canonical}`];
         if (pinnedLines.length > 0) {
           sections.push(`\u{1F4CC} Pinned
 ${pinnedLines.join("\n")}`);
@@ -686,8 +2163,10 @@ var init_summarize = __esm({
   "src/tools/summarize.ts"() {
     "use strict";
     init_client();
+    init_repo();
+    init_workspace();
     summarizeRepoContextInputSchema = {
-      repo: z6.string().trim().min(1, "repo is required")
+      repo: z10.string().trim().min(1).optional()
     };
     sectionTitleByType = {
       convention: "Conventions",
@@ -701,8 +2180,8 @@ var init_summarize = __esm({
 });
 
 // src/tools/update.ts
-import { z as z7 } from "zod";
-function parseTags3(raw) {
+import { z as z11 } from "zod";
+function parseTags5(raw) {
   try {
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
@@ -711,7 +2190,7 @@ function parseTags3(raw) {
   }
 }
 function formatMemory(memory) {
-  const tags = parseTags3(memory.tags);
+  const tags = parseTags5(memory.tags);
   const tagsLine = tags.length > 0 ? tags.join(", ") : "(none)";
   return [
     `Memory ${memory.row_id} updated successfully.`,
@@ -730,7 +2209,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 }) => {
@@ -747,14 +2226,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: [
@@ -765,23 +2238,41 @@ 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;
-        db.prepare(
-          `
-            UPDATE memories
-            SET type = ?, note = ?, updated_at = ?
-            WHERE rowid = ?
-          `
-        ).run(nextType, nextNote, now, id);
+        const nextNormalized = content ? normalizeText(content) : null;
+        if (nextNormalized !== null) {
+          db.prepare(
+            `
+              UPDATE memories
+              SET type = ?, note = ?, note_normalized = ?, updated_at = ?
+              WHERE rowid = ?
+            `
+          ).run(nextType, nextNote, nextNormalized, now, existing.row_id);
+        } else {
+          db.prepare(
+            `
+              UPDATE memories
+              SET type = ?, note = ?, updated_at = ?
+              WHERE rowid = ?
+            `
+          ).run(nextType, nextNote, now, existing.row_id);
+        }
         const updated = db.prepare(
           `
               SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
               FROM memories
               WHERE rowid = ?
             `
-        ).get(id);
+        ).get(existing.row_id);
         if (!updated) {
           return {
             isError: true,
@@ -821,10 +2312,14 @@ var init_update = __esm({
   "src/tools/update.ts"() {
     "use strict";
     init_client();
+    init_dedupe();
+    init_memory();
     updateMemoryInputSchema = {
-      id: z7.number().int().positive(),
-      content: z7.string().trim().min(1).optional(),
-      memory_type: z7.enum(MEMORY_TYPES).optional()
+      // 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()
     };
   }
 });
@@ -843,13 +2338,61 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 function resolveDbPath() {
   return process.env.FOSSEL_DB_PATH?.trim() || join(homedir(), ".fossel", "memory.db");
 }
+function registerStartupContextResource(server) {
+  server.registerResource(
+    "fossel-startup-context",
+    "fossel://context/current-repo",
+    {
+      title: "Fossel: current repo context",
+      description: "Top pinned and recent memories for the current workspace. Read this at the start of a session to ground the conversation in prior context.",
+      mimeType: "text/markdown"
+    },
+    async (uri) => {
+      try {
+        const db = getDb();
+        const resolved = resolveRepo(getWorkspaceRoot(), db);
+        const rows = fetchRepoContext(db, resolved.canonical, 5);
+        const text = formatContext(rows, {
+          repo: resolved.canonical,
+          format: "markdown"
+        });
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "text/markdown",
+              text
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "text/markdown",
+              text: `# Fossel context unavailable
+
+${message}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
 async function startServer() {
   const dbPath = resolveDbPath();
   initDb(dbPath);
   const server = new McpServer({
     name: "fossel",
-    version: "1.0.0"
+    version: "1.1.1"
   });
+  registerRememberTool(server);
+  registerGetContextTool(server);
+  registerResolveRepoTool(server);
+  registerDedupeRepoTool(server);
   registerStoreContextTool(server);
   registerGetRepoContextTool(server);
   registerSearchMemoryTool(server);
@@ -858,6 +2401,7 @@ async function startServer() {
   registerPinMemoryTool(server);
   registerUnpinMemoryTool(server);
   registerSummarizeRepoContextTool(server);
+  registerStartupContextResource(server);
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
@@ -866,9 +2410,16 @@ var init_index = __esm({
   "src/index.ts"() {
     "use strict";
     init_client();
+    init_context();
+    init_repo();
+    init_workspace();
+    init_dedupe_repo();
     init_delete();
+    init_get_context();
     init_get_repo();
     init_pin();
+    init_remember();
+    init_resolve_repo();
     init_search();
     init_store();
     init_summarize();
@@ -887,111 +2438,299 @@ var init_index = __esm({
 
 // src/cli.ts
 init_client();
+init_dedupe();
+init_repo();
 import { homedir as homedir2 } from "os";
-import { basename, join as join2 } from "path";
-import { spawnSync } from "child_process";
-import { nanoid as nanoid2 } from "nanoid";
+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;
 }
-function detectRepoFromRemote(cwd) {
-  const result = spawnSync("git", ["remote", "get-url", "origin"], {
-    cwd,
-    encoding: "utf8"
-  });
-  if (result.status !== 0) {
-    return null;
-  }
-  const remote = result.stdout.trim();
-  if (!remote) {
-    return null;
-  }
-  const normalized = remote.replace(/\\/g, "/").replace(/\/+$/, "");
-  const lastSegment = normalized.split("/").at(-1);
-  if (!lastSegment) {
-    return null;
-  }
-  return lastSegment.replace(/\.git$/i, "");
-}
-function detectRepoName(cwd) {
-  return detectRepoFromRemote(cwd) ?? basename(cwd);
-}
-function ensureSampleMemory(repo) {
+function ensureSampleMemoryIfEmpty(repo) {
   const db = getDb();
-  const existing = db.prepare(
-    `
-        SELECT rowid AS row_id
-        FROM memories
-        WHERE repo = ? AND type = 'convention' AND note = ?
-        LIMIT 1
-      `
-  ).get(repo, INIT_MEMORY_TEXT);
-  if (existing) {
-    return;
+  const totalRow = db.prepare("SELECT COUNT(*) AS count FROM memories").get();
+  if (totalRow.count > 0) {
+    return false;
   }
   const now = Math.floor(Date.now() / 1e3);
   db.prepare(
     `
-      INSERT INTO memories (id, repo, type, note, tags, created_at, updated_at, pinned)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO memories (id, repo, type, note, tags, created_at, updated_at, pinned, metadata_json, note_normalized)
+      VALUES (?, ?, ?, ?, ?, ?, ?, 0, '{}', ?)
     `
-  ).run(nanoid2(), repo, "convention", INIT_MEMORY_TEXT, "[]", now, now, 0);
+  ).run(
+    nanoid3(),
+    repo,
+    "convention",
+    INIT_MEMORY_TEXT,
+    "[]",
+    now,
+    now,
+    normalizeText(INIT_MEMORY_TEXT)
+  );
+  return true;
 }
-function formatCursorConfig() {
-  return JSON.stringify(
-    {
-      mcpServers: {
-        fossel: {
-          command: "npx",
-          args: ["-y", "fossel"]
+var MCP_CONFIG_SNIPPET = JSON.stringify(
+  {
+    mcpServers: {
+      fossel: {
+        command: "npx",
+        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}"
         }
       }
-    },
-    null,
-    2
-  );
+    }
+  },
+  null,
+  2
+);
+function findMergeCandidates(canonical) {
+  const db = getDb();
+  const tail = canonical.split("/").at(-1) ?? canonical;
+  const rows = db.prepare(
+    `
+        SELECT repo, COUNT(*) AS count
+        FROM memories
+        WHERE repo != ?
+        GROUP BY repo
+      `
+  ).all(canonical);
+  return rows.filter((row) => {
+    if (!row.repo) return false;
+    const otherTail = row.repo.split("/").at(-1) ?? row.repo;
+    return otherTail === tail || otherTail === canonical || row.repo === tail;
+  });
 }
-function formatClaudeDesktopConfig() {
-  return JSON.stringify(
-    {
-      mcpServers: {
-        fossel: {
-          command: "npx",
-          args: ["-y", "fossel"]
-        }
+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;
       }
-    },
-    null,
-    2
-  );
+    }
+  });
+  tx();
+  return removed;
 }
-function printInitOutput(repo, dbPath) {
+function runInit(options) {
+  const dbPath = resolveDbPath2();
+  initDb(dbPath);
   const db = getDb();
-  const countRow = db.prepare("SELECT COUNT(*) AS count FROM memories").get();
-  console.log("Fossel remembers project context locally for each repository.");
-  console.log("Store conventions, fixes, and decisions once; retrieve them when needed.");
-  console.log("Everything stays in your local SQLite database.\n");
-  console.log(`Detected repository: ${repo}
-`);
-  console.log("Cursor MCP config (~/.cursor/mcp.json):");
-  console.log(formatCursorConfig());
+  const resolved = resolveRepo(process.cwd(), db);
+  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}`);
+  console.log(`  source: ${resolved.source}`);
+  if (resolved.gitRemote) {
+    console.log(`  git remote: ${resolved.gitRemote}`);
+  }
+  if (resolved.aliases.length > 0) {
+    console.log(`  aliases: ${resolved.aliases.join(", ")}`);
+  }
+  console.log("");
+  if (mergedAliases > 0 || mergedMemories > 0 || rewrittenNotes > 0) {
+    console.log(
+      `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("");
+  console.log(`DB path: ${dbPath}`);
+  console.log(`Memories for ${resolved.canonical}: ${countRow.count}`);
+  if (sampleAdded) {
+    console.log("Inserted one starter memory because the database was empty.");
+  }
   console.log("");
-  console.log("Claude Desktop MCP config:");
-  console.log(formatClaudeDesktopConfig());
+  console.log("Quick usage in chat:");
+  console.log("  remember           \u2014 natural-language save (no type/tags needed)");
+  console.log("  get_context        \u2014 pinned + recent + matching memories");
+  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(`DB Path: ${dbPath}`);
-  console.log(`Total memories: ${countRow.count}`);
+  console.log("Set FOSSEL_WORKSPACE in your MCP config to your project root if Fossel detects the wrong repo.");
+  closeDb();
+}
+function gatherDoctorReport() {
+  const dbPath = resolveDbPath2();
+  const lines = [];
+  let ok = true;
+  initDb(dbPath);
+  const db = getDb();
+  lines.push(`DB path: ${dbPath}`);
+  const resolved = resolveRepo(process.cwd(), db);
+  lines.push(`Canonical repo key: ${resolved.canonical} (source: ${resolved.source})`);
+  if (resolved.gitRemote) {
+    lines.push(`Git remote: ${resolved.gitRemote}`);
+  } else {
+    lines.push("Git remote: not detected (using folder name).");
+  }
+  if (resolved.aliases.length > 0) {
+    lines.push(`Aliases: ${resolved.aliases.join(", ")}`);
+  }
+  const siblings = findMergeCandidates(resolved.canonical);
+  if (siblings.length > 0) {
+    ok = false;
+    const summary = siblings.map((row) => `${row.repo} (${row.count})`).join(", ");
+    lines.push(`\u26A0 Sibling repo keys detected: ${summary}. Run \`npx fossel init\` to merge.`);
+  } 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
+        FROM memories
+        WHERE repo = ? AND note_normalized != ''
+        GROUP BY note_normalized
+        HAVING COUNT(*) > 1
+      `
+  ).all(resolved.canonical);
+  if (duplicateRows.length > 0) {
+    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 \`fossel doctor --fix\` (or \`dedupe_repo\` with apply=true) to merge.`
+    );
+  } else {
+    lines.push("No exact-duplicate memory clusters.");
+  }
+  const mcpConfigCandidates = [
+    join2(homedir2(), ".cursor", "mcp.json"),
+    join2(
+      homedir2(),
+      "AppData",
+      "Roaming",
+      "Claude",
+      "claude_desktop_config.json"
+    ),
+    join2(
+      homedir2(),
+      "Library",
+      "Application Support",
+      "Claude",
+      "claude_desktop_config.json"
+    )
+  ];
+  const found = mcpConfigCandidates.filter((path) => {
+    try {
+      return statSync(path).isFile();
+    } catch {
+      return false;
+    }
+  });
+  if (found.length === 0) {
+    lines.push(
+      "\u26A0 Could not find Cursor or Claude Desktop MCP config. Run `npx fossel init` and paste the snippet."
+    );
+  } else {
+    lines.push(`Detected MCP config(s): ${found.join(", ")}`);
+  }
+  const totalRow = db.prepare("SELECT COUNT(*) AS count FROM memories").get();
+  lines.push(`Total memories across all repos: ${totalRow.count}`);
+  return { ok, lines, duplicateClusters: duplicateRows.length, staleMentions };
+}
+function runDoctor(options) {
+  const report = gatherDoctorReport();
+  console.log(report.lines.join("\n"));
+  console.log("");
+  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("Quick commands");
-  console.log("Command                  Description");
-  console.log("-----------------------  --------------------------------------------");
-  console.log("npx -y fossel            Start Fossel MCP server over stdio");
-  console.log("npx -y fossel init       Initialize Fossel for current repository");
-  console.log("store_context            Save context memory");
-  console.log("get_repo_context         Retrieve recent repo memories");
-  console.log("summarize_repo_context   Generate markdown context summary");
+  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];
@@ -1001,16 +2740,18 @@ async function main() {
     return;
   }
   if (command === "init") {
-    const dbPath = resolveDbPath2();
-    initDb(dbPath);
-    const repo = detectRepoName(process.cwd());
-    ensureSampleMemory(repo);
-    printInitOutput(repo, dbPath);
-    closeDb();
+    const args = process.argv.slice(3);
+    const autoDedupe = !parseFlag(args, "no-dedupe");
+    runInit({ autoDedupe });
+    return;
+  }
+  if (command === "doctor") {
+    const args = process.argv.slice(3);
+    runDoctor({ fix: parseFlag(args, "fix") });
     return;
   }
   console.error(`Unknown command: ${command}`);
-  console.error("Usage: fossel [init]");
+  console.error("Usage: fossel [init [--no-dedupe] | doctor [--fix]]");
   process.exit(1);
 }
 main().catch((error) => {
@@ -1018,3 +2759,7 @@ main().catch((error) => {
   console.error(`Fossel command failed: ${message}`);
   process.exit(1);
 });
+export {
+  runDoctor,
+  runInit
+};