@danielmarbach/mnemonic-mcp 0.26.0 → 0.26.2

package/CHANGELOG.md

@@ -6,6 +6,21 @@ The format is loosely based on Keep a Changelog and uses semver-style version he
 
 ## [Unreleased]
 
+## [0.26.2] - 2026-04-26
+
+### Fixed
+
+- `update` skips write/commit/embed when no fields actually changed.
+- `update` `fieldsModified` tracks actual value differences, not parameter presence.
+- Metadata-only updates no longer trigger re-embedding.
+
+## [0.26.1] - 2026-04-26
+
+### Changed
+
+- Improved `heading` selector error message to suggest `headingStartsWith` for prefix matching when exact headings are uncertain.
+- `mnemonic-rpi-workflow` skill: added explicit handoff checkpoints between Research→Plan and Plan→Implement to prevent proceeding without user confirmation at natural workflow boundaries.
+
 ## [0.26.0] - 2026-04-25
 
 ### Added

package/build/index.js

@@ -19,6 +19,7 @@ import { shouldTriggerLexicalRescue, prepareTfIdfCorpusFromTokenizedDocuments, r
 import { getRelationshipPreview } from "./relationships.js";
 import { MarkdownLintError, cleanMarkdown } from "./markdown.js";
 import { applySemanticPatches } from "./semantic-patch.js";
+import { hasActualChanges, computeFieldsModified } from "./update-detect-changes.js";
 import { MnemonicConfigStore, readVaultSchemaVersion } from "./config.js";
 import { CONSOLIDATION_MODES, PROTECTED_BRANCH_BEHAVIORS, PROJECT_POLICY_SCOPES, WRITE_SCOPES, isProtectedBranch, resolveProtectedBranchBehavior, resolveProtectedBranchPatterns, resolveConsolidationMode, resolveWriteScope, } from "./project-memory-policy.js";
 import { classifyTheme, classifyThemeWithGraduation, computeThemesWithGraduation, summarizePreview, titleCaseTheme, daysSinceUpdate, withinThemeScore, anchorScore, computeConnectionDiversity, workingStateScore, extractNextAction, } from "./project-introspection.js";
@@ -2316,64 +2317,136 @@ server.registerTool("update", {
         }
     }
     const cleanedContent = content === undefined ? undefined : await cleanMarkdown(content);
-    const updated = {
-        ...note,
-        title: title ?? note.title,
-        content: patchedContent ?? cleanedContent ?? note.content,
-        tags: tags ?? note.tags,
-        lifecycle: lifecycle ?? note.lifecycle,
-        ...(role !== undefined ? { role } : (note.role ? { role: note.role } : {})),
-        alwaysLoad: alwaysLoad !== undefined ? alwaysLoad : note.alwaysLoad,
-        updatedAt: now,
-    };
-    if (updated.project) {
-        const accessCandidates = getRecentSessionNoteAccesses(updated.project)
+    const resolvedTitle = title ?? note.title;
+    const resolvedContent = patchedContent ?? cleanedContent ?? note.content;
+    const resolvedTags = tags ?? note.tags;
+    const resolvedLifecycle = lifecycle ?? note.lifecycle;
+    const resolvedRole = role !== undefined ? role : (note.role ? note.role : undefined);
+    const resolvedAlwaysLoad = alwaysLoad !== undefined ? alwaysLoad : note.alwaysLoad;
+    let relatedToChanged = false;
+    let resolvedRelatedTo = note.relatedTo;
+    if (note.project) {
+        const accessCandidates = getRecentSessionNoteAccesses(note.project)
             .map((entry) => {
-            const cachedNote = getSessionCachedNote(updated.project, entry.vaultPath, entry.noteId)
-                ?? getRecentSessionAccessNote(updated.project, entry.vaultPath, entry.noteId);
+            const cachedNote = getSessionCachedNote(note.project, entry.vaultPath, entry.noteId)
+                ?? getRecentSessionAccessNote(note.project, entry.vaultPath, entry.noteId);
             return cachedNote
                 ? { note: cachedNote, accessedAt: entry.accessedAt, accessKind: entry.accessKind, score: entry.score }
                 : null;
         })
             .filter((entry) => entry !== null);
-        const autoRelationships = suggestAutoRelationships(updated, accessCandidates);
+        const autoRelationships = suggestAutoRelationships({
+            ...note,
+            title: resolvedTitle,
+            content: resolvedContent,
+            tags: resolvedTags,
+            lifecycle: resolvedLifecycle,
+            alwaysLoad: resolvedAlwaysLoad,
+        }, accessCandidates);
         if (autoRelationships.length > 0) {
-            const existing = [...(updated.relatedTo ?? [])];
+            const existing = [...(note.relatedTo ?? [])];
             for (const relationship of autoRelationships) {
                 if (!existing.some((rel) => rel.id === relationship.id && rel.type === relationship.type)) {
                     existing.push(relationship);
                 }
             }
-            updated.relatedTo = existing;
-        }
+            resolvedRelatedTo = existing;
+            relatedToChanged = true;
+        }
+    }
+    const changes = computeFieldsModified({
+        patchedContent,
+        originalContent: note.content,
+        contentExplicitlyProvided: content !== undefined,
+        semanticPatchProvided: semanticPatch !== undefined && semanticPatch.length > 0,
+        newTitle: resolvedTitle,
+        originalTitle: note.title,
+        titleExplicitlyProvided: title !== undefined,
+        newLifecycle: resolvedLifecycle,
+        originalLifecycle: note.lifecycle,
+        lifecycleExplicitlyProvided: lifecycle !== undefined,
+        newRole: resolvedRole,
+        originalRole: note.role,
+        roleExplicitlySet: role !== undefined,
+        newTags: resolvedTags,
+        originalTags: note.tags,
+        tagsExplicitlyProvided: tags !== undefined,
+        newAlwaysLoad: resolvedAlwaysLoad,
+        originalAlwaysLoad: note.alwaysLoad,
+        alwaysLoadExplicitlyProvided: alwaysLoad !== undefined,
+        relatedToChanged,
+    });
+    const hasChanges = hasActualChanges({
+        content: cleanedContent,
+        originalContent: note.content,
+        title,
+        originalTitle: note.title,
+        tags,
+        originalTags: note.tags,
+        lifecycle,
+        originalLifecycle: note.lifecycle,
+        role,
+        originalRole: note.role,
+        roleExplicitlySet: role !== undefined,
+        alwaysLoad,
+        originalAlwaysLoad: note.alwaysLoad,
+        semanticPatchApplied: semanticPatch !== undefined && semanticPatch.length > 0,
+        relatedToChanged,
+    });
+    if (!hasChanges) {
+        const noOpPersistence = {
+            notePath: vault.storage.notePath(id),
+            embeddingPath: vault.storage.embeddingPath(id),
+            embedding: { status: "skipped", model: embedModel, reason: "no-changes" },
+            git: {
+                commit: "skipped",
+                push: "skipped",
+                commitReason: "no-changes",
+                pushReason: "no-changes",
+            },
+            durability: "local-only",
+        };
+        return {
+            content: [{ type: "text", text: `No changes to memory '${id}'` }],
+            structuredContent: {
+                action: "updated",
+                id,
+                title: note.title,
+                fieldsModified: [],
+                timestamp: note.updatedAt,
+                project: noteProjectRef(note),
+                lifecycle: note.lifecycle,
+                role: note.role,
+                persistence: noOpPersistence,
+            },
+        };
     }
+    const updated = {
+        ...note,
+        title: resolvedTitle,
+        content: resolvedContent,
+        tags: resolvedTags,
+        lifecycle: resolvedLifecycle,
+        ...(role !== undefined ? { role: resolvedRole } : (note.role ? { role: note.role } : {})),
+        alwaysLoad: resolvedAlwaysLoad,
+        updatedAt: now,
+        relatedTo: resolvedRelatedTo,
+    };
     await vault.storage.writeNote(updated);
-    let embeddingStatus = { status: "written" };
-    try {
-        const text = await embedTextForNote(vault.storage, updated);
-        const vector = await embed(text);
-        await vault.storage.writeEmbedding({ id, model: embedModel, embedding: vector, updatedAt: now });
+    const shouldReembed = patchedContent !== undefined || cleanedContent !== undefined;
+    let embeddingStatus = { status: "skipped", reason: shouldReembed ? undefined : "metadata-only" };
+    if (shouldReembed) {
+        try {
+            const text = await embedTextForNote(vault.storage, updated);
+            const vector = await embed(text);
+            await vault.storage.writeEmbedding({ id, model: embedModel, embedding: vector, updatedAt: now });
+            embeddingStatus = { status: "written" };
+        }
+        catch (err) {
+            embeddingStatus = { status: "skipped", reason: err instanceof Error ? err.message : String(err) };
+            console.error(`[embedding] Re-embed failed for '${id}': ${err}`);
+        }
     }
-    catch (err) {
-        embeddingStatus = { status: "skipped", reason: err instanceof Error ? err.message : String(err) };
-        console.error(`[embedding] Re-embed failed for '${id}': ${err}`);
-    }
-    // Build change summary (LLM-provided or auto-generated)
-    const changes = [];
-    if (title !== undefined && title !== note.title)
-        changes.push("title");
-    if (content !== undefined)
-        changes.push("content");
-    if (semanticPatch !== undefined)
-        changes.push("semanticPatch");
-    if (tags !== undefined)
-        changes.push("tags");
-    if (lifecycle !== undefined && lifecycle !== note.lifecycle)
-        changes.push("lifecycle");
-    if (role !== undefined && role !== note.role)
-        changes.push("role");
-    if (alwaysLoad !== undefined && alwaysLoad !== note.alwaysLoad)
-        changes.push("alwaysLoad");
     const changeDesc = changes.length > 0 ? `Updated ${changes.join(", ")}` : "No changes";
     const commitSummary = summary ?? changeDesc;
     const commitBody = formatCommitBody({