@danielmarbach/mnemonic-mcp 0.9.0 → 0.11.0

package/build/index.js

@@ -15,6 +15,7 @@ import { CONSOLIDATION_MODES, PROTECTED_BRANCH_BEHAVIORS, PROJECT_POLICY_SCOPES,
 import { classifyTheme, summarizePreview, titleCaseTheme } from "./project-introspection.js";
 import { detectProject, getCurrentGitBranch, resolveProjectIdentity } from "./project.js";
 import { VaultManager } from "./vault.js";
+import { checkBranchChange } from "./branch-tracker.js";
 import { Migrator } from "./migration.js";
 import { parseMemorySections } from "./import.js";
 import { defaultClaudeHome, defaultVaultPath, resolveUserPath } from "./paths.js";
@@ -331,6 +332,33 @@ async function resolveWriteVault(cwd, scope) {
 function describeProject(project) {
     return project ? `project '${project.name}' (${project.id})` : "global";
 }
+/**
+ * Checks if the git branch has changed since the last operation for a directory.
+ * If a branch change is detected, automatically triggers sync to rebuild embeddings.
+ * Returns true if sync was triggered, false otherwise.
+ */
+async function ensureBranchSynced(cwd) {
+    if (!cwd)
+        return false;
+    const previousBranch = await checkBranchChange(cwd);
+    if (!previousBranch)
+        return false; // No branch change or not in git repo
+    console.error(`[branch] Detected branch change from '${previousBranch}' — auto-syncing`);
+    // Trigger sync to rebuild embeddings
+    const mainResult = await vaultManager.main.git.sync();
+    console.error(`[branch] Main vault sync: ${JSON.stringify(mainResult)}`);
+    const projectVault = await vaultManager.getProjectVaultIfExists(cwd);
+    if (projectVault) {
+        const projectResult = await projectVault.git.sync();
+        console.error(`[branch] Project vault sync: ${JSON.stringify(projectResult)}`);
+        // Backfill embeddings after sync
+        const backfill = await backfillEmbeddingsAfterSync(projectVault.storage, "project vault", [], true);
+        console.error(`[branch] Project vault embedded ${backfill.embedded} notes`);
+    }
+    const mainBackfill = await backfillEmbeddingsAfterSync(vaultManager.main.storage, "main vault", [], true);
+    console.error(`[branch] Main vault embedded ${mainBackfill.embedded} notes`);
+    return true;
+}
 function formatProjectIdentityText(identity) {
     const lines = [
         `Project identity:`,
@@ -592,12 +620,34 @@ function buildPersistenceStatus(args) {
             commitMessage: args.commitMessage,
             commitBody: args.commitBody,
             commitReason: args.commit.reason,
+            commitError: args.commit.error,
             pushReason: args.push.reason,
             pushError: args.push.error,
         },
+        retry: args.retry,
         durability: resolveDurability(args.commit, args.push),
     };
 }
+function buildMutationRetryContract(args) {
+    if (args.commit.status !== "failed") {
+        return undefined;
+    }
+    return {
+        attemptedCommit: {
+            message: args.commitMessage,
+            body: args.commitBody,
+            files: args.files,
+            cwd: args.cwd,
+            vault: storageLabel(args.vault),
+            error: args.commit.error ?? "Unknown git commit failure",
+        },
+        mutationApplied: args.mutationApplied,
+        retrySafe: args.mutationApplied,
+        rationale: args.mutationApplied
+            ? "Mutation is already persisted on disk; commit can be retried deterministically."
+            : "Mutation was not applied; retry may require re-running the operation.",
+    };
+}
 function formatPersistenceSummary(persistence) {
     const parts = [
         `Persistence: embedding ${persistence.embedding.status}`,
@@ -716,7 +766,7 @@ async function formatProjectPolicyLine(projectId) {
     }
     return `Policy: default write scope ${policy.defaultScope} (updated ${policy.updatedAt})`;
 }
-async function moveNoteBetweenVaults(found, targetVault, noteToWrite) {
+async function moveNoteBetweenVaults(found, targetVault, noteToWrite, cwd) {
     const { note, vault: sourceVault } = found;
     const finalNote = noteToWrite ?? note;
     const embedding = await sourceVault.storage.readEmbedding(note.id);
@@ -733,7 +783,9 @@ async function moveNoteBetweenVaults(found, targetVault, noteToWrite) {
         noteTitle: finalNote.title,
         projectName: finalNote.projectName,
     });
-    const targetCommit = await targetVault.git.commitWithStatus(`move: ${finalNote.title}`, [vaultManager.noteRelPath(targetVault, finalNote.id)], targetCommitBody);
+    const targetCommitMessage = `move: ${finalNote.title}`;
+    const targetCommitFiles = [vaultManager.noteRelPath(targetVault, finalNote.id)];
+    const targetCommit = await targetVault.git.commitWithStatus(targetCommitMessage, targetCommitFiles, targetCommitBody);
     const sourceCommitBody = formatCommitBody({
         summary: `Moved to ${targetVaultLabel}`,
         noteId: finalNote.id,
@@ -741,7 +793,18 @@ async function moveNoteBetweenVaults(found, targetVault, noteToWrite) {
         projectName: finalNote.projectName,
     });
     await sourceVault.git.commitWithStatus(`move: ${finalNote.title}`, [vaultManager.noteRelPath(sourceVault, finalNote.id)], sourceCommitBody);
-    const targetPush = await pushAfterMutation(targetVault);
+    const targetPush = targetCommit.status === "committed"
+        ? await pushAfterMutation(targetVault)
+        : { status: "skipped", reason: "commit-failed" };
+    const retry = buildMutationRetryContract({
+        commit: targetCommit,
+        commitMessage: targetCommitMessage,
+        commitBody: targetCommitBody,
+        files: targetCommitFiles,
+        cwd,
+        vault: targetVault,
+        mutationApplied: true,
+    });
     if (sourceVault !== targetVault) {
         await pushAfterMutation(sourceVault);
     }
@@ -753,8 +816,9 @@ async function moveNoteBetweenVaults(found, targetVault, noteToWrite) {
             embedding: embedding ? { status: "written" } : { status: "skipped", reason: "no-source-embedding" },
             commit: targetCommit,
             push: targetPush,
-            commitMessage: `move: ${finalNote.title}`,
+            commitMessage: targetCommitMessage,
             commitBody: targetCommitBody,
+            retry,
         }),
     };
 }
@@ -952,8 +1016,21 @@ server.registerTool("set_project_identity", {
             `Resolved identity: ${candidateIdentity.project.id}\n` +
             `Remote: ${remoteName}`,
     });
-    await vaultManager.main.git.commit(`identity: ${defaultProject.name} use remote ${remoteName}`, ["config.json"], commitBody);
-    await pushAfterMutation(vaultManager.main);
+    const commitMessage = `identity: ${defaultProject.name} use remote ${remoteName}`;
+    const commitFiles = ["config.json"];
+    const commitStatus = await vaultManager.main.git.commitWithStatus(commitMessage, commitFiles, commitBody);
+    const pushStatus = commitStatus.status === "committed"
+        ? await pushAfterMutation(vaultManager.main)
+        : { status: "skipped", reason: "commit-failed" };
+    const retry = buildMutationRetryContract({
+        commit: commitStatus,
+        commitMessage,
+        commitBody,
+        files: commitFiles,
+        cwd,
+        vault: vaultManager.main,
+        mutationApplied: true,
+    });
     const structuredContent = {
         action: "project_identity_set",
         project: {
@@ -971,12 +1048,14 @@ server.registerTool("set_project_identity", {
             remoteName,
             updatedAt: now,
         },
+        retry,
     };
     return {
         content: [{
                 type: "text",
                 text: `Project identity override set for ${defaultProject.name}: ` +
-                    `default=\`${defaultProject.id}\`, effective=\`${candidateIdentity.project.id}\`, remote=${remoteName}`,
+                    `default=\`${defaultProject.id}\`, effective=\`${candidateIdentity.project.id}\`, remote=${remoteName}` +
+                    `${commitStatus.status === "failed" ? `\nCommit failed; retry data included. Push status: ${pushStatus.status}.` : ""}`,
             }],
         structuredContent,
     };
@@ -1067,6 +1146,7 @@ server.registerTool("execute_migration", {
     }),
     outputSchema: MigrationExecuteResultSchema,
 }, async ({ migrationName, dryRun, backup, cwd }) => {
+    await ensureBranchSynced(cwd);
     try {
         const { results, vaultsProcessed } = await migrator.runMigration(migrationName, {
             dryRun,
@@ -1182,6 +1262,7 @@ server.registerTool("remember", {
     }),
     outputSchema: RememberResultSchema,
 }, async ({ title, content, tags, lifecycle, summary, cwd, scope, allowProtectedBranch = false }) => {
+    await ensureBranchSynced(cwd);
     const project = await resolveProject(cwd);
     const cleanedContent = await cleanMarkdown(content);
     const policy = project ? await configStore.getProjectPolicy(project.id) : undefined;
@@ -1195,7 +1276,7 @@ server.registerTool("remember", {
     const protectedBranchCheck = await shouldBlockProtectedBranchCommit({
         cwd,
         writeScope,
-        automaticCommit: scope === undefined,
+        automaticCommit: true,
         projectLabel: project ? `${project.name} (${project.id})` : "this context",
         policy,
         allowProtectedBranch,
@@ -1236,16 +1317,30 @@ server.registerTool("remember", {
         scope: writeScope,
         tags: tags,
     });
-    const commitStatus = await vault.git.commitWithStatus(`remember: ${title}`, [vaultManager.noteRelPath(vault, id)], commitBody);
-    const pushStatus = await pushAfterMutation(vault);
+    const commitMessage = `remember: ${title}`;
+    const commitFiles = [vaultManager.noteRelPath(vault, id)];
+    const commitStatus = await vault.git.commitWithStatus(commitMessage, commitFiles, commitBody);
+    const pushStatus = commitStatus.status === "committed"
+        ? await pushAfterMutation(vault)
+        : { status: "skipped", reason: "commit-failed" };
+    const retry = buildMutationRetryContract({
+        commit: commitStatus,
+        commitMessage,
+        commitBody,
+        files: commitFiles,
+        cwd,
+        vault,
+        mutationApplied: true,
+    });
     const persistence = buildPersistenceStatus({
         storage: vault.storage,
         id,
         embedding: embeddingStatus,
         commit: commitStatus,
         push: pushStatus,
-        commitMessage: `remember: ${title}`,
+        commitMessage,
         commitBody,
+        retry,
     });
     const vaultLabel = vault.isProject ? " [project vault]" : " [main vault]";
     const textContent = `Remembered as \`${id}\` [${projectScope}, stored=${writeScope}]${vaultLabel}\n${formatPersistenceSummary(persistence)}`;
@@ -1345,8 +1440,21 @@ server.registerTool("set_project_memory_policy", {
                 ? `\nProtected branch patterns: ${effectiveProtectedBranchPatterns.join(", ")}`
                 : ""}`,
     });
-    await vaultManager.main.git.commit(`policy: ${project.name} default scope ${effectiveDefaultScope}`, ["config.json"], commitBody);
-    await pushAfterMutation(vaultManager.main);
+    const commitMessage = `policy: ${project.name} default scope ${effectiveDefaultScope}`;
+    const commitFiles = ["config.json"];
+    const commitStatus = await vaultManager.main.git.commitWithStatus(commitMessage, commitFiles, commitBody);
+    const pushStatus = commitStatus.status === "committed"
+        ? await pushAfterMutation(vaultManager.main)
+        : { status: "skipped", reason: "commit-failed" };
+    const retry = buildMutationRetryContract({
+        commit: commitStatus,
+        commitMessage,
+        commitBody,
+        files: commitFiles,
+        cwd,
+        vault: vaultManager.main,
+        mutationApplied: true,
+    });
     const structuredContent = {
         action: "policy_set",
         project: { id: project.id, name: project.name },
@@ -1354,13 +1462,15 @@ server.registerTool("set_project_memory_policy", {
         consolidationMode: effectiveConsolidationMode,
         protectedBranchBehavior: effectiveProtectedBranchBehavior,
         protectedBranchPatterns: effectiveProtectedBranchPatterns,
-        timestamp: now,
+        updatedAt: now,
+        retry,
     };
     return {
         content: [{
                 type: "text",
                 text: `Project memory policy set for ${project.name}: defaultScope=${effectiveDefaultScope}` +
-                    `${modeStr}${branchBehaviorStr}${branchPatternsStr}`,
+                    `${modeStr}${branchBehaviorStr}${branchPatternsStr}` +
+                    `${commitStatus.status === "failed" ? `\nCommit failed; retry data included. Push status: ${pushStatus.status}.` : ""}`,
             }],
         structuredContent,
     };
@@ -1470,9 +1580,24 @@ server.registerTool("recall", {
     }),
     outputSchema: RecallResultSchema,
 }, async ({ query, cwd, limit, minSimilarity, tags, scope }) => {
+    await ensureBranchSynced(cwd);
     const project = await resolveProject(cwd);
     const queryVec = await embed(query);
     const vaults = await vaultManager.searchOrder(cwd);
+    const noteCache = new Map();
+    const noteCacheKey = (vault, id) => `${vault.storage.vaultPath}::${id}`;
+    const readCachedNote = async (vault, id) => {
+        const key = noteCacheKey(vault, id);
+        const cached = noteCache.get(key);
+        if (cached) {
+            return cached;
+        }
+        const note = await vault.storage.readNote(id);
+        if (note) {
+            noteCache.set(key, note);
+        }
+        return note;
+    };
     for (const vault of vaults) {
         await embedMissingNotes(vault.storage).catch(() => { });
     }
@@ -1483,7 +1608,7 @@ server.registerTool("recall", {
             const rawScore = cosineSimilarity(queryVec, rec.embedding);
             if (rawScore < minSimilarity)
                 continue;
-            const note = await vault.storage.readNote(rec.id);
+            const note = await readCachedNote(vault, rec.id);
             if (!note)
                 continue;
             if (tags && tags.length > 0) {
@@ -1512,7 +1637,7 @@ server.registerTool("recall", {
     }
     const sections = [];
     for (const { id, score, vault } of top) {
-        const note = await vault.storage.readNote(id);
+        const note = await readCachedNote(vault, id);
         if (note)
             sections.push(formatNote(note, score));
     }
@@ -1523,7 +1648,7 @@ server.registerTool("recall", {
     // Build structured results array
     const structuredResults = [];
     for (const { id, score, vault, boosted } of top) {
-        const note = await vault.storage.readNote(id);
+        const note = await readCachedNote(vault, id);
         if (note) {
             structuredResults.push({
                 id,
@@ -1590,6 +1715,7 @@ server.registerTool("update", {
     }),
     outputSchema: UpdateResultSchema,
 }, async ({ id, content, title, tags, lifecycle, summary, cwd, allowProtectedBranch = false }) => {
+    await ensureBranchSynced(cwd);
     const found = await vaultManager.findNote(id, cwd);
     if (!found) {
         return { content: [{ type: "text", text: `No memory found with id '${id}'` }], isError: true };
@@ -1656,16 +1782,30 @@ server.registerTool("update", {
         projectName: updated.projectName,
         tags: updated.tags,
     });
-    const commitStatus = await vault.git.commitWithStatus(`update: ${updated.title}`, [vaultManager.noteRelPath(vault, id)], commitBody);
-    const pushStatus = await pushAfterMutation(vault);
+    const commitMessage = `update: ${updated.title}`;
+    const commitFiles = [vaultManager.noteRelPath(vault, id)];
+    const commitStatus = await vault.git.commitWithStatus(commitMessage, commitFiles, commitBody);
+    const pushStatus = commitStatus.status === "committed"
+        ? await pushAfterMutation(vault)
+        : { status: "skipped", reason: "commit-failed" };
+    const retry = buildMutationRetryContract({
+        commit: commitStatus,
+        commitMessage,
+        commitBody,
+        files: commitFiles,
+        cwd,
+        vault,
+        mutationApplied: true,
+    });
     const persistence = buildPersistenceStatus({
         storage: vault.storage,
         id,
         embedding: embeddingStatus,
         commit: commitStatus,
         push: pushStatus,
-        commitMessage: `update: ${updated.title}`,
+        commitMessage,
         commitBody,
+        retry,
     });
     const structuredContent = {
         action: "updated",
@@ -1712,6 +1852,7 @@ server.registerTool("forget", {
     }),
     outputSchema: ForgetResultSchema,
 }, async ({ id, cwd, allowProtectedBranch = false }) => {
+    await ensureBranchSynced(cwd);
     const found = await vaultManager.findNote(id, cwd);
     if (!found) {
         return { content: [{ type: "text", text: `No memory found with id '${id}'` }], isError: true };
@@ -1745,6 +1886,7 @@ server.registerTool("forget", {
     const vaultChanges = await removeRelationshipsToNoteIds([id]);
     // Always include the deleted note's path (git add on a deleted file stages the removal)
     addVaultChange(vaultChanges, noteVault, vaultManager.noteRelPath(noteVault, id));
+    let retry;
     for (const [v, files] of vaultChanges) {
         const isPrimaryVault = v === noteVault;
         const summary = isPrimaryVault ? `Deleted note and cleaned up ${files.length - 1} reference(s)` : "Cleaned up dangling reference";
@@ -1754,8 +1896,22 @@ server.registerTool("forget", {
             noteTitle: note.title,
             projectName: note.projectName,
         });
-        await v.git.commit(`forget: ${note.title}`, files, commitBody);
-        await pushAfterMutation(v);
+        const commitMessage = `forget: ${note.title}`;
+        const commitStatus = await v.git.commitWithStatus(commitMessage, files, commitBody);
+        if (!retry) {
+            retry = buildMutationRetryContract({
+                commit: commitStatus,
+                commitMessage,
+                commitBody,
+                files,
+                cwd,
+                vault: v,
+                mutationApplied: true,
+            });
+        }
+        if (commitStatus.status === "committed") {
+            await pushAfterMutation(v);
+        }
     }
     const structuredContent = {
         action: "forgotten",
@@ -1765,6 +1921,7 @@ server.registerTool("forget", {
         projectName: note.projectName,
         relationshipsCleaned: vaultChanges.size > 0 ? Array.from(vaultChanges.values()).reduce((sum, files) => sum + files.length - 1, 0) : 0,
         vaultsModified: Array.from(vaultChanges.keys()).map(v => storageLabel(v)),
+        retry,
     };
     return { content: [{ type: "text", text: `Forgotten '${id}' (${note.title})` }], structuredContent };
 });
@@ -1794,6 +1951,7 @@ server.registerTool("get", {
     }),
     outputSchema: GetResultSchema,
 }, async ({ ids, cwd }) => {
+    await ensureBranchSynced(cwd);
     const found = [];
     const notFound = [];
     for (const id of ids) {
@@ -1864,6 +2022,7 @@ server.registerTool("where_is_memory", {
     }),
     outputSchema: WhereIsResultSchema,
 }, async ({ id, cwd }) => {
+    await ensureBranchSynced(cwd);
     const found = await vaultManager.findNote(id, cwd);
     if (!found) {
         return { content: [{ type: "text", text: `No memory found with id '${id}'` }], isError: true };
@@ -1937,6 +2096,7 @@ server.registerTool("list", {
     }),
     outputSchema: ListResultSchema,
 }, async ({ cwd, scope, storedIn, tags, includeRelations, includePreview, includeStorage, includeUpdated }) => {
+    await ensureBranchSynced(cwd);
     const { project, entries } = await collectVisibleNotes(cwd, scope, tags, storedIn);
     if (entries.length === 0) {
         const structuredContent = { action: "listed", count: 0, scope: scope || "all", storedIn: storedIn || "any", project: project ? { id: project.id, name: project.name } : undefined, notes: [] };
@@ -2009,6 +2169,7 @@ server.registerTool("recent_memories", {
     }),
     outputSchema: RecentResultSchema,
 }, async ({ cwd, scope, storedIn, limit, includePreview, includeStorage }) => {
+    await ensureBranchSynced(cwd);
     const { project, entries } = await collectVisibleNotes(cwd, scope, undefined, storedIn);
     const recent = [...entries]
         .sort((a, b) => b.note.updatedAt.localeCompare(a.note.updatedAt))
@@ -2075,6 +2236,7 @@ server.registerTool("memory_graph", {
     }),
     outputSchema: MemoryGraphResultSchema,
 }, async ({ cwd, scope, storedIn, limit }) => {
+    await ensureBranchSynced(cwd);
     const { project, entries } = await collectVisibleNotes(cwd, scope, undefined, storedIn);
     if (entries.length === 0) {
         const structuredContent = { action: "graph_shown", project: project?.id, projectName: project?.name, nodes: [], limit, truncated: false };
@@ -2151,6 +2313,7 @@ server.registerTool("project_memory_summary", {
     }),
     outputSchema: ProjectSummaryResultSchema,
 }, async ({ cwd, maxPerTheme, recentLimit }) => {
+    await ensureBranchSynced(cwd);
     const { project, entries } = await collectVisibleNotes(cwd, "all");
     if (!project) {
         return { content: [{ type: "text", text: `Could not detect a project for: ${cwd}` }], isError: true };
@@ -2342,6 +2505,7 @@ server.registerTool("move_memory", {
     }),
     outputSchema: MoveResultSchema,
 }, async ({ id, target, vaultFolder, cwd, allowProtectedBranch = false }) => {
+    await ensureBranchSynced(cwd);
     const found = await vaultManager.findNote(id, cwd);
     if (!found) {
         return { content: [{ type: "text", text: `No memory found with id '${id}'` }], isError: true };
@@ -2432,7 +2596,7 @@ server.registerTool("move_memory", {
             updatedAt: new Date().toISOString(),
         };
     }
-    const moveResult = await moveNoteBetweenVaults(found, targetVault, noteToWrite);
+    const moveResult = await moveNoteBetweenVaults(found, targetVault, noteToWrite, cwd);
     const movedNote = moveResult.note;
     const associationValue = movedNote.projectName && movedNote.project
         ? `${movedNote.projectName} (${movedNote.project})`
@@ -2494,6 +2658,7 @@ server.registerTool("relate", {
     }),
     outputSchema: RelateResultSchema,
 }, async ({ fromId, toId, type, bidirectional, cwd }) => {
+    await ensureBranchSynced(cwd);
     const [foundFrom, foundTo] = await Promise.all([
         vaultManager.findNote(fromId, cwd),
         vaultManager.findNote(toId, cwd),
@@ -2527,6 +2692,7 @@ server.registerTool("relate", {
         return { content: [{ type: "text", text: `Relationship already exists between '${fromId}' and '${toId}'` }], isError: true };
     }
     const modifiedNoteIds = [];
+    let retry;
     for (const [vault, files] of vaultChanges) {
         const isFromVault = vault === fromVault;
         const thisNote = isFromVault ? fromNote : toNote;
@@ -2541,8 +2707,22 @@ server.registerTool("relate", {
                 type,
             },
         });
-        await vault.git.commit(`relate: ${fromNote.title} ↔ ${toNote.title}`, files, commitBody);
-        await pushAfterMutation(vault);
+        const commitMessage = `relate: ${fromNote.title} ↔ ${toNote.title}`;
+        const commitStatus = await vault.git.commitWithStatus(commitMessage, files, commitBody);
+        if (!retry) {
+            retry = buildMutationRetryContract({
+                commit: commitStatus,
+                commitMessage,
+                commitBody,
+                files,
+                cwd,
+                vault,
+                mutationApplied: true,
+            });
+        }
+        if (commitStatus.status === "committed") {
+            await pushAfterMutation(vault);
+        }
         modifiedNoteIds.push(...files.map(f => path.basename(f, '.md')));
     }
     const dirStr = bidirectional ? "↔" : "→";
@@ -2553,6 +2733,7 @@ server.registerTool("relate", {
         type,
         bidirectional,
         notesModified: modifiedNoteIds,
+        retry,
     };
     return {
         content: [{ type: "text", text: `Linked \`${fromId}\` ${dirStr} \`${toId}\` (${type})` }],
@@ -2587,6 +2768,7 @@ server.registerTool("unrelate", {
     }),
     outputSchema: RelateResultSchema,
 }, async ({ fromId, toId, bidirectional, cwd }) => {
+    await ensureBranchSynced(cwd);
     const [foundFrom, foundTo] = await Promise.all([
         vaultManager.findNote(fromId, cwd),
         vaultManager.findNote(toId, cwd),
@@ -2616,6 +2798,7 @@ server.registerTool("unrelate", {
     if (vaultChanges.size === 0) {
         return { content: [{ type: "text", text: `No relationship found between '${fromId}' and '${toId}'` }], isError: true };
     }
+    let retry;
     for (const [vault, files] of vaultChanges) {
         const found = foundFrom?.vault === vault ? foundFrom : foundTo;
         const commitBody = found
@@ -2625,8 +2808,22 @@ server.registerTool("unrelate", {
                 projectName: found.note.projectName,
             })
             : undefined;
-        await vault.git.commit(`unrelate: ${fromId} ↔ ${toId}`, files, commitBody);
-        await pushAfterMutation(vault);
+        const commitMessage = `unrelate: ${fromId} ↔ ${toId}`;
+        const commitStatus = await vault.git.commitWithStatus(commitMessage, files, commitBody);
+        if (!retry) {
+            retry = buildMutationRetryContract({
+                commit: commitStatus,
+                commitMessage,
+                commitBody,
+                files,
+                cwd,
+                vault,
+                mutationApplied: true,
+            });
+        }
+        if (commitStatus.status === "committed") {
+            await pushAfterMutation(vault);
+        }
     }
     const modifiedNoteIds = [];
     for (const [vault, files] of vaultChanges) {
@@ -2639,6 +2836,7 @@ server.registerTool("unrelate", {
         type: "related-to", // not tracked for unrelate
         bidirectional,
         notesModified: modifiedNoteIds,
+        retry,
     };
     return { content: [{ type: "text", text: `Removed relationship between \`${fromId}\` and \`${toId}\`` }], structuredContent };
 });
@@ -2707,6 +2905,7 @@ server.registerTool("consolidate", {
     }),
     outputSchema: ConsolidateResultSchema,
 }, async ({ cwd, strategy, mode, threshold, mergePlan, allowProtectedBranch = false }) => {
+    await ensureBranchSynced(cwd);
     const project = await resolveProject(cwd);
     if (!project && cwd) {
         return { content: [{ type: "text", text: `Could not detect a project for: ${cwd}` }], isError: true };
@@ -2751,21 +2950,22 @@ async function detectDuplicates(entries, threshold, project) {
     const checked = new Set();
     let foundCount = 0;
     const duplicates = [];
+    const embeddings = await loadEmbeddingsByNoteId(entries);
     for (let i = 0; i < entries.length; i++) {
         const entryA = entries[i];
         if (checked.has(entryA.note.id))
             continue;
-        const embeddingA = await entryA.vault.storage.readEmbedding(entryA.note.id);
+        const embeddingA = embeddings.get(entryA.note.id);
         if (!embeddingA)
             continue;
         for (let j = i + 1; j < entries.length; j++) {
             const entryB = entries[j];
             if (checked.has(entryB.note.id))
                 continue;
-            const embeddingB = await entryB.vault.storage.readEmbedding(entryB.note.id);
+            const embeddingB = embeddings.get(entryB.note.id);
             if (!embeddingB)
                 continue;
-            const similarity = cosineSimilarity(embeddingA.embedding, embeddingB.embedding);
+            const similarity = cosineSimilarity(embeddingA, embeddingB);
             if (similarity >= threshold) {
                 foundCount++;
                 lines.push(`${foundCount}. ${entryA.note.title} (${entryA.note.id})`);
@@ -2895,11 +3095,12 @@ async function suggestMerges(entries, threshold, defaultConsolidationMode, proje
     const checked = new Set();
     let suggestionCount = 0;
     const suggestions = [];
+    const embeddings = await loadEmbeddingsByNoteId(entries);
     for (let i = 0; i < entries.length; i++) {
         const entryA = entries[i];
         if (checked.has(entryA.note.id))
             continue;
-        const embeddingA = await entryA.vault.storage.readEmbedding(entryA.note.id);
+        const embeddingA = embeddings.get(entryA.note.id);
         if (!embeddingA)
             continue;
         const similar = [];
@@ -2907,10 +3108,10 @@ async function suggestMerges(entries, threshold, defaultConsolidationMode, proje
             const entryB = entries[j];
             if (checked.has(entryB.note.id))
                 continue;
-            const embeddingB = await entryB.vault.storage.readEmbedding(entryB.note.id);
+            const embeddingB = embeddings.get(entryB.note.id);
             if (!embeddingB)
                 continue;
-            const similarity = cosineSimilarity(embeddingA.embedding, embeddingB.embedding);
+            const similarity = cosineSimilarity(embeddingA, embeddingB);
             if (similarity >= threshold) {
                 similar.push({ entry: entryB, similarity });
             }
@@ -2972,6 +3173,16 @@ async function suggestMerges(entries, threshold, defaultConsolidationMode, proje
     };
     return { content: [{ type: "text", text: lines.join("\n") }], structuredContent };
 }
+async function loadEmbeddingsByNoteId(entries) {
+    const embeddings = new Map();
+    await Promise.all(entries.map(async (entry) => {
+        const record = await entry.vault.storage.readEmbedding(entry.note.id);
+        if (record) {
+            embeddings.set(entry.note.id, record.embedding);
+        }
+    }));
+    return embeddings;
+}
 async function executeMerge(entries, mergePlan, defaultConsolidationMode, project, cwd, explicitMode, policy, allowProtectedBranch = false) {
     const sourceIds = normalizeMergePlanSourceIds(mergePlan.sourceIds);
     const targetTitle = mergePlan.targetTitle.trim();
@@ -3162,6 +3373,7 @@ async function executeMerge(entries, mergePlan, defaultConsolidationMode, projec
     let targetPushStatus = { status: "skipped", reason: "no-remote" };
     let targetCommitBody;
     let targetCommitMessage;
+    let targetCommitFiles;
     for (const [vault, files] of vaultChanges) {
         const isTargetVault = vault === targetVault;
         // Determine action and summary based on mode
@@ -3199,14 +3411,28 @@ async function executeMerge(entries, mergePlan, defaultConsolidationMode, projec
             });
         const commitMessage = `${action}: ${targetTitle}`;
         const commitStatus = await vault.git.commitWithStatus(commitMessage, files, commitBody);
-        const pushStatus = await pushAfterMutation(vault);
+        const pushStatus = commitStatus.status === "committed"
+            ? await pushAfterMutation(vault)
+            : { status: "skipped", reason: "commit-failed" };
         if (isTargetVault) {
             targetCommitStatus = commitStatus;
             targetPushStatus = pushStatus;
             targetCommitBody = commitBody;
             targetCommitMessage = commitMessage;
+            targetCommitFiles = [...files];
         }
     }
+    const retry = targetCommitMessage && targetCommitFiles
+        ? buildMutationRetryContract({
+            commit: targetCommitStatus,
+            commitMessage: targetCommitMessage,
+            commitBody: targetCommitBody,
+            files: targetCommitFiles,
+            cwd,
+            vault: targetVault,
+            mutationApplied: true,
+        })
+        : undefined;
     const persistence = buildPersistenceStatus({
         storage: targetVault.storage,
         id: targetId,
@@ -3215,6 +3441,7 @@ async function executeMerge(entries, mergePlan, defaultConsolidationMode, projec
         push: targetPushStatus,
         commitMessage: targetCommitMessage,
         commitBody: targetCommitBody,
+        retry,
     });
     const lines = [];
     lines.push(`Consolidated ${sourceIds.length} notes into '${targetId}'`);
@@ -3245,6 +3472,7 @@ async function executeMerge(entries, mergePlan, defaultConsolidationMode, projec
         notesProcessed: entries.length,
         notesModified: vaultChanges.size,
         persistence,
+        retry,
     };
     return { content: [{ type: "text", text: lines.join("\n") }], structuredContent };
 }
@@ -3370,14 +3598,29 @@ async function pruneSuperseded(entries, consolidationMode, project, cwd, policy,
         }
     }
     // Commit changes per vault
+    let retry;
     for (const [vault, files] of vaultChanges) {
         const prunedIds = files.map((f) => f.replace(/\.mnemonic\/notes\/(.+)\.md$/, "$1").replace(/notes\/(.+)\.md$/, "$1"));
         const commitBody = formatCommitBody({
             noteIds: prunedIds,
             description: `Pruned ${prunedIds.length} superseded note(s)\nNotes: ${prunedIds.join(", ")}`,
         });
-        await vault.git.commit(`prune: removed ${files.length} superseded note(s)`, files, commitBody);
-        await pushAfterMutation(vault);
+        const commitMessage = `prune: removed ${files.length} superseded note(s)`;
+        const commitStatus = await vault.git.commitWithStatus(commitMessage, files, commitBody);
+        if (!retry) {
+            retry = buildMutationRetryContract({
+                commit: commitStatus,
+                commitMessage,
+                commitBody,
+                files,
+                cwd,
+                vault,
+                mutationApplied: true,
+            });
+        }
+        if (commitStatus.status === "committed") {
+            await pushAfterMutation(vault);
+        }
     }
     lines.push("");
     lines.push(`Pruned ${supersededIds.size} note(s).`);
@@ -3388,6 +3631,7 @@ async function pruneSuperseded(entries, consolidationMode, project, cwd, policy,
         projectName: project?.name,
         notesProcessed: entries.length,
         notesModified: vaultChanges.size,
+        retry,
     };
     return { content: [{ type: "text", text: lines.join("\n") }], structuredContent };
 }