md-feedback 1.0.1 → 1.1.0

package/README.md

@@ -28,16 +28,16 @@ Add to your MCP client config (Claude Code, Cursor, etc.):
 
 That's it. No install, no setup — `npx` handles everything.
 
-## 13 MCP Tools
+## 19 MCP Tools
 
 | Tool | Description |
 |------|-------------|
-| `get_document_structure` | Full review state: memos, gates, cursor, sections, summary |
+| `get_document_structure` | Full review state: memos, gates, cursor, sections, summary, metrics |
 | `list_annotations` | All annotations with type/status/owner/color |
 | `get_review_status` | Annotation counts and session status |
 | `create_annotation` | Create annotation programmatically with anchor search |
 | `respond_to_memo` | Add AI response to an annotation |
-| `update_memo_status` | Mark a memo as open/answered/wontfix |
+| `update_memo_status` | Mark a memo as open/in_progress/answered/done/failed/wontfix |
 | `update_cursor` | Set plan cursor position (task ID, step, next action) |
 | `evaluate_gates` | Check if merge/release/implement conditions are met |
 | `export_review` | Export for a specific AI tool format |
@@ -45,6 +45,12 @@ That's it. No install, no setup — `npx` handles everything.
 | `get_checkpoints` | List all checkpoints |
 | `generate_handoff` | Generate structured handoff document |
 | `pickup_handoff` | Parse existing handoff for session resumption |
+| `apply_memo` | Apply implementation (text_replace, file_patch, file_create) with dry-run |
+| `link_artifacts` | Link source files to a memo |
+| `update_memo_progress` | Update progress with status and message |
+| `rollback_memo` | Rollback the latest implementation for a memo |
+| `batch_apply` | Apply multiple operations in a single transaction |
+| `get_memo_changes` | Get implementation history and progress for a memo |
 
 ## How It Works
 

package/dist/mcp-server.js

@@ -3224,8 +3224,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path) {
-      let input = path;
+    function removeDotSegments(path2) {
+      let input = path2;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3424,8 +3424,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path && path !== "/" ? path : void 0;
+        const [path2, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path2 && path2 !== "/" ? path2 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -7276,8 +7276,8 @@ function getErrorMap() {
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path, errorMaps, issueData } = params;
-  const fullPath = [...path, ...issueData.path || []];
+  const { data, path: path2, errorMaps, issueData } = params;
+  const fullPath = [...path2, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -7393,11 +7393,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path, key) {
+  constructor(parent, value, path2, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path;
+    this._path = path2;
     this._key = key;
   }
   get path() {
@@ -11035,10 +11035,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path) {
-  if (!path)
+function getElementAtPath(obj, path2) {
+  if (!path2)
     return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
+  return path2.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11358,11 +11358,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path, issues) {
+function prefixIssues(path2, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path);
+    iss.path.unshift(path2);
     return iss;
   });
 }
@@ -20870,6 +20870,53 @@ function writeMarkdownFile(filePath, content) {
     throw new Error(`Cannot write file ${resolved}: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
+function ensureSidecar(mdFilePath) {
+  const resolved = resolvePath(mdFilePath);
+  const dir = (0, import_path.join)((0, import_path.dirname)(resolved), ".md-feedback");
+  if (!(0, import_fs.existsSync)(dir)) {
+    (0, import_fs.mkdirSync)(dir, { recursive: true });
+  }
+  return dir;
+}
+function writeSnapshot(mdFilePath, content) {
+  const sidecar = ensureSidecar(mdFilePath);
+  const snapshotsDir = (0, import_path.join)(sidecar, "snapshots");
+  if (!(0, import_fs.existsSync)(snapshotsDir)) {
+    (0, import_fs.mkdirSync)(snapshotsDir, { recursive: true });
+  }
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const snapshotPath = (0, import_path.join)(snapshotsDir, `snapshot-${ts}.md`);
+  (0, import_fs.writeFileSync)(snapshotPath, content, "utf-8");
+  return snapshotPath;
+}
+function readProgress(mdFilePath) {
+  const sidecar = ensureSidecar(mdFilePath);
+  const progressPath = (0, import_path.join)(sidecar, "progress.json");
+  if (!(0, import_fs.existsSync)(progressPath)) return [];
+  try {
+    return JSON.parse((0, import_fs.readFileSync)(progressPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function appendProgress(mdFilePath, entry) {
+  const sidecar = ensureSidecar(mdFilePath);
+  const progressPath = (0, import_path.join)(sidecar, "progress.json");
+  const entries = readProgress(mdFilePath);
+  entries.push(entry);
+  (0, import_fs.writeFileSync)(progressPath, JSON.stringify(entries, null, 2), "utf-8");
+}
+function writeTransaction(mdFilePath, transaction) {
+  const sidecar = ensureSidecar(mdFilePath);
+  const txDir = (0, import_path.join)(sidecar, "transactions");
+  if (!(0, import_fs.existsSync)(txDir)) {
+    (0, import_fs.mkdirSync)(txDir, { recursive: true });
+  }
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const txPath = (0, import_path.join)(txDir, `tx-${ts}.json`);
+  (0, import_fs.writeFileSync)(txPath, JSON.stringify(transaction, null, 2), "utf-8");
+  return txPath;
+}
 
 // ../../packages/shared/src/types.ts
 var HEX_TO_COLOR_NAME = {
@@ -20877,6 +20924,9 @@ var HEX_TO_COLOR_NAME = {
   "#fca5a5": "red",
   "#93c5fd": "blue"
 };
+function isResolved(status) {
+  return status === "answered" || status === "done" || status === "failed" || status === "wontfix";
+}
 function colorToType(color) {
   if (color === "red") return "fix";
   if (color === "blue") return "question";
@@ -21128,6 +21178,11 @@ var BANNER_CONTENT_RE = /MD Feedback/;
 var FEEDBACK_NOTES_RE = /^<!-- \/?(USER_FEEDBACK_NOTES|@\/?feedback-notes)\b.*-->$/;
 var RESPONSE_OPEN_RE = /^<!-- REVIEW_RESPONSE\s+to="([^"]+)"\s*-->$/;
 var RESPONSE_CLOSE_RE = /^<!-- \/REVIEW_RESPONSE\s*-->$/;
+var IMPL_START_RE = /^<!-- MEMO_IMPL\s*$/;
+var IMPL_END_RE = /^-->$/;
+var ARTIFACT_START_RE = /^<!-- MEMO_ARTIFACT\s*$/;
+var ARTIFACT_END_RE = /^-->$/;
+var DEPENDENCY_RE = /^<!-- MEMO_DEPENDENCY\s+id="([^"]+)"\s+from="([^"]+)"\s+to="([^"]+)"\s+type="([^"]+)" -->$/;
 function parseAttrs(lines) {
   const unesc = (s) => s.replace(/&#10;/g, "\n").replace(/&quot;/g, '"');
   const attrs = {};
@@ -21149,6 +21204,9 @@ function splitDocument(markdown) {
   const bodyLines = [];
   const memos = [];
   const responses = [];
+  const impls = [];
+  const artifacts = [];
+  const dependencies = [];
   const checkpoints = [];
   const gates = [];
   const unknownComments = [];
@@ -21262,6 +21320,58 @@ function splitDocument(markdown) {
       };
       continue;
     }
+    if (IMPL_START_RE.test(trimmed)) {
+      const attrLines = [];
+      i++;
+      while (i < lines.length && !IMPL_END_RE.test(lines[i].trim())) {
+        attrLines.push(lines[i]);
+        i++;
+      }
+      i++;
+      const a = parseAttrs(attrLines);
+      let operations = [];
+      try {
+        operations = JSON.parse(a.operations || "[]");
+      } catch {
+      }
+      impls.push({
+        id: a.id || `impl_${Date.now().toString(36)}`,
+        memoId: a.memoId || "",
+        status: a.status || "applied",
+        operations,
+        summary: a.summary || "",
+        appliedAt: a.appliedAt || (/* @__PURE__ */ new Date()).toISOString()
+      });
+      continue;
+    }
+    if (ARTIFACT_START_RE.test(trimmed)) {
+      const attrLines = [];
+      i++;
+      while (i < lines.length && !ARTIFACT_END_RE.test(lines[i].trim())) {
+        attrLines.push(lines[i]);
+        i++;
+      }
+      i++;
+      const a = parseAttrs(attrLines);
+      artifacts.push({
+        id: a.id || `art_${Date.now().toString(36)}`,
+        memoId: a.memoId || "",
+        files: a.files ? a.files.split(",").map((s) => s.trim()).filter(Boolean) : [],
+        linkedAt: a.linkedAt || (/* @__PURE__ */ new Date()).toISOString()
+      });
+      continue;
+    }
+    const depMatch = trimmed.match(DEPENDENCY_RE);
+    if (depMatch) {
+      dependencies.push({
+        id: depMatch[1],
+        from: depMatch[2],
+        to: depMatch[3],
+        type: depMatch[4]
+      });
+      i++;
+      continue;
+    }
     const cpMatch = trimmed.match(CHECKPOINT_RE);
     if (cpMatch) {
       checkpoints.push({
@@ -21322,11 +21432,6 @@ function splitDocument(markdown) {
     openResponse.bodyEndIdx = bodyLines.length - 1;
     responses.push(openResponse);
   }
-  for (const memo of memos) {
-    if (memo.status === "done") {
-      memo.status = "answered";
-    }
-  }
   const respondedMemoIds = new Set(responses.map((r) => r.to));
   for (const memo of memos) {
     if (memo.status === "open" && respondedMemoIds.has(memo.id)) {
@@ -21338,6 +21443,9 @@ function splitDocument(markdown) {
     body: bodyLines.join("\n"),
     memos,
     responses,
+    impls,
+    artifacts,
+    dependencies,
     checkpoints,
     gates,
     cursor,
@@ -21351,6 +21459,15 @@ function mergeDocument(parts) {
   }
   const bodyWithMemos = reinsertMemosAndResponses(parts.body, parts.memos, parts.responses || []);
   sections.push(bodyWithMemos);
+  for (const impl of parts.impls || []) {
+    sections.push(serializeMemoImpl(impl));
+  }
+  for (const art of parts.artifacts || []) {
+    sections.push(serializeMemoArtifact(art));
+  }
+  for (const dep of parts.dependencies || []) {
+    sections.push(serializeMemoDependency(dep));
+  }
   for (const gate of parts.gates) {
     sections.push(serializeGate(gate));
   }
@@ -21408,6 +21525,34 @@ function serializeCheckpoint(cp) {
   const sections = cp.sectionsReviewed.join(",");
   return `<!-- CHECKPOINT id="${cp.id}" time="${cp.timestamp}" note="${note}" fixes=${cp.fixes} questions=${cp.questions} highlights=${cp.highlights} sections="${sections}" -->`;
 }
+function serializeMemoImpl(impl) {
+  const esc2 = (s) => s.replace(/"/g, "&quot;").replace(/\n/g, "&#10;");
+  const ops = JSON.stringify(impl.operations).replace(/"/g, "&quot;");
+  return [
+    "<!-- MEMO_IMPL",
+    `  id="${esc2(impl.id)}"`,
+    `  memoId="${esc2(impl.memoId)}"`,
+    `  status="${impl.status}"`,
+    `  operations="${ops}"`,
+    `  summary="${esc2(impl.summary)}"`,
+    `  appliedAt="${impl.appliedAt}"`,
+    "-->"
+  ].join("\n");
+}
+function serializeMemoArtifact(art) {
+  const esc2 = (s) => s.replace(/"/g, "&quot;");
+  return [
+    "<!-- MEMO_ARTIFACT",
+    `  id="${esc2(art.id)}"`,
+    `  memoId="${esc2(art.memoId)}"`,
+    `  files="${art.files.join(",")}"`,
+    `  linkedAt="${art.linkedAt}"`,
+    "-->"
+  ].join("\n");
+}
+function serializeMemoDependency(dep) {
+  return `<!-- MEMO_DEPENDENCY id="${dep.id}" from="${dep.from}" to="${dep.to}" type="${dep.type}" -->`;
+}
 function reinsertMemosAndResponses(body, memos, responses) {
   if (memos.length === 0 && responses.length === 0) return body;
   const lines = body.split("\n");
@@ -21981,11 +22126,11 @@ function parseHandoffFile(markdown) {
 // ../../packages/shared/src/gate-evaluator.ts
 function evaluateGate(gate, memos) {
   if (gate.blockedBy.length > 0) {
-    const blocking = gate.blockedBy.map((id) => memos.find((m) => m.id === id)).filter((m) => m != null && m.status === "open");
+    const blocking = gate.blockedBy.map((id) => memos.find((m) => m.id === id)).filter((m) => m != null && !isResolved(m.status));
     if (blocking.length > 0) return "blocked";
   }
-  const hasOpenMemos = memos.some((m) => m.status === "open");
-  if (!hasOpenMemos) return "done";
+  const hasUnresolvedMemos = memos.some((m) => !isResolved(m.status));
+  if (!hasUnresolvedMemos) return "done";
   return "proceed";
 }
 function evaluateAllGates(gates, memos) {
@@ -21995,6 +22140,138 @@ function evaluateAllGates(gates, memos) {
   }));
 }
 
+// src/file-safety.ts
+var import_node_path = __toESM(require("node:path"));
+var DEFAULT_BLOCKLIST = [
+  "**/.env",
+  ".env",
+  "**/.env.*",
+  ".env.*",
+  "**/credentials*",
+  "credentials*",
+  "**/secrets*",
+  "secrets*",
+  "**/*.pem",
+  "*.pem",
+  "**/*.key",
+  "*.key",
+  "**/*.p12",
+  "*.p12",
+  "**/node_modules/**",
+  "node_modules/**",
+  "**/.git/**",
+  ".git/**"
+];
+function createFileSafety(workspaceRoot) {
+  return {
+    workspaceRoot: workspaceRoot || process.cwd(),
+    blocklist: [...DEFAULT_BLOCKLIST],
+    allowlist: []
+  };
+}
+function matchGlob(pattern, filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  const regexStr = normalizedPattern.replace(/[.+^${}()|[\]]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\u0000/g, ".*").replace(/\?/g, "[^/]");
+  return new RegExp(`^${regexStr}$`).test(normalized);
+}
+function matchesAny(patterns, filePath) {
+  return patterns.some((pattern) => matchGlob(pattern, filePath));
+}
+function validateFilePath(config2, filePath) {
+  const resolved = import_node_path.default.resolve(config2.workspaceRoot, filePath);
+  const normalizedRoot = import_node_path.default.resolve(config2.workspaceRoot);
+  if (!resolved.startsWith(normalizedRoot + import_node_path.default.sep) && resolved !== normalizedRoot) {
+    return { safe: false, reason: `Path "${filePath}" resolves outside workspace root` };
+  }
+  const relative = import_node_path.default.relative(normalizedRoot, resolved).replace(/\\/g, "/");
+  if (matchesAny(config2.blocklist, relative)) {
+    return { safe: false, reason: `Path "${filePath}" matches blocklist pattern` };
+  }
+  if (config2.allowlist.length > 0 && !matchesAny(config2.allowlist, relative)) {
+    return { safe: false, reason: `Path "${filePath}" not in allowlist` };
+  }
+  return { safe: true };
+}
+
+// src/metrics.ts
+function computeMetrics(memos, impls, gates, checkpoints, artifacts, dependencies) {
+  const byStatus = {};
+  const byType = {};
+  let resolvedCount = 0;
+  for (const memo of memos) {
+    byStatus[memo.status] = (byStatus[memo.status] || 0) + 1;
+    byType[memo.type] = (byType[memo.type] || 0) + 1;
+    if (isResolved(memo.status)) resolvedCount++;
+  }
+  const resolutionRate = memos.length > 0 ? resolvedCount / memos.length : 0;
+  const implsByStatus = {};
+  let appliedCount = 0;
+  let revertedCount = 0;
+  let failedCount = 0;
+  for (const impl of impls) {
+    implsByStatus[impl.status] = (implsByStatus[impl.status] || 0) + 1;
+    if (impl.status === "applied") appliedCount++;
+    if (impl.status === "reverted") revertedCount++;
+    if (impl.status === "failed") failedCount++;
+  }
+  const gatesByStatus = {};
+  for (const gate of gates) {
+    gatesByStatus[gate.status] = (gatesByStatus[gate.status] || 0) + 1;
+  }
+  const fileSet = /* @__PURE__ */ new Set();
+  for (const art of artifacts) {
+    for (const f of art.files) {
+      fileSet.add(f);
+    }
+  }
+  const blockingChains = dependencies.filter((d) => d.type === "blocks").length;
+  let lastCheckpoint = null;
+  if (checkpoints.length > 0) {
+    lastCheckpoint = checkpoints.reduce(
+      (latest, cp) => cp.timestamp > latest ? cp.timestamp : latest,
+      checkpoints[0].timestamp
+    );
+  }
+  let avgResolutionTime = null;
+  const resolvedMemos = memos.filter((m) => isResolved(m.status) && m.createdAt && m.updatedAt);
+  if (resolvedMemos.length > 0) {
+    let totalMs = 0;
+    let validCount = 0;
+    for (const memo of resolvedMemos) {
+      const created = new Date(memo.createdAt).getTime();
+      const updated = new Date(memo.updatedAt).getTime();
+      if (!isNaN(created) && !isNaN(updated) && updated > created) {
+        totalMs += updated - created;
+        validCount++;
+      }
+    }
+    if (validCount > 0) {
+      avgResolutionTime = totalMs / validCount;
+    }
+  }
+  return {
+    totalMemos: memos.length,
+    byStatus,
+    byType,
+    resolutionRate,
+    totalImpls: impls.length,
+    implsByStatus,
+    appliedCount,
+    revertedCount,
+    failedCount,
+    totalGates: gates.length,
+    gatesByStatus,
+    totalArtifacts: artifacts.length,
+    linkedFiles: fileSet.size,
+    totalDependencies: dependencies.length,
+    blockingChains,
+    totalCheckpoints: checkpoints.length,
+    lastCheckpoint,
+    avgResolutionTime
+  };
+}
+
 // src/tools.ts
 function computeLineHash(line) {
   let hash = 5381;
@@ -22215,7 +22492,11 @@ function registerTools(server2) {
         const reviewedSections = getSectionsWithAnnotations(markdown);
         const gates = evaluateAllGates(parts.gates, parts.memos);
         const open = parts.memos.filter((m) => m.status === "open").length;
-        const done = parts.memos.filter((m) => m.status !== "open").length;
+        const inProgress = parts.memos.filter((m) => m.status === "in_progress").length;
+        const answered = parts.memos.filter((m) => m.status === "answered").length;
+        const done = parts.memos.filter((m) => m.status === "done").length;
+        const failed = parts.memos.filter((m) => m.status === "failed").length;
+        const wontfix = parts.memos.filter((m) => m.status === "wontfix").length;
         const blocked = gates.filter((g) => g.status === "blocked").length;
         const structure = {
           version: "0.4.0",
@@ -22230,20 +22511,35 @@ function registerTools(server2) {
             reviewed: reviewedSections,
             uncovered: allSections.filter((s) => !reviewedSections.includes(s))
           },
+          impls: parts.impls,
+          artifacts: parts.artifacts,
+          dependencies: parts.dependencies,
           summary: {
             total: parts.memos.length,
             open,
+            inProgress,
+            answered,
             done,
+            failed,
+            wontfix,
             blocked,
             fixes: parts.memos.filter((m) => m.type === "fix").length,
             questions: parts.memos.filter((m) => m.type === "question").length,
             highlights: parts.memos.filter((m) => m.type === "highlight").length
           }
         };
+        const metrics = computeMetrics(
+          parts.memos,
+          parts.impls,
+          gates,
+          parts.checkpoints,
+          parts.artifacts,
+          parts.dependencies
+        );
         return {
           content: [{
             type: "text",
-            text: JSON.stringify(structure, null, 2)
+            text: JSON.stringify({ ...structure, metrics }, null, 2)
           }]
         };
       } catch (err) {
@@ -22466,7 +22762,7 @@ function registerTools(server2) {
     {
       file: external_exports.string().describe("Path to the annotated markdown file"),
       memoId: external_exports.string().describe("The memo ID to update"),
-      status: external_exports.enum(["open", "answered", "wontfix"]).describe("New status"),
+      status: external_exports.enum(["open", "in_progress", "answered", "done", "failed", "wontfix"]).describe("New status"),
       owner: external_exports.enum(["human", "agent", "tool"]).optional().describe("Optionally change the owner")
     },
     async ({ file, memoId, status, owner }) => {
@@ -22657,6 +22953,445 @@ function registerTools(server2) {
       }
     }
   );
+  server2.tool(
+    "apply_memo",
+    "Apply an implementation action to a memo. Supports text_replace (on current document), file_patch (apply patch to target file), and file_create (create a new file). Creates a snapshot before modification, records the implementation, and updates memo status to done.",
+    {
+      file: external_exports.string().describe("Path to the annotated markdown file"),
+      memoId: external_exports.string().describe("The memo ID to apply implementation to"),
+      action: external_exports.enum(["text_replace", "file_patch", "file_create"]).describe("Type of implementation action"),
+      dryRun: external_exports.boolean().optional().default(false).describe("If true, return preview without writing"),
+      oldText: external_exports.string().optional().describe("For text_replace: the text to find and replace"),
+      newText: external_exports.string().optional().describe("For text_replace: the replacement text"),
+      targetFile: external_exports.string().optional().describe("For file_patch/file_create: target file path"),
+      patch: external_exports.string().optional().describe("For file_patch: the patch content"),
+      content: external_exports.string().optional().describe("For file_create: the file content to write")
+    },
+    async ({ file, memoId, action, dryRun, oldText, newText, targetFile, patch, content: fileContent }) => {
+      try {
+        const markdown = readMarkdownFile(file);
+        const parts = splitDocument(markdown);
+        const memo = parts.memos.find((m) => m.id === memoId);
+        if (!memo) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: `Memo not found: ${memoId}` }) }],
+            isError: true
+          };
+        }
+        let operation;
+        if (action === "text_replace") {
+          if (!oldText || newText === void 0) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "text_replace requires oldText and newText" }) }],
+              isError: true
+            };
+          }
+          operation = { type: "text_replace", file: "", before: oldText, after: newText };
+        } else if (action === "file_patch") {
+          if (!targetFile || !patch) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "file_patch requires targetFile and patch" }) }],
+              isError: true
+            };
+          }
+          operation = { type: "file_patch", file: targetFile, patch };
+        } else {
+          if (!targetFile || fileContent === void 0) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: "file_create requires targetFile and content" }) }],
+              isError: true
+            };
+          }
+          operation = { type: "file_create", file: targetFile, content: fileContent };
+        }
+        const impl = {
+          id: `impl_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`,
+          memoId,
+          status: "applied",
+          operations: [operation],
+          summary: `${action} for ${memoId}`,
+          appliedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        if (dryRun) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({ dryRun: true, impl, operation, memo: { id: memo.id, status: memo.status } }, null, 2)
+            }]
+          };
+        }
+        if ((action === "file_patch" || action === "file_create") && targetFile) {
+          const safety = createFileSafety();
+          const check2 = validateFilePath(safety, targetFile);
+          if (!check2.safe) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: `File safety: ${check2.reason}` }) }],
+              isError: true
+            };
+          }
+        }
+        writeSnapshot(file, markdown);
+        if (action === "text_replace") {
+          if (!parts.body.includes(oldText)) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ error: `oldText not found in document body` }) }],
+              isError: true
+            };
+          }
+          parts.body = parts.body.replace(oldText, newText);
+        } else if (action === "file_patch") {
+          writeMarkdownFile(targetFile, patch);
+        } else if (action === "file_create") {
+          writeMarkdownFile(targetFile, fileContent);
+        }
+        parts.impls.push(impl);
+        memo.status = "done";
+        memo.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (parts.gates.length > 0) {
+          parts.gates = evaluateAllGates(parts.gates, parts.memos);
+        }
+        const resolvedCount = parts.memos.filter((m) => isResolved(m.status)).length;
+        const openMemos = parts.memos.filter((m) => !isResolved(m.status));
+        parts.cursor = {
+          taskId: memoId,
+          step: `${resolvedCount}/${parts.memos.length} resolved`,
+          nextAction: openMemos.length === 0 ? "All annotations resolved \u2014 review complete" : `Resolve: ${openMemos.map((m) => m.id).slice(0, 3).join(", ")}${openMemos.length > 3 ? "..." : ""}`,
+          lastSeenHash: generateBodyHash(parts.body),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const updated = mergeDocument(parts);
+        writeMarkdownFile(file, updated);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ impl, memo: { id: memo.id, status: memo.status }, gatesUpdated: parts.gates.length }, null, 2)
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "link_artifacts",
+    "Link file artifacts (source files, configs, etc.) to a memo. Creates a MemoArtifact record in the document.",
+    {
+      file: external_exports.string().describe("Path to the annotated markdown file"),
+      memoId: external_exports.string().describe("The memo ID to link artifacts to"),
+      files: external_exports.array(external_exports.string()).describe("Array of relative file paths to link")
+    },
+    async ({ file, memoId, files: artifactFiles }) => {
+      try {
+        const markdown = readMarkdownFile(file);
+        const parts = splitDocument(markdown);
+        const memo = parts.memos.find((m) => m.id === memoId);
+        if (!memo) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: `Memo not found: ${memoId}` }) }],
+            isError: true
+          };
+        }
+        const artifact = {
+          id: `art_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`,
+          memoId,
+          files: artifactFiles,
+          linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        parts.artifacts.push(artifact);
+        const updated = mergeDocument(parts);
+        writeMarkdownFile(file, updated);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ artifact }, null, 2)
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "update_memo_progress",
+    "Update the progress of a memo with a status change and message. Writes progress to .md-feedback/progress.json and updates the memo status.",
+    {
+      file: external_exports.string().describe("Path to the annotated markdown file"),
+      memoId: external_exports.string().describe("The memo ID to update progress for"),
+      status: external_exports.enum(["in_progress", "done", "failed"]).describe("New progress status"),
+      message: external_exports.string().describe("Progress message describing what was done or what failed")
+    },
+    async ({ file, memoId, status, message }) => {
+      try {
+        const markdown = readMarkdownFile(file);
+        const parts = splitDocument(markdown);
+        const memo = parts.memos.find((m) => m.id === memoId);
+        if (!memo) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: `Memo not found: ${memoId}` }) }],
+            isError: true
+          };
+        }
+        memo.status = status;
+        memo.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const progressEntry = {
+          memoId,
+          status,
+          message,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        appendProgress(file, progressEntry);
+        if (parts.gates.length > 0) {
+          parts.gates = evaluateAllGates(parts.gates, parts.memos);
+        }
+        const resolvedCount = parts.memos.filter((m) => isResolved(m.status)).length;
+        const openMemos = parts.memos.filter((m) => !isResolved(m.status));
+        parts.cursor = {
+          taskId: memoId,
+          step: `${resolvedCount}/${parts.memos.length} resolved`,
+          nextAction: openMemos.length === 0 ? "All annotations resolved \u2014 review complete" : `Resolve: ${openMemos.map((m) => m.id).slice(0, 3).join(", ")}${openMemos.length > 3 ? "..." : ""}`,
+          lastSeenHash: generateBodyHash(parts.body),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const updated = mergeDocument(parts);
+        writeMarkdownFile(file, updated);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ memo: { id: memo.id, status: memo.status }, progressEntry, gatesUpdated: parts.gates.length }, null, 2)
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "rollback_memo",
+    "Rollback the latest implementation for a memo. Reverses text_replace operations (swaps before/after), marks the impl as reverted, and sets the memo status back to open.",
+    {
+      file: external_exports.string().describe("Path to the annotated markdown file"),
+      memoId: external_exports.string().describe("The memo ID to rollback")
+    },
+    async ({ file, memoId }) => {
+      try {
+        const markdown = readMarkdownFile(file);
+        const parts = splitDocument(markdown);
+        const memo = parts.memos.find((m) => m.id === memoId);
+        if (!memo) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: `Memo not found: ${memoId}` }) }],
+            isError: true
+          };
+        }
+        const memoImpls = parts.impls.filter((imp) => imp.memoId === memoId && imp.status === "applied");
+        if (memoImpls.length === 0) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: `No applied implementation found for memo: ${memoId}` }) }],
+            isError: true
+          };
+        }
+        const latestImpl = memoImpls[memoImpls.length - 1];
+        for (const op of latestImpl.operations) {
+          if (op.type === "text_replace") {
+            if (parts.body.includes(op.after)) {
+              parts.body = parts.body.replace(op.after, op.before);
+            }
+          }
+        }
+        latestImpl.status = "reverted";
+        memo.status = "open";
+        memo.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (parts.gates.length > 0) {
+          parts.gates = evaluateAllGates(parts.gates, parts.memos);
+        }
+        const resolvedCount = parts.memos.filter((m) => isResolved(m.status)).length;
+        const openMemos = parts.memos.filter((m) => !isResolved(m.status));
+        parts.cursor = {
+          taskId: memoId,
+          step: `${resolvedCount}/${parts.memos.length} resolved`,
+          nextAction: openMemos.length === 0 ? "All annotations resolved \u2014 review complete" : `Resolve: ${openMemos.map((m) => m.id).slice(0, 3).join(", ")}${openMemos.length > 3 ? "..." : ""}`,
+          lastSeenHash: generateBodyHash(parts.body),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        const updated = mergeDocument(parts);
+        writeMarkdownFile(file, updated);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              rolledBack: latestImpl.id,
+              memo: { id: memo.id, status: memo.status },
+              gatesUpdated: parts.gates.length
+            }, null, 2)
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "batch_apply",
+    "Apply multiple implementation operations in a single transaction. Parses the document once, applies all operations sequentially, then writes once. Each operation follows the same format as apply_memo.",
+    {
+      file: external_exports.string().describe("Path to the annotated markdown file"),
+      operations: external_exports.array(external_exports.object({
+        memoId: external_exports.string().describe("The memo ID to apply implementation to"),
+        action: external_exports.enum(["text_replace", "file_patch", "file_create"]).describe("Type of implementation action"),
+        oldText: external_exports.string().optional().describe("For text_replace: the text to find and replace"),
+        newText: external_exports.string().optional().describe("For text_replace: the replacement text"),
+        targetFile: external_exports.string().optional().describe("For file_patch/file_create: target file path"),
+        patch: external_exports.string().optional().describe("For file_patch: the patch content"),
+        content: external_exports.string().optional().describe("For file_create: the file content to write")
+      })).describe("Array of operations to apply")
+    },
+    async ({ file, operations }) => {
+      try {
+        const markdown = readMarkdownFile(file);
+        const parts = splitDocument(markdown);
+        writeSnapshot(file, markdown);
+        const results = [];
+        const safety = createFileSafety();
+        for (const op of operations) {
+          const memo = parts.memos.find((m) => m.id === op.memoId);
+          if (!memo) {
+            results.push({ memoId: op.memoId, implId: "", status: `error: memo not found` });
+            continue;
+          }
+          if ((op.action === "file_patch" || op.action === "file_create") && op.targetFile) {
+            const check2 = validateFilePath(safety, op.targetFile);
+            if (!check2.safe) {
+              results.push({ memoId: op.memoId, implId: "", status: `error: file safety: ${check2.reason}` });
+              continue;
+            }
+          }
+          let operation;
+          if (op.action === "text_replace") {
+            if (!op.oldText || op.newText === void 0) {
+              results.push({ memoId: op.memoId, implId: "", status: "error: text_replace requires oldText and newText" });
+              continue;
+            }
+            operation = { type: "text_replace", file: "", before: op.oldText, after: op.newText };
+            if (!parts.body.includes(op.oldText)) {
+              results.push({ memoId: op.memoId, implId: "", status: "error: oldText not found in body" });
+              continue;
+            }
+            parts.body = parts.body.replace(op.oldText, op.newText);
+          } else if (op.action === "file_patch") {
+            if (!op.targetFile || !op.patch) {
+              results.push({ memoId: op.memoId, implId: "", status: "error: file_patch requires targetFile and patch" });
+              continue;
+            }
+            operation = { type: "file_patch", file: op.targetFile, patch: op.patch };
+            writeMarkdownFile(op.targetFile, op.patch);
+          } else {
+            if (!op.targetFile || op.content === void 0) {
+              results.push({ memoId: op.memoId, implId: "", status: "error: file_create requires targetFile and content" });
+              continue;
+            }
+            operation = { type: "file_create", file: op.targetFile, content: op.content };
+            writeMarkdownFile(op.targetFile, op.content);
+          }
+          const impl = {
+            id: `impl_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`,
+            memoId: op.memoId,
+            status: "applied",
+            operations: [operation],
+            summary: `${op.action} for ${op.memoId}`,
+            appliedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          parts.impls.push(impl);
+          memo.status = "done";
+          memo.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          results.push({ memoId: op.memoId, implId: impl.id, status: "applied" });
+        }
+        if (parts.gates.length > 0) {
+          parts.gates = evaluateAllGates(parts.gates, parts.memos);
+        }
+        const resolvedCount = parts.memos.filter((m) => isResolved(m.status)).length;
+        const openMemos = parts.memos.filter((m) => !isResolved(m.status));
+        parts.cursor = {
+          taskId: operations[0]?.memoId || "",
+          step: `${resolvedCount}/${parts.memos.length} resolved`,
+          nextAction: openMemos.length === 0 ? "All annotations resolved \u2014 review complete" : `Resolve: ${openMemos.map((m) => m.id).slice(0, 3).join(", ")}${openMemos.length > 3 ? "..." : ""}`,
+          lastSeenHash: generateBodyHash(parts.body),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        writeTransaction(file, { type: "batch_apply", results, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+        const updated = mergeDocument(parts);
+        writeMarkdownFile(file, updated);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ results, gatesUpdated: parts.gates.length, cursor: parts.cursor }, null, 2)
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "get_memo_changes",
+    "Get the implementation history and progress for a memo. Returns all MemoImpl records and progress entries from .md-feedback/progress.json. If memoId is omitted, returns all changes.",
+    {
+      file: external_exports.string().describe("Path to the annotated markdown file"),
+      memoId: external_exports.string().optional().describe("Optional memo ID to filter by \u2014 if omitted, returns all changes")
+    },
+    async ({ file, memoId }) => {
+      try {
+        const markdown = readMarkdownFile(file);
+        const parts = splitDocument(markdown);
+        const impls = memoId ? parts.impls.filter((imp) => imp.memoId === memoId) : parts.impls;
+        const allProgress = readProgress(file);
+        const progress = memoId ? allProgress.filter((p) => p.memoId === memoId) : allProgress;
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ impls, progress }, null, 2)
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ error: err instanceof Error ? err.message : String(err) })
+          }],
+          isError: true
+        };
+      }
+    }
+  );
 }
 
 // src/server.ts
@@ -22666,13 +23401,13 @@ function log(msg) {
 }
 var server = new McpServer({
   name: "md-feedback",
-  version: "1.0.1"
+  version: "1.1.0"
 });
 registerTools(server);
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  log(`v${"1.0.1"} ready (stdio)`);
+  log(`v${"1.1.0"} ready (stdio)`);
 }
 main().catch((err) => {
   log(`fatal: ${err}`);

package/package.json

@@ -1,70 +1,70 @@
-{
-  "name": "md-feedback",
-  "version": "1.0.1",
-  "description": "MCP server for markdown plan review — AI agents read annotations, mark tasks done, evaluate quality gates, and generate session handoffs. 13 tools for Claude Code, Cursor, Copilot, and 8 more AI tools.",
-  "license": "SUL-1.0",
-  "author": "Yeomin Seon",
-  "type": "commonjs",
-  "bin": {
-    "md-feedback": "./bin/md-feedback.cjs"
-  },
-  "files": [
-    "dist/mcp-server.js",
-    "bin/md-feedback.cjs",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "node esbuild.mjs"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.0",
-    "zod": "^3.23.0"
-  },
-  "devDependencies": {
-    "esbuild": "^0.24.2",
-    "typescript": "^5.7.0"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/yeominux/md-feedback"
-  },
-  "bugs": {
-    "url": "https://github.com/yeominux/md-feedback/issues"
-  },
-  "homepage": "https://github.com/yeominux/md-feedback#mcp-server",
-  "keywords": [
-    "mcp",
-    "mcp-server",
-    "model-context-protocol",
-    "markdown",
-    "feedback",
-    "ai",
-    "annotation",
-    "review",
-    "plan-review",
-    "ai-agent",
-    "coding-workflow",
-    "handoff",
-    "session-handoff",
-    "structured-feedback",
-    "checkpoint",
-    "ai-context",
-    "ai-coding",
-    "claude-code",
-    "cursor-ai",
-    "vibe-coding",
-    "context-engineering",
-    "gates",
-    "plan-review-tool",
-    "document-annotation",
-    "code-review",
-    "ai-workflow",
-    "copilot",
-    "markdown-review",
-    "developer-tools",
-    "quality-gate"
-  ]
-}
+{
+  "name": "md-feedback",
+  "version": "1.1.0",
+  "description": "MCP server for markdown plan review — AI agents read annotations, mark tasks done, evaluate quality gates, and generate session handoffs. 19 tools for Claude Code, Cursor, Copilot, and 8 more AI tools.",
+  "license": "SUL-1.0",
+  "author": "Yeomin Seon",
+  "type": "commonjs",
+  "bin": {
+    "md-feedback": "./bin/md-feedback.cjs"
+  },
+  "files": [
+    "dist/mcp-server.js",
+    "bin/md-feedback.cjs",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node esbuild.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.24.2",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yeominux/md-feedback"
+  },
+  "bugs": {
+    "url": "https://github.com/yeominux/md-feedback/issues"
+  },
+  "homepage": "https://github.com/yeominux/md-feedback#mcp-server",
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "markdown",
+    "feedback",
+    "ai",
+    "annotation",
+    "review",
+    "plan-review",
+    "ai-agent",
+    "coding-workflow",
+    "handoff",
+    "session-handoff",
+    "structured-feedback",
+    "checkpoint",
+    "ai-context",
+    "ai-coding",
+    "claude-code",
+    "cursor-ai",
+    "vibe-coding",
+    "context-engineering",
+    "gates",
+    "plan-review-tool",
+    "document-annotation",
+    "code-review",
+    "ai-workflow",
+    "copilot",
+    "markdown-review",
+    "developer-tools",
+    "quality-gate"
+  ]
+}