@velvetmonkey/flywheel-crank 0.10.0 → 0.11.1

package/dist/index.js

@@ -141,22 +141,106 @@ function findSection(content, sectionName) {
     contentStartLine
   };
 }
+function isInsideCodeBlock(lines, currentIndex) {
+  let fenceCount = 0;
+  for (let i = 0; i < currentIndex; i++) {
+    if (lines[i].trim().startsWith("```")) {
+      fenceCount++;
+    }
+  }
+  return fenceCount % 2 === 1;
+}
+function isStructuredLine(line) {
+  const trimmed = line.trimStart();
+  return trimmed.startsWith("|") || // Table row
+  trimmed.startsWith(">") || // Blockquote
+  trimmed.startsWith("```") || // Code fence
+  /^-{3,}$/.test(trimmed) || // Horizontal rule (dashes)
+  /^\*{3,}$/.test(trimmed) || // Horizontal rule (asterisks)
+  /^_{3,}$/.test(trimmed);
+}
+function isPreformattedList(content) {
+  const trimmed = content.trim();
+  if (!trimmed)
+    return false;
+  const firstLine = trimmed.split("\n")[0];
+  return /^[-*+]\s/.test(firstLine) || // Bullet
+  /^\d+\.\s/.test(firstLine) || // Numbered
+  /^[-*+]\s*\[[ xX]\]/.test(firstLine);
+}
 function formatContent(content, format) {
   const trimmed = content.trim();
   switch (format) {
     case "plain":
       return trimmed;
-    case "bullet":
-      return `- ${trimmed}`;
-    case "task":
-      return `- [ ] ${trimmed}`;
-    case "numbered":
-      return `1. ${trimmed}`;
+    case "bullet": {
+      if (isPreformattedList(trimmed)) {
+        return trimmed;
+      }
+      const lines = trimmed.split("\n");
+      return lines.map((line, i) => {
+        if (i === 0)
+          return `- ${line}`;
+        if (line === "")
+          return "";
+        if (isInsideCodeBlock(lines, i) || isStructuredLine(line)) {
+          return line;
+        }
+        return `  ${line}`;
+      }).join("\n");
+    }
+    case "task": {
+      if (isPreformattedList(trimmed)) {
+        return trimmed;
+      }
+      const lines = trimmed.split("\n");
+      return lines.map((line, i) => {
+        if (i === 0)
+          return `- [ ] ${line}`;
+        if (line === "")
+          return "";
+        if (isInsideCodeBlock(lines, i) || isStructuredLine(line)) {
+          return line;
+        }
+        return `      ${line}`;
+      }).join("\n");
+    }
+    case "numbered": {
+      if (isPreformattedList(trimmed)) {
+        return trimmed;
+      }
+      const lines = trimmed.split("\n");
+      return lines.map((line, i) => {
+        if (i === 0)
+          return `1. ${line}`;
+        if (line === "")
+          return "";
+        if (isInsideCodeBlock(lines, i) || isStructuredLine(line)) {
+          return line;
+        }
+        return `   ${line}`;
+      }).join("\n");
+    }
     case "timestamp-bullet": {
+      if (isPreformattedList(trimmed)) {
+        return trimmed;
+      }
       const now = /* @__PURE__ */ new Date();
       const hours = String(now.getHours()).padStart(2, "0");
       const minutes = String(now.getMinutes()).padStart(2, "0");
-      return `- **${hours}:${minutes}** ${trimmed}`;
+      const prefix = `- **${hours}:${minutes}** `;
+      const lines = trimmed.split("\n");
+      const indent = "  ";
+      return lines.map((line, i) => {
+        if (i === 0)
+          return `${prefix}${line}`;
+        if (line === "")
+          return "";
+        if (isInsideCodeBlock(lines, i) || isStructuredLine(line)) {
+          return line;
+        }
+        return `${indent}${line}`;
+      }).join("\n");
     }
     default:
       return trimmed;
@@ -198,7 +282,13 @@ function insertInSection(content, section, newContent, position, options) {
         break;
       }
       if (indent) {
-        const indentedContent = formattedContent.split("\n").map((line) => indent + line).join("\n");
+        const contentLines = formattedContent.split("\n");
+        const indentedContent = contentLines.map((line, i) => {
+          if (line === "" || isInsideCodeBlock(contentLines, i) || isStructuredLine(line)) {
+            return line;
+          }
+          return indent + line;
+        }).join("\n");
         lines.splice(section.contentStartLine, 0, indentedContent);
       } else {
         lines.splice(section.contentStartLine, 0, formattedContent);
@@ -217,7 +307,13 @@ function insertInSection(content, section, newContent, position, options) {
     if (lastContentLineIdx >= section.contentStartLine && isEmptyPlaceholder(lines[lastContentLineIdx])) {
       if (options?.preserveListNesting) {
         const indent = detectSectionBaseIndentation(lines, section.contentStartLine, section.endLine);
-        const indentedContent = formattedContent.split("\n").map((line) => indent + line).join("\n");
+        const contentLines = formattedContent.split("\n");
+        const indentedContent = contentLines.map((line, i) => {
+          if (line === "" || isInsideCodeBlock(contentLines, i) || isStructuredLine(line)) {
+            return line;
+          }
+          return indent + line;
+        }).join("\n");
         lines[lastContentLineIdx] = indentedContent;
       } else {
         lines[lastContentLineIdx] = formattedContent;
@@ -236,7 +332,13 @@ function insertInSection(content, section, newContent, position, options) {
       }
       if (options?.preserveListNesting) {
         const indent = detectSectionBaseIndentation(lines, section.contentStartLine, section.endLine);
-        const indentedContent = formattedContent.split("\n").map((line) => indent + line).join("\n");
+        const contentLines = formattedContent.split("\n");
+        const indentedContent = contentLines.map((line, i) => {
+          if (line === "" || isInsideCodeBlock(contentLines, i) || isStructuredLine(line)) {
+            return line;
+          }
+          return indent + line;
+        }).join("\n");
         lines.splice(insertLine, 0, indentedContent);
       } else {
         lines.splice(insertLine, 0, formattedContent);
@@ -421,9 +523,236 @@ function replaceInSection(content, section, search, replacement, mode = "first",
   };
 }
 
+// src/core/validator.ts
+var TIMESTAMP_PATTERN = /^\*\*\d{2}:\d{2}\*\*/;
+var NON_MARKDOWN_BULLET_PATTERNS = [
+  /^[\s]*\u2022/,
+  // • (bullet)
+  /^[\s]*\u25E6/,
+  // ◦ (hollow bullet)
+  /^[\s]*\u25AA/,
+  // ▪ (small square)
+  /^[\s]*\u25AB/,
+  // ▫ (hollow small square)
+  /^[\s]*\u2023/,
+  // ‣ (triangular bullet)
+  /^[\s]*\u2043/
+  // ⁃ (hyphen bullet)
+];
+var EMBEDDED_HEADING_PATTERN = /^#{1,6}\s+/m;
+function validateInput(content, format) {
+  const warnings = [];
+  if (format === "timestamp-bullet" && TIMESTAMP_PATTERN.test(content.trim())) {
+    warnings.push({
+      type: "double-timestamp",
+      message: "Content already contains a timestamp prefix, and format is timestamp-bullet",
+      suggestion: 'Use format: "plain" or "bullet" instead to avoid duplicate timestamps'
+    });
+  }
+  const lines = content.split("\n");
+  for (const line of lines) {
+    for (const pattern of NON_MARKDOWN_BULLET_PATTERNS) {
+      if (pattern.test(line)) {
+        warnings.push({
+          type: "non-markdown-bullets",
+          message: `Non-markdown bullet character detected: "${line.trim().charAt(0)}"`,
+          suggestion: "Use markdown bullets (-) for proper rendering"
+        });
+        break;
+      }
+    }
+  }
+  if (EMBEDDED_HEADING_PATTERN.test(content)) {
+    warnings.push({
+      type: "embedded-heading",
+      message: "Content contains markdown heading syntax (##)",
+      suggestion: "Use bold (**text**) instead of headings inside list items"
+    });
+  }
+  const fenceCount = (content.match(/^```/gm) || []).length;
+  if (fenceCount % 2 !== 0) {
+    warnings.push({
+      type: "orphaned-fence",
+      message: "Odd number of code fence markers (```) detected",
+      suggestion: "Ensure code blocks are properly closed"
+    });
+  }
+  return {
+    isValid: warnings.length === 0,
+    warnings
+  };
+}
+function normalizeInput(content, format) {
+  let normalized = content;
+  const changes = [];
+  if (format === "timestamp-bullet" && TIMESTAMP_PATTERN.test(normalized.trim())) {
+    normalized = normalized.trim().replace(TIMESTAMP_PATTERN, "").trim();
+    changes.push("Removed duplicate timestamp prefix");
+  }
+  const lines = normalized.split("\n");
+  let bulletReplaced = false;
+  const normalizedLines = lines.map((line) => {
+    for (const pattern of NON_MARKDOWN_BULLET_PATTERNS) {
+      if (pattern.test(line)) {
+        bulletReplaced = true;
+        return line.replace(/^([\s]*)[•◦▪▫‣⁃]\s*/, "$1- ");
+      }
+    }
+    return line;
+  });
+  if (bulletReplaced) {
+    normalized = normalizedLines.join("\n");
+    changes.push('Replaced non-markdown bullets with "-"');
+  }
+  const trimmed = normalized.replace(/\n{3,}/g, "\n\n");
+  if (trimmed !== normalized) {
+    normalized = trimmed;
+    changes.push("Trimmed excessive blank lines");
+  }
+  return {
+    content: normalized,
+    normalized: changes.length > 0,
+    changes
+  };
+}
+function validateOutput(formatted) {
+  const issues = [];
+  const tableRows = formatted.match(/^\s*\|.*\|/gm);
+  if (tableRows && tableRows.length > 1) {
+    const pipeCounts = tableRows.map((row) => (row.match(/\|/g) || []).length);
+    const firstPipeCount = pipeCounts[0];
+    const hasInconsistentPipes = pipeCounts.some((count) => count !== firstPipeCount);
+    if (hasInconsistentPipes) {
+      issues.push({
+        type: "broken-table",
+        severity: "error",
+        message: "Table rows have inconsistent pipe counts - table alignment may be broken"
+      });
+    }
+  }
+  const fenceCount = (formatted.match(/^```/gm) || []).length;
+  if (fenceCount % 2 !== 0) {
+    issues.push({
+      type: "orphaned-fence",
+      severity: "error",
+      message: "Odd number of code fence markers - code block may be unclosed"
+    });
+  }
+  const indentedFences = formatted.match(/^[ \t]+```/gm);
+  if (indentedFences && indentedFences.length > 0) {
+    const lines = formatted.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (/^[ \t]+```/.test(lines[i])) {
+        issues.push({
+          type: "indented-fence",
+          severity: "warning",
+          message: "Code fence marker is indented - this may break the code block",
+          line: i + 1
+        });
+      }
+    }
+  }
+  const blockquoteLines = formatted.match(/^[ \t]*>/gm);
+  if (blockquoteLines) {
+    const lines = formatted.split("\n");
+    let inBlockquote = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const isBlockquoteLine = /^[ \t]*>/.test(line);
+      if (isBlockquoteLine) {
+        inBlockquote = true;
+      } else if (inBlockquote && line.trim() !== "" && !/^[ \t]*>/.test(line)) {
+        if (/^[ \t]+[^-*>\d]/.test(line)) {
+          issues.push({
+            type: "broken-blockquote",
+            severity: "warning",
+            message: "Blockquote structure may be broken - continuation line not prefixed with >",
+            line: i + 1
+          });
+        }
+        inBlockquote = false;
+      } else if (line.trim() === "") {
+        inBlockquote = false;
+      }
+    }
+  }
+  return {
+    valid: issues.filter((i) => i.severity === "error").length === 0,
+    issues
+  };
+}
+function runValidationPipeline(content, format, options = {}) {
+  const {
+    validate = true,
+    normalize = true,
+    guardrails = "warn"
+  } = options;
+  let processedContent = content;
+  let inputWarnings = [];
+  let normalizationChanges = [];
+  let outputIssues = [];
+  let blocked = false;
+  let blockReason;
+  if (validate) {
+    const inputResult = validateInput(content, format);
+    inputWarnings = inputResult.warnings;
+  }
+  if (normalize) {
+    const normResult = normalizeInput(processedContent, format);
+    processedContent = normResult.content;
+    normalizationChanges = normResult.changes;
+  }
+  if (guardrails !== "off") {
+    const outputResult = validateOutput(processedContent);
+    outputIssues = outputResult.issues;
+    if (guardrails === "strict" && !outputResult.valid) {
+      blocked = true;
+      const errors = outputIssues.filter((i) => i.severity === "error");
+      blockReason = `Output validation failed: ${errors.map((e) => e.message).join("; ")}`;
+    }
+  }
+  return {
+    content: processedContent,
+    inputWarnings,
+    outputIssues,
+    normalizationChanges,
+    blocked,
+    blockReason
+  };
+}
+
 // src/core/git.ts
 import { simpleGit, CheckRepoActions } from "simple-git";
 import path2 from "path";
+import fs2 from "fs/promises";
+var LAST_COMMIT_FILE = ".claude/last-crank-commit.json";
+async function saveLastCrankCommit(vaultPath2, hash, message) {
+  const filePath = path2.join(vaultPath2, LAST_COMMIT_FILE);
+  const dirPath = path2.dirname(filePath);
+  await fs2.mkdir(dirPath, { recursive: true });
+  const data = {
+    hash,
+    message,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await fs2.writeFile(filePath, JSON.stringify(data, null, 2));
+}
+async function getLastCrankCommit(vaultPath2) {
+  try {
+    const filePath = path2.join(vaultPath2, LAST_COMMIT_FILE);
+    const content = await fs2.readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function clearLastCrankCommit(vaultPath2) {
+  try {
+    const filePath = path2.join(vaultPath2, LAST_COMMIT_FILE);
+    await fs2.unlink(filePath);
+  } catch {
+  }
+}
 async function isGitRepo(vaultPath2) {
   try {
     const git = simpleGit(vaultPath2);
@@ -447,6 +776,9 @@ async function commitChange(vaultPath2, filePath, messagePrefix) {
     const fileName = path2.basename(filePath);
     const commitMessage = `${messagePrefix} Update ${fileName}`;
     const result = await git.commit(commitMessage);
+    if (result.commit) {
+      await saveLastCrankCommit(vaultPath2, result.commit, commitMessage);
+    }
     return {
       success: true,
       hash: result.commit
@@ -1722,7 +2054,7 @@ function suggestRelatedLinks(content, options = {}) {
 }
 
 // src/tools/mutations.ts
-import fs2 from "fs/promises";
+import fs3 from "fs/promises";
 import path5 from "path";
 function registerMutationTools(server2, vaultPath2) {
   server2.tool(
@@ -1738,13 +2070,16 @@ function registerMutationTools(server2, vaultPath2) {
       skipWikilinks: z.boolean().default(false).describe("If true, skip auto-wikilink application (wikilinks are applied by default)"),
       preserveListNesting: z.boolean().default(true).describe("Detect and preserve the indentation level of surrounding list items. Set false to disable."),
       suggestOutgoingLinks: z.boolean().default(true).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]] [[Philosophy]]"). Set false to disable.'),
-      maxSuggestions: z.number().min(1).max(10).default(3).describe("Maximum number of suggested wikilinks to append (1-10, default: 3)")
+      maxSuggestions: z.number().min(1).max(10).default(3).describe("Maximum number of suggested wikilinks to append (1-10, default: 3)"),
+      validate: z.boolean().default(true).describe("Check input for common issues (double timestamps, non-markdown bullets, etc.)"),
+      normalize: z.boolean().default(true).describe("Auto-fix common issues before formatting (replace \u2022 with -, trim excessive whitespace, etc.)"),
+      guardrails: z.enum(["warn", "strict", "off"]).default("warn").describe('Output validation mode: "warn" returns issues but proceeds, "strict" blocks on errors, "off" disables')
     },
-    async ({ path: notePath, section, content, position, format, commit, skipWikilinks, preserveListNesting, suggestOutgoingLinks, maxSuggestions }) => {
+    async ({ path: notePath, section, content, position, format, commit, skipWikilinks, preserveListNesting, suggestOutgoingLinks, maxSuggestions, validate, normalize, guardrails }) => {
       try {
         const fullPath = path5.join(vaultPath2, notePath);
         try {
-          await fs2.access(fullPath);
+          await fs3.access(fullPath);
         } catch {
           const result2 = {
             success: false,
@@ -1767,7 +2102,25 @@ function registerMutationTools(server2, vaultPath2) {
           result2.tokensEstimate = estimateTokens(result2);
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        let { content: processedContent, wikilinkInfo } = maybeApplyWikilinks(content, skipWikilinks);
+        const validationResult = runValidationPipeline(content, format, {
+          validate,
+          normalize,
+          guardrails
+        });
+        if (validationResult.blocked) {
+          const result2 = {
+            success: false,
+            message: validationResult.blockReason || "Output validation failed",
+            path: notePath,
+            warnings: validationResult.inputWarnings,
+            outputIssues: validationResult.outputIssues,
+            tokensEstimate: 0
+          };
+          result2.tokensEstimate = estimateTokens(result2);
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        let workingContent = validationResult.content;
+        let { content: processedContent, wikilinkInfo } = maybeApplyWikilinks(workingContent, skipWikilinks);
         let suggestInfo;
         if (suggestOutgoingLinks && !skipWikilinks) {
           const result2 = suggestRelatedLinks(processedContent, { maxSuggestions });
@@ -1805,8 +2158,12 @@ function registerMutationTools(server2, vaultPath2) {
           preview,
           gitCommit,
           gitError,
-          tokensEstimate: 0
+          tokensEstimate: 0,
           // Will be set below
+          // Include validation info if present
+          ...validationResult.inputWarnings.length > 0 && { warnings: validationResult.inputWarnings },
+          ...validationResult.outputIssues.length > 0 && { outputIssues: validationResult.outputIssues },
+          ...validationResult.normalizationChanges.length > 0 && { normalizationChanges: validationResult.normalizationChanges }
         };
         result.tokensEstimate = estimateTokens(result);
         return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
@@ -1837,7 +2194,7 @@ function registerMutationTools(server2, vaultPath2) {
       try {
         const fullPath = path5.join(vaultPath2, notePath);
         try {
-          await fs2.access(fullPath);
+          await fs3.access(fullPath);
         } catch {
           const result2 = {
             success: false,
@@ -1924,13 +2281,16 @@ function registerMutationTools(server2, vaultPath2) {
       commit: z.boolean().default(false).describe("If true, commit this change to git (creates undo point)"),
       skipWikilinks: z.boolean().default(false).describe("If true, skip auto-wikilink application on replacement text"),
       suggestOutgoingLinks: z.boolean().default(true).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]] [[Philosophy]]"). Set false to disable.'),
-      maxSuggestions: z.number().min(1).max(10).default(3).describe("Maximum number of suggested wikilinks to append (1-10, default: 3)")
+      maxSuggestions: z.number().min(1).max(10).default(3).describe("Maximum number of suggested wikilinks to append (1-10, default: 3)"),
+      validate: z.boolean().default(true).describe("Check input for common issues (double timestamps, non-markdown bullets, etc.)"),
+      normalize: z.boolean().default(true).describe("Auto-fix common issues before formatting (replace \u2022 with -, trim excessive whitespace, etc.)"),
+      guardrails: z.enum(["warn", "strict", "off"]).default("warn").describe('Output validation mode: "warn" returns issues but proceeds, "strict" blocks on errors, "off" disables')
     },
-    async ({ path: notePath, section, search, replacement, mode, useRegex, commit, skipWikilinks, suggestOutgoingLinks, maxSuggestions }) => {
+    async ({ path: notePath, section, search, replacement, mode, useRegex, commit, skipWikilinks, suggestOutgoingLinks, maxSuggestions, validate, normalize, guardrails }) => {
       try {
         const fullPath = path5.join(vaultPath2, notePath);
         try {
-          await fs2.access(fullPath);
+          await fs3.access(fullPath);
         } catch {
           const result2 = {
             success: false,
@@ -1953,7 +2313,25 @@ function registerMutationTools(server2, vaultPath2) {
           result2.tokensEstimate = estimateTokens(result2);
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        let { content: processedReplacement, wikilinkInfo } = maybeApplyWikilinks(replacement, skipWikilinks);
+        const validationResult = runValidationPipeline(replacement, "plain", {
+          validate,
+          normalize,
+          guardrails
+        });
+        if (validationResult.blocked) {
+          const result2 = {
+            success: false,
+            message: validationResult.blockReason || "Output validation failed",
+            path: notePath,
+            warnings: validationResult.inputWarnings,
+            outputIssues: validationResult.outputIssues,
+            tokensEstimate: 0
+          };
+          result2.tokensEstimate = estimateTokens(result2);
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        let workingReplacement = validationResult.content;
+        let { content: processedReplacement, wikilinkInfo } = maybeApplyWikilinks(workingReplacement, skipWikilinks);
         let suggestInfo;
         if (suggestOutgoingLinks && !skipWikilinks) {
           const result2 = suggestRelatedLinks(processedReplacement, { maxSuggestions });
@@ -2002,7 +2380,11 @@ function registerMutationTools(server2, vaultPath2) {
           preview: previewLines.join("\n"),
           gitCommit,
           gitError,
-          tokensEstimate: 0
+          tokensEstimate: 0,
+          // Include validation info if present
+          ...validationResult.inputWarnings.length > 0 && { warnings: validationResult.inputWarnings },
+          ...validationResult.outputIssues.length > 0 && { outputIssues: validationResult.outputIssues },
+          ...validationResult.normalizationChanges.length > 0 && { normalizationChanges: validationResult.normalizationChanges }
         };
         result.tokensEstimate = estimateTokens(result);
         return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
@@ -2023,7 +2405,7 @@ function registerMutationTools(server2, vaultPath2) {
 
 // src/tools/tasks.ts
 import { z as z2 } from "zod";
-import fs3 from "fs/promises";
+import fs4 from "fs/promises";
 import path6 from "path";
 var TASK_REGEX = /^(\s*)-\s*\[([ xX])\]\s*(.*)$/;
 function findTasks(content, section) {
@@ -2082,7 +2464,7 @@ function registerTaskTools(server2, vaultPath2) {
       try {
         const fullPath = path6.join(vaultPath2, notePath);
         try {
-          await fs3.access(fullPath);
+          await fs4.access(fullPath);
         } catch {
           const result2 = {
             success: false,
@@ -2184,13 +2566,16 @@ function registerTaskTools(server2, vaultPath2) {
       skipWikilinks: z2.boolean().default(false).describe("If true, skip auto-wikilink application (wikilinks are applied by default)"),
       suggestOutgoingLinks: z2.boolean().default(true).describe('Append suggested outgoing wikilinks based on content (e.g., "\u2192 [[AI]] [[Philosophy]]"). Set false to disable.'),
       maxSuggestions: z2.number().min(1).max(10).default(3).describe("Maximum number of suggested wikilinks to append (1-10, default: 3)"),
-      preserveListNesting: z2.boolean().default(true).describe("Preserve indentation when inserting into nested lists. Default: true")
+      preserveListNesting: z2.boolean().default(true).describe("Preserve indentation when inserting into nested lists. Default: true"),
+      validate: z2.boolean().default(true).describe("Check input for common issues"),
+      normalize: z2.boolean().default(true).describe("Auto-fix common issues before formatting"),
+      guardrails: z2.enum(["warn", "strict", "off"]).default("warn").describe("Output validation mode")
     },
-    async ({ path: notePath, section, task, position, completed, commit, skipWikilinks, suggestOutgoingLinks, maxSuggestions, preserveListNesting }) => {
+    async ({ path: notePath, section, task, position, completed, commit, skipWikilinks, suggestOutgoingLinks, maxSuggestions, preserveListNesting, validate, normalize, guardrails }) => {
       try {
         const fullPath = path6.join(vaultPath2, notePath);
         try {
-          await fs3.access(fullPath);
+          await fs4.access(fullPath);
         } catch {
           const result2 = {
             success: false,
@@ -2213,7 +2598,25 @@ function registerTaskTools(server2, vaultPath2) {
           result2.tokensEstimate = estimateTokens(result2);
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        let { content: processedTask, wikilinkInfo } = maybeApplyWikilinks(task.trim(), skipWikilinks);
+        const validationResult = runValidationPipeline(task.trim(), "task", {
+          validate,
+          normalize,
+          guardrails
+        });
+        if (validationResult.blocked) {
+          const result2 = {
+            success: false,
+            message: validationResult.blockReason || "Output validation failed",
+            path: notePath,
+            warnings: validationResult.inputWarnings,
+            outputIssues: validationResult.outputIssues,
+            tokensEstimate: 0
+          };
+          result2.tokensEstimate = estimateTokens(result2);
+          return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+        }
+        let workingTask = validationResult.content;
+        let { content: processedTask, wikilinkInfo } = maybeApplyWikilinks(workingTask, skipWikilinks);
         let suggestInfo;
         if (suggestOutgoingLinks && !skipWikilinks) {
           const result2 = suggestRelatedLinks(processedTask, { maxSuggestions });
@@ -2251,7 +2654,11 @@ function registerTaskTools(server2, vaultPath2) {
 (${infoLines.join("; ")})` : ""),
           gitCommit,
           gitError,
-          tokensEstimate: 0
+          tokensEstimate: 0,
+          // Include validation info if present
+          ...validationResult.inputWarnings.length > 0 && { warnings: validationResult.inputWarnings },
+          ...validationResult.outputIssues.length > 0 && { outputIssues: validationResult.outputIssues },
+          ...validationResult.normalizationChanges.length > 0 && { normalizationChanges: validationResult.normalizationChanges }
         };
         result.tokensEstimate = estimateTokens(result);
         return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
@@ -2272,7 +2679,7 @@ function registerTaskTools(server2, vaultPath2) {
 
 // src/tools/frontmatter.ts
 import { z as z3 } from "zod";
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 import path7 from "path";
 function registerFrontmatterTools(server2, vaultPath2) {
   server2.tool(
@@ -2287,7 +2694,7 @@ function registerFrontmatterTools(server2, vaultPath2) {
       try {
         const fullPath = path7.join(vaultPath2, notePath);
         try {
-          await fs4.access(fullPath);
+          await fs5.access(fullPath);
         } catch {
           const result2 = {
             success: false,
@@ -2343,7 +2750,7 @@ function registerFrontmatterTools(server2, vaultPath2) {
       try {
         const fullPath = path7.join(vaultPath2, notePath);
         try {
-          await fs4.access(fullPath);
+          await fs5.access(fullPath);
         } catch {
           const result2 = {
             success: false,
@@ -2397,7 +2804,7 @@ function registerFrontmatterTools(server2, vaultPath2) {
 
 // src/tools/notes.ts
 import { z as z4 } from "zod";
-import fs5 from "fs/promises";
+import fs6 from "fs/promises";
 import path8 from "path";
 function registerNoteTools(server2, vaultPath2) {
   server2.tool(
@@ -2422,7 +2829,7 @@ function registerNoteTools(server2, vaultPath2) {
         }
         const fullPath = path8.join(vaultPath2, notePath);
         try {
-          await fs5.access(fullPath);
+          await fs6.access(fullPath);
           if (!overwrite) {
             const result2 = {
               success: false,
@@ -2434,7 +2841,7 @@ function registerNoteTools(server2, vaultPath2) {
         } catch {
         }
         const dir = path8.dirname(fullPath);
-        await fs5.mkdir(dir, { recursive: true });
+        await fs6.mkdir(dir, { recursive: true });
         await writeVaultFile(vaultPath2, notePath, content, frontmatter);
         let gitCommit;
         let gitError;
@@ -2494,7 +2901,7 @@ Content length: ${content.length} chars`,
         }
         const fullPath = path8.join(vaultPath2, notePath);
         try {
-          await fs5.access(fullPath);
+          await fs6.access(fullPath);
         } catch {
           const result2 = {
             success: false,
@@ -2503,7 +2910,7 @@ Content length: ${content.length} chars`,
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
-        await fs5.unlink(fullPath);
+        await fs6.unlink(fullPath);
         let gitCommit;
         let gitError;
         if (commit) {
@@ -2537,7 +2944,7 @@ Content length: ${content.length} chars`,
 
 // src/tools/system.ts
 import { z as z5 } from "zod";
-import fs6 from "fs/promises";
+import fs7 from "fs/promises";
 import path9 from "path";
 function registerSystemTools(server2, vaultPath2) {
   server2.tool(
@@ -2560,7 +2967,7 @@ function registerSystemTools(server2, vaultPath2) {
         }
         const fullPath = path9.join(vaultPath2, notePath);
         try {
-          await fs6.access(fullPath);
+          await fs7.access(fullPath);
         } catch {
           const result2 = {
             success: false,
@@ -2606,8 +3013,8 @@ function registerSystemTools(server2, vaultPath2) {
     async ({ confirm }) => {
       try {
         if (!confirm) {
-          const lastCommit = await getLastCommit(vaultPath2);
-          if (!lastCommit) {
+          const lastCommit2 = await getLastCommit(vaultPath2);
+          if (!lastCommit2) {
             const result3 = {
               success: false,
               message: "No commits found to undo",
@@ -2617,11 +3024,11 @@ function registerSystemTools(server2, vaultPath2) {
           }
           const result2 = {
             success: false,
-            message: `Undo requires confirmation (confirm=true). Would undo: "${lastCommit.message}"`,
+            message: `Undo requires confirmation (confirm=true). Would undo: "${lastCommit2.message}"`,
             path: "",
-            preview: `Commit: ${lastCommit.hash.substring(0, 7)}
-Message: ${lastCommit.message}
-Date: ${lastCommit.date}`
+            preview: `Commit: ${lastCommit2.hash.substring(0, 7)}
+Message: ${lastCommit2.message}
+Date: ${lastCommit2.date}`
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
@@ -2634,6 +3041,20 @@ Date: ${lastCommit.date}`
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
+        const lastCrankCommit = await getLastCrankCommit(vaultPath2);
+        const lastCommit = await getLastCommit(vaultPath2);
+        if (lastCrankCommit && lastCommit) {
+          if (lastCommit.hash !== lastCrankCommit.hash) {
+            const result2 = {
+              success: false,
+              message: `Cannot undo: HEAD (${lastCommit.hash.substring(0, 7)}) doesn't match last Crank commit (${lastCrankCommit.hash.substring(0, 7)}). Another process may have committed since your mutation.`,
+              path: "",
+              preview: `Expected: ${lastCrankCommit.hash.substring(0, 7)} "${lastCrankCommit.message}"
+Actual HEAD: ${lastCommit.hash.substring(0, 7)} "${lastCommit.message}"`
+            };
+            return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+          }
+        }
         const undoResult = await undoLastCommit(vaultPath2);
         if (!undoResult.success) {
           const result2 = {
@@ -2643,6 +3064,7 @@ Date: ${lastCommit.date}`
           };
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
         }
+        await clearLastCrankCommit(vaultPath2);
         const result = {
           success: true,
           message: undoResult.message,
@@ -2665,7 +3087,7 @@ Message: ${undoResult.undoneCommit.message}` : void 0
 }
 
 // src/core/vaultRoot.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import * as path10 from "path";
 var VAULT_MARKERS = [".obsidian", ".claude"];
 function findVaultRoot(startPath) {
@@ -2673,7 +3095,7 @@ function findVaultRoot(startPath) {
   while (true) {
     for (const marker of VAULT_MARKERS) {
       const markerPath = path10.join(current, marker);
-      if (fs7.existsSync(markerPath) && fs7.statSync(markerPath).isDirectory()) {
+      if (fs8.existsSync(markerPath) && fs8.statSync(markerPath).isDirectory()) {
         return current;
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-crank",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "Deterministic vault mutations for Obsidian via MCP",
   "type": "module",
   "main": "dist/index.js",