fossel 1.0.9 → 1.1.1

package/dist/index.js

@@ -17,6 +17,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();
+}
 var migrations = [
   {
     name: "001_init_memories_schema",
@@ -82,6 +85,59 @@ var migrations = [
         `);
       }
     }
+  },
+  {
+    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);
+      }
+    }
   }
 ];
 function runMigrations(db) {
@@ -139,23 +195,615 @@ function getDb() {
   return dbInstance;
 }
 
-// src/tools/delete.ts
+// src/lib/context.ts
+var SECTION_TITLES = {
+  convention: "Conventions",
+  bug_fix: "Bug Fixes",
+  reviewer_pattern: "Reviewer Patterns",
+  decision: "Decisions",
+  issue: "Issues",
+  general: "General"
+};
+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");
+}
+
+// src/lib/repo.ts
+import { spawnSync } from "child_process";
+import { basename } from "path";
+var 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)?$/
+];
+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)
+  };
+}
+
+// src/lib/workspace.ts
+function getWorkspaceRoot() {
+  const fromEnv = process.env.FOSSEL_WORKSPACE?.trim();
+  if (fromEnv) {
+    return fromEnv;
+  }
+  return process.cwd();
+}
+
+// src/tools/dedupe-repo.ts
 import { z } from "zod";
+
+// src/lib/dedupe.ts
+var DEFAULT_THRESHOLD = 0.82;
+var DEFAULT_CANDIDATE_LIMIT = 200;
+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;
+}
+
+// src/tools/dedupe-repo.ts
+var dedupeRepoInputSchema = {
+  repo: z.string().trim().min(1).optional(),
+  threshold: z.number().min(0.5).max(1).default(0.85),
+  apply: z.boolean().default(false)
+};
+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(
+    "dedupe_repo",
+    {
+      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 ({ repo, threshold, apply }) => {
+      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, metadata_json
+              FROM memories
+              WHERE repo = ?
+              ORDER BY updated_at DESC
+            `
+        ).all(resolved.canonical);
+        if (rows.length < 2) {
+          return {
+            content: [
+              {
+                type: "text",
+                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 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;
+          }
+        });
+        tx(plan);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Merged ${merged} duplicate pair(s) in ${resolved.canonical}.`
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error while deduping repo.";
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Failed to dedupe repo: ${message}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/delete.ts
+import { z as z2 } from "zod";
+
+// src/lib/memory.ts
+function findMemoryByAnyId(db, input) {
+  const numeric = typeof input === "number" ? input : Number(input);
+  const isNumericId = Number.isInteger(numeric) && numeric > 0 && String(numeric) === String(input).trim();
+  if (isNumericId) {
+    const row = db.prepare(
+      `
+          SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
+          FROM memories
+          WHERE rowid = ?
+        `
+    ).get(numeric);
+    if (row) {
+      return row;
+    }
+  }
+  const stringInput = String(input).trim();
+  if (stringInput.length === 0) {
+    return null;
+  }
+  const stringRow = db.prepare(
+    `
+        SELECT rowid AS row_id, id, repo, type, note, tags, created_at, updated_at, pinned
+        FROM memories
+        WHERE id = ?
+      `
+  ).get(stringInput);
+  return stringRow ?? null;
+}
+
+// src/tools/delete.ts
 var deleteMemoryInputSchema = {
-  id: z.string().trim().min(1, "id is required")
+  // Accept either the numeric row_id or the legacy nanoid string. Tools used
+  // to disagree about which form to take; this unifies them so callers can
+  // paste whichever id they have in front of them.
+  id: z2.union([z2.number().int().positive(), z2.string().trim().min(1)])
 };
 function registerDeleteMemoryTool(server) {
   server.registerTool(
     "delete_memory",
     {
-      description: "Delete a memory from storage by id.",
+      description: "Delete a memory from storage by id. Accepts either the numeric row id or the legacy string id.",
       inputSchema: deleteMemoryInputSchema
     },
     async ({ id }) => {
       try {
         const db = getDb();
-        const row = db.prepare("SELECT id FROM memories WHERE id = ?").get(id);
-        if (!row) {
+        const memory = findMemoryByAnyId(db, id);
+        if (!memory) {
           return {
             isError: true,
             content: [
@@ -166,26 +814,75 @@ 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(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}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/get-context.ts
+import { z as z3 } from "zod";
+var 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")
+};
+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
         });
-        deleteTx(id);
         return {
           content: [
             {
               type: "text",
-              text: `Deleted memory ${id}.`
+              text
             }
           ]
         };
       } catch (error) {
-        const message = error instanceof Error ? error.message : "Unknown error while deleting memory.";
+        const message = error instanceof Error ? error.message : "Unknown error while fetching context.";
         return {
           isError: true,
           content: [
             {
               type: "text",
-              text: `Failed to delete memory: ${message}`
+              text: `Failed to fetch context: ${message}`
             }
           ]
         };
@@ -195,12 +892,12 @@ function registerDeleteMemoryTool(server) {
 }
 
 // src/tools/get-repo.ts
-import { z as z2 } from "zod";
+import { z as z4 } from "zod";
 var 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)
 };
-function parseTags(raw) {
+function parseTags3(raw) {
   try {
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
@@ -215,12 +912,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
@@ -229,20 +927,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}`;
@@ -263,7 +961,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")}`
@@ -287,11 +985,12 @@ ${sections.join("\n\n")}`
 }
 
 // src/tools/pin.ts
-import { z as z3 } from "zod";
+import { z as z5 } from "zod";
 var pinInputSchema = {
-  id: z3.number().int().positive()
+  // Accept numeric row_id or legacy string id for parity with the other tools.
+  id: z5.union([z5.number().int().positive(), z5.string().trim().min(1)])
 };
-function setPinnedState(memoryId, pinned) {
+function setPinnedState(rowId, pinned) {
   const db = getDb();
   const now = Math.floor(Date.now() / 1e3);
   const updateResult = db.prepare(
@@ -300,7 +999,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;
   }
@@ -310,7 +1009,7 @@ function setPinnedState(memoryId, pinned) {
         FROM memories
         WHERE rowid = ?
       `
-  ).get(memoryId);
+  ).get(rowId);
 }
 function registerPinMemoryTool(server) {
   server.registerTool(
@@ -321,7 +1020,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,
@@ -365,7 +1077,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,
@@ -401,21 +1126,560 @@ function registerUnpinMemoryTool(server) {
   );
 }
 
+// src/tools/remember.ts
+import { nanoid } from "nanoid";
+import { z as z6 } from "zod";
+
+// src/lib/inference.ts
+var 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 }
+    ]
+  }
+];
+var AUTH_KEYWORDS = /\b(?:auth|jwt|oauth|token|login|logout|session|sso|saml)\b/i;
+var CHOICE_KEYWORDS = /\b(?:chose|choose|decided|prefer|switched|migrated|adopted|over|instead of)\b/i;
+var 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 }
+];
+var 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"
+]);
+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)
+  };
+}
+
+// src/tools/remember.ts
+var 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()
+};
+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 [];
+  }
+}
+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(
+    "remember",
+    {
+      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 ({ note, repo, type, tags }) => {
+      try {
+        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 {
+            content: [
+              {
+                type: "text",
+                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: `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 remembering note.";
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Failed to remember note: ${message}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/resolve-repo.ts
+import { z as z7 } from "zod";
+var resolveRepoInputSchema = {
+  cwd: z7.string().trim().min(1).optional()
+};
+function registerResolveRepoTool(server) {
+  server.registerTool(
+    "resolve_repo",
+    {
+      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 ({ cwd }) => {
+      try {
+        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: JSON.stringify(payload, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error while resolving repo.";
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: `Failed to resolve repo: ${message}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
 // src/tools/search.ts
-import { z as z4 } from "zod";
+import { z as z8 } from "zod";
 var 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)
 };
-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 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") : [];
@@ -423,58 +1687,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}`
             }
@@ -497,35 +1792,45 @@ ${formatted}`
 }
 
 // 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";
 var 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()
 };
 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
@@ -537,7 +1842,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}).`
             }
           ]
         };
@@ -558,9 +1863,9 @@ function registerStoreContextTool(server) {
 }
 
 // src/tools/summarize.ts
-import { z as z6 } from "zod";
+import { z as z10 } from "zod";
 var summarizeRepoContextInputSchema = {
-  repo: z6.string().trim().min(1, "repo is required")
+  repo: z10.string().trim().min(1).optional()
 };
 var sectionTitleByType = {
   convention: "Conventions",
@@ -580,6 +1885,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
@@ -587,13 +1893,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.`
               }
@@ -601,7 +1907,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")}`);
@@ -639,13 +1945,15 @@ ${entries.join("\n")}`);
 }
 
 // src/tools/update.ts
-import { z as z7 } from "zod";
+import { z as z11 } from "zod";
 var 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()
 };
-function parseTags3(raw) {
+function parseTags5(raw) {
   try {
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
@@ -654,7 +1962,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.`,
@@ -673,7 +1981,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 }) => {
@@ -690,14 +1998,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: [
@@ -708,23 +2010,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,
@@ -764,13 +2084,61 @@ function registerUpdateMemoryTool(server) {
 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);
@@ -779,6 +2147,7 @@ async function startServer() {
   registerPinMemoryTool(server);
   registerUnpinMemoryTool(server);
   registerSummarizeRepoContextTool(server);
+  registerStartupContextResource(server);
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }