apple-notes-mcp 2.8.44 → 2.8.46

package/README.md

@@ -1174,15 +1174,18 @@ Creates a new folder, including a whole nested hierarchy in one call.
 
 **Returns:** Confirmation message. The call is **idempotent** — an already-existing folder (or path segment) is skipped rather than treated as an error, so it is safe to call before every `create-note` that targets a folder.
 
+Existence is decided by folder id, not by name: a folder deleted earlier in the same Notes session no longer counts as existing, and the call succeeds only once the created folder is confirmed by its id. Otherwise it reports failure.
+
 ---
 
 #### `get-folder-by-id`
 
-Reads one exact folder's current name and parent ID. Use these values with
-`rename-folder`; this avoids relying on ambiguous folder names or paths. The
-`id` may also be the folder's Notes UUID or numeric key, and the result adds
-`identifier`, `parentIdentifier`, and `accountIdentifier` when Full Disk Access
-is granted.
+Reads one exact folder's current name, parent ID, and account ID (`accountId`,
+plus `isRoot`, true when the folder sits at the account root). Use these values
+with `rename-folder` or `delete-folder-by-id`; this avoids relying on ambiguous
+folder names or paths. The `id` may also be the folder's Notes UUID or numeric
+key, and the result adds `identifier`, `parentIdentifier`, and
+`accountIdentifier` when Full Disk Access is granted.
 
 ---
 
@@ -1194,6 +1197,54 @@ and descendants. It refuses stale metadata and a conflicting sibling name.
 
 ---
 
+#### `delete-folder-by-id`
+
+Deletes one exact, empty, ordinary folder through a plan-then-apply handshake.
+Read the folder first with `get-folder-by-id`, call once with `dryRun: true`,
+then repeat the same guards with `dryRun: false` and the returned `revision`.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `id` | string | Yes | Exact folder id (`x-coredata://…/ICFolder/pN`), or the folder's Notes UUID or numeric key |
+| `expectedName` | string | Yes | Current folder name (not a path), matched case-sensitively |
+| `expectedAccountId` | string | Yes | Owning account id (`x-coredata://…/ICAccount/pN`) |
+| `expectedParentId` | string | One of these two | Current parent folder id (same forms as `id`) |
+| `expectedRoot` | `true` | One of these two | The folder sits at the account root |
+| `dryRun` | boolean | Yes | `true` plans; `false` applies |
+| `expectedRevision` | string | On apply | The `revision` from the dry run |
+
+**Example (plan, then apply with the returned revision):**
+```json
+{
+  "id": "x-coredata://ABC/ICFolder/p42",
+  "expectedName": "Old Projects",
+  "expectedAccountId": "x-coredata://ABC/ICAccount/p3",
+  "expectedRoot": true,
+  "dryRun": true
+}
+```
+
+**Returns:** `status: "planned"` with `wouldDelete`, `identifier`, `name`,
+`accountId`, `parentId`, `folderType: 0`, zero `childFolderCount` and
+`noteCount`, and `revision`; on apply, `status: "deleted"`, `committed: true`,
+`verified: true` (Notes.app no longer resolves the id), and `storeTombstoned`.
+
+**Safety:** it always refuses Recently Deleted, smart folders, the account's
+default and other system folders, shared folders (or folders inside a shared
+folder), and any folder that still holds notes or subfolders. There is no
+override. It is **not atomic**: the guard is a pre-check followed by an
+AppleScript delete. The name, parent, account, sharing, and emptiness checks
+repeat inside the delete script, but the folder type and stable identifier come
+from the local Notes database just before it. It needs Full Disk Access and
+fails closed without it.
+
+**Errors** carry the standard `code`: `revision_conflict` (a `Conflict:` message;
+read and plan again), `unsupported` (a `Refused:` message), `verification_failed`
+with `indeterminate: true` (read the folder before any retry), and
+`full_disk_access_missing`.
+
+---
+
 #### `delete-folder`
 
 Deletes a folder.

package/build/index.js

@@ -3268,8 +3268,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path9) {
-      let input = path9;
+    function removeDotSegments(path10) {
+      let input = path10;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3674,8 +3674,8 @@ var require_schemes = __commonJS({
       }
       if (wsComponent.resourceName) {
         const queryIndex = wsComponent.resourceName.indexOf("?");
-        const path9 = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
-        wsComponent.path = path9 && path9 !== "/" ? path9 : void 0;
+        const path10 = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
+        wsComponent.path = path10 && path10 !== "/" ? path10 : void 0;
         wsComponent.query = queryIndex === -1 ? void 0 : wsComponent.resourceName.slice(queryIndex + 1);
         wsComponent.resourceName = void 0;
       }
@@ -5049,8 +5049,8 @@ var require_multipleOf = __commonJS({
         const { gen, data, schemaCode, it } = cxt;
         const prec = it.opts.multipleOfPrecision;
         const res = gen.let("res");
-        const invalid = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`;
-        cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid}))`);
+        const invalid2 = prec ? (0, codegen_1._)`Math.abs(Math.round(${res}) - ${res}) > 1e-${prec}` : (0, codegen_1._)`${res} !== parseInt(${res})`;
+        cxt.fail$data((0, codegen_1._)`(${schemaCode} === 0 || (${res} = ${data}/${schemaCode}, ${invalid2}))`);
       }
     };
     exports.default = def;
@@ -12238,32 +12238,32 @@ var require_URL = __commonJS({
           else
             return basepath.substring(0, lastslash + 1) + refpath;
         }
-        function remove_dot_segments(path9) {
-          if (!path9) return path9;
+        function remove_dot_segments(path10) {
+          if (!path10) return path10;
           var output = "";
-          while (path9.length > 0) {
-            if (path9 === "." || path9 === "..") {
-              path9 = "";
+          while (path10.length > 0) {
+            if (path10 === "." || path10 === "..") {
+              path10 = "";
               break;
             }
-            var twochars = path9.substring(0, 2);
-            var threechars = path9.substring(0, 3);
-            var fourchars = path9.substring(0, 4);
+            var twochars = path10.substring(0, 2);
+            var threechars = path10.substring(0, 3);
+            var fourchars = path10.substring(0, 4);
             if (threechars === "../") {
-              path9 = path9.substring(3);
+              path10 = path10.substring(3);
             } else if (twochars === "./") {
-              path9 = path9.substring(2);
+              path10 = path10.substring(2);
             } else if (threechars === "/./") {
-              path9 = "/" + path9.substring(3);
-            } else if (twochars === "/." && path9.length === 2) {
-              path9 = "/";
-            } else if (fourchars === "/../" || threechars === "/.." && path9.length === 3) {
-              path9 = "/" + path9.substring(4);
+              path10 = "/" + path10.substring(3);
+            } else if (twochars === "/." && path10.length === 2) {
+              path10 = "/";
+            } else if (fourchars === "/../" || threechars === "/.." && path10.length === 3) {
+              path10 = "/" + path10.substring(4);
               output = output.replace(/\/?[^\/]*$/, "");
             } else {
-              var segment = path9.match(/(\/?([^\/]*))/)[0];
+              var segment = path10.match(/(\/?([^\/]*))/)[0];
               output += segment;
-              path9 = path9.substring(segment.length);
+              path10 = path10.substring(segment.length);
             }
           }
           return output;
@@ -24465,14 +24465,14 @@ var require_turndown_cjs = __commonJS({
         } else if (node.nodeType === 1) {
           replacement = replacementForNode.call(self, node);
         }
-        return join23(output, replacement);
+        return join24(output, replacement);
       }, "");
     }
     function postProcess(output) {
       var self = this;
       this.rules.forEach(function(rule) {
         if (typeof rule.append === "function") {
-          output = join23(output, rule.append(self.options));
+          output = join24(output, rule.append(self.options));
         }
       });
       return output.replace(/^[\t\r\n]+/, "").replace(/[\t\r\n\s]+$/, "");
@@ -24484,7 +24484,7 @@ var require_turndown_cjs = __commonJS({
       if (whitespace.leading || whitespace.trailing) content = content.trim();
       return whitespace.leading + rule.replacement(content, node, this.options) + whitespace.trailing;
     }
-    function join23(output, replacement) {
+    function join24(output, replacement) {
       var s1 = trimTrailingNewlines(output);
       var s2 = trimLeadingNewlines(replacement);
       var nls = Math.max(output.length - s1.length, replacement.length - s2.length);
@@ -24979,8 +24979,8 @@ function getErrorMap() {
 
 // node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path9, errorMaps, issueData } = params;
-  const fullPath = [...path9, ...issueData.path || []];
+  const { data, path: path10, errorMaps, issueData } = params;
+  const fullPath = [...path10, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -25096,11 +25096,11 @@ var errorUtil;
 
 // node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path9, key) {
+  constructor(parent, value, path10, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path9;
+    this._path = path10;
     this._key = key;
   }
   get path() {
@@ -28737,10 +28737,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path9) {
-  if (!path9)
+function getElementAtPath(obj, path10) {
+  if (!path10)
     return obj;
-  return path9.reduce((acc, key) => acc?.[key], obj);
+  return path10.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -29060,11 +29060,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path9, issues) {
+function prefixIssues(path10, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path9);
+    iss.path.unshift(path10);
     return iss;
   });
 }
@@ -32475,11 +32475,11 @@ function normalizeObjectSchema(schema) {
   }
   return void 0;
 }
-function getDotPath(path9) {
-  if (path9.length === 0) {
+function getDotPath(path10) {
+  if (path10.length === 0) {
     return "object root";
   }
-  return path9.reduce((acc, seg, index) => {
+  return path10.reduce((acc, seg, index) => {
     if (index === 0) {
       return String(seg);
     }
@@ -40964,8 +40964,8 @@ function allowedSaveRoots() {
 function deniedSaveRoots() {
   return [join6(homedir6(), "Library/Group Containers/group.com.apple.notes")];
 }
-function canonicalize(path9) {
-  return realpathSync.native(path9);
+function canonicalize(path10) {
+  return realpathSync.native(path10);
 }
 function isWithinRoots(candidate, roots) {
   return roots.some((root) => {
@@ -40987,9 +40987,9 @@ function canonicalRoots(roots) {
   }
   return canonical;
 }
-function entryExists(path9) {
+function entryExists(path10) {
   try {
-    lstatSync(path9);
+    lstatSync(path10);
     return true;
   } catch (e) {
     const code = e.code;
@@ -41363,24 +41363,24 @@ function safeComponent(value) {
   if (value === "." || value === ".." || value.includes("/") || value.includes("\0")) return null;
   return value;
 }
-function realInside(path9, rootReal) {
+function realInside(path10, rootReal) {
   try {
-    const real = realpathSync2.native(path9);
+    const real = realpathSync2.native(path10);
     return real === rootReal || real.startsWith(rootReal + sep2) ? real : null;
   } catch {
     return null;
   }
 }
-function isRegularFile(path9) {
+function isRegularFile(path10) {
   try {
-    return lstatSync2(path9).isFile();
+    return lstatSync2(path10).isFile();
   } catch {
     return false;
   }
 }
-function isDirectory(path9) {
+function isDirectory(path10) {
   try {
-    return lstatSync2(path9).isDirectory();
+    return lstatSync2(path10).isDirectory();
   } catch {
     return false;
   }
@@ -41760,10 +41760,10 @@ function readImageInfoFd(fd) {
   const read = readSync2(fd, buf, 0, buf.length, 0);
   return parseImageHeader(buf.subarray(0, read));
 }
-function readImageInfo(path9) {
+function readImageInfo(path10) {
   let fd;
   try {
-    fd = openSync3(path9, constants3.O_RDONLY | constants3.O_NOFOLLOW);
+    fd = openSync3(path10, constants3.O_RDONLY | constants3.O_NOFOLLOW);
   } catch {
     return null;
   }
@@ -41863,9 +41863,9 @@ function readDrawingRows(noteId3, dbPath2 = join8(NOTES_CONTAINER_DIR, "NoteStor
     throw new AttachmentStoreError("Drawing rows could not be parsed", "query_error");
   }
 }
-function kindOf(path9) {
+function kindOf(path10) {
   try {
-    const st = lstatSync3(path9);
+    const st = lstatSync3(path10);
     return st.isFile() ? "file" : st.isDirectory() ? "dir" : null;
   } catch {
     return null;
@@ -41931,13 +41931,13 @@ function describeDrawings(rows, containerDir = NOTES_CONTAINER_DIR) {
     const previewPath = accountDir ? findLargestPreview(accountDir, row.identifier) : null;
     const bundle = accountDir && id2 && kind === "paper" ? realInside(join8(accountDir, "Paper", "Bundles", `${id2}.bundle`), accountDir) : null;
     let raster = null;
-    for (const [path9, source] of [
+    for (const [path10, source] of [
       [fallbackImagePath, "fallback"],
       [previewPath, "preview"]
     ]) {
-      const info = path9 ? readImageInfo(path9) : null;
-      if (path9 && info) {
-        raster = { path: path9, source, ...info };
+      const info = path10 ? readImageInfo(path10) : null;
+      if (path10 && info) {
+        raster = { path: path10, source, ...info };
         break;
       }
     }
@@ -41954,10 +41954,10 @@ function describeDrawings(rows, containerDir = NOTES_CONTAINER_DIR) {
     };
   });
 }
-function verifyWrittenImage(fd, path9, expected) {
+function verifyWrittenImage(fd, path10, expected) {
   const check2 = readImageInfoFd(fd);
   if (!check2 || check2.format !== expected.format || check2.width !== expected.width || check2.height !== expected.height) {
-    unlinkSync2(path9);
+    unlinkSync2(path10);
     throw new Error("The exported image failed validation and was removed.");
   }
   return check2;
@@ -42321,6 +42321,58 @@ function buildFolderReference(folderPath) {
   return parts.reverse().map((part) => `folder "${escapePlainStringForAppleScript(part)}"`).join(" of ");
 }
 var AS_ACCOUNT_REF = "__acctRef";
+var LIVE_FOLDER_NOT_FOUND = "Folder not found";
+function buildLiveFolderResolution(folderPath, varName, opts = {}) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(varName)) throw new Error("Invalid AppleScript variable");
+  buildFolderReference(folderPath);
+  const parts = splitFolderPath(folderPath);
+  const c = `${varName}_c`;
+  const cid = `${varName}_cid`;
+  const any = `${varName}_any`;
+  const parent = `${varName}_p`;
+  const notFound = `error "${LIVE_FOLDER_NOT_FOUND}: ${escapePlainStringForAppleScript(folderPath)}" number -1728`;
+  const lines = [];
+  parts.forEach((part, i) => {
+    const name = escapePlainStringForAppleScript(part);
+    if (i === 0) {
+      lines.push(
+        `set ${varName} to missing value`,
+        `set ${any} to missing value`,
+        `repeat with ${c} in (folders of ${AS_ACCOUNT_REF} whose name is "${name}")`,
+        `  try`,
+        `    set ${cid} to id of ${c}`,
+        `    if exists folder id ${cid} then`,
+        `      if class of (container of ${c}) is not folder then`,
+        `        set ${varName} to folder id ${cid}`,
+        `        exit repeat`,
+        `      else if ${any} is missing value then`,
+        `        set ${any} to folder id ${cid}`,
+        `      end if`,
+        `    end if`,
+        `  end try`,
+        `end repeat`
+      );
+      if (!opts.rootOnly)
+        lines.push(`if ${varName} is missing value then set ${varName} to ${any}`);
+    } else {
+      lines.push(
+        `set ${parent} to ${varName}`,
+        `set ${varName} to missing value`,
+        `repeat with ${c} in (folders of ${parent} whose name is "${name}")`,
+        `  try`,
+        `    set ${cid} to id of ${c}`,
+        `    if exists folder id ${cid} then`,
+        `      set ${varName} to folder id ${cid}`,
+        `      exit repeat`,
+        `    end if`,
+        `  end try`,
+        `end repeat`
+      );
+    }
+    lines.push(`if ${varName} is missing value then ${notFound}`);
+  });
+  return lines.join("\n");
+}
 var ACCOUNT_RESOLUTION_ERROR = "AccountResolutionError:";
 function throwIfAccountResolutionFailed(error2) {
   if (!error2) return;
@@ -42373,6 +42425,34 @@ function buildAppLevelScript(command) {
     end tell
   `;
 }
+function folderDeleteFactsScript(id2) {
+  if (!FOLDER_ID_PATTERN.test(id2)) throw new Error("An exact folder ID is required");
+  return `
+      set f to folder id "${id2}"
+      set folderName to name of f
+      set parentRef to container of f
+      set parentId to ""
+      if class of parentRef is folder then set parentId to id of parentRef
+      set sharedAny to (shared of f)
+      set acct to parentRef
+      repeat while class of acct is folder
+        if shared of acct then set sharedAny to true
+        set acct to container of acct
+      end repeat
+      set acctId to id of acct
+      set defaultId to ""
+      try
+        set defaultId to id of default folder of acct
+      end try
+      -- "folders of f" keeps listing a child deleted earlier in this Notes
+      -- session, while "exists folder id" reports it gone, so count only
+      -- children that still exist.
+      set childCount to 0
+      repeat with childRef in folders of f
+        if exists folder id (id of childRef) then set childCount to childCount + 1
+      end repeat
+      set noteCount to count of notes of f`;
+}
 function getNoteLinkFromDB(coreDataId2) {
   const match = coreDataId2.match(/\/p(\d+)$/);
   if (!match) return null;
@@ -42522,8 +42602,8 @@ var AppleNotesManager = class {
     const safeBody = escapeHtmlForAppleScript(`<h1>${htmlTitle}</h1>${bodyContent}`);
     let createCommand;
     if (folder) {
-      const folderRef = buildFolderReference(folder);
-      createCommand = `make new note at ${folderRef} with properties {body:"${safeBody}"}`;
+      createCommand = `${buildLiveFolderResolution(folder, "__folder")}
+      make new note at __folder with properties {body:"${safeBody}"}`;
     } else {
       createCommand = `
         set newNote to make new note with properties {body:"${safeBody}"}
@@ -43402,18 +43482,134 @@ var AppleNotesManager = class {
       );
     return { id: id2, name: newName, parentId: expectedParentId };
   }
-  /** Read the exact name and parent identity used by guarded folder rename. */
+  /** Read the exact name, parent, and account identity used by guarded folder writes. */
   getFolderById(id2) {
     if (!/^x-coredata:\/\/[0-9a-f-]+\/ICFolder\/p\d+$/i.test(id2))
       throw new Error("An exact folder ID is required");
     const result = executeAppleScript(`tell application "Notes"
       set f to folder id "${id2}"
-      return (name of f) & ${AS_FIELD_SEP} & (id of container of f)
+      set acct to container of f
+      repeat while class of acct is folder
+        set acct to container of acct
+      end repeat
+      return (name of f) & ${AS_FIELD_SEP} & (id of container of f) & ${AS_FIELD_SEP} & (id of acct)
     end tell`);
     if (!result.success) throw new Error(result.error || "Folder not found");
-    const [name, parentId] = result.output.replace(/\n$/, "").split(FIELD_SEP);
+    const [name, parentId, accountId] = result.output.replace(/\n$/, "").split(FIELD_SEP);
     if (!name || !parentId) throw new Error("Incomplete folder metadata");
-    return { id: id2, name, parentId };
+    return accountId ? { id: id2, name, parentId, accountId, isRoot: parentId === accountId } : { id: id2, name, parentId };
+  }
+  /**
+   * Reads, in one AppleScript, everything Notes.app itself knows about a folder
+   * that guarded deletion checks: name, parent (empty at an account root),
+   * account, the account's default folder, shared state of the folder or any
+   * ancestor, and the counts of direct child folders and notes.
+   */
+  readFolderForDelete(id2) {
+    if (!FOLDER_ID_PATTERN.test(id2)) throw new Error("An exact folder ID is required");
+    const result = executeAppleScript(
+      buildAppLevelScript(`${folderDeleteFactsScript(id2)}
+      return folderName & ${AS_FIELD_SEP} & parentId & ${AS_FIELD_SEP} & acctId & ${AS_FIELD_SEP} & defaultId & ${AS_FIELD_SEP} & (sharedAny as text) & ${AS_FIELD_SEP} & (childCount as text) & ${AS_FIELD_SEP} & (noteCount as text)`)
+    );
+    if (!result.success) throw new Error(result.error || "Folder not found");
+    const parts = result.output.replace(/\n$/, "").split(FIELD_SEP);
+    if (parts.length !== 7 || !parts[0] || !parts[2]) throw new Error("Incomplete folder metadata");
+    const count = (value) => {
+      const parsed = Number(value.trim());
+      if (!Number.isInteger(parsed) || parsed < 0) throw new Error("Incomplete folder metadata");
+      return parsed;
+    };
+    return {
+      id: id2,
+      name: parts[0],
+      parentId: parts[1] || null,
+      accountId: parts[2],
+      defaultFolderId: parts[3] || null,
+      shared: parts[4].trim() === "true",
+      childFolderCount: count(parts[5]),
+      noteCount: count(parts[6])
+    };
+  }
+  /**
+   * Deletes one empty folder by exact id, repeating every Notes.app-visible
+   * guard inside the same AppleScript as the `delete` command: exact name
+   * (case-sensitive), parent or account root, account, not the default folder,
+   * not shared (itself or an ancestor), no child folders, no notes.
+   *
+   * Store-only facts (folder type, stable identifier) are checked by the caller
+   * before this runs, so the whole guard is a pre-check followed by an
+   * AppleScript delete, not one atomic transaction.
+   */
+  deleteEmptyFolderIfUnchanged(id2, expected) {
+    if (!FOLDER_ID_PATTERN.test(id2)) throw new Error("An exact folder ID is required");
+    const literal2 = (value) => `"${escapePlainStringForAppleScript(value)}"`;
+    const script = buildAppLevelScript(`${folderDeleteFactsScript(id2)}
+      considering case
+        if folderName is not ${literal2(expected.name)} then return "SAFETY_CONFLICT:name"
+      end considering
+      if parentId is not ${literal2(expected.parentId ?? "")} then return "SAFETY_CONFLICT:parent"
+      if acctId is not ${literal2(expected.accountId)} then return "SAFETY_CONFLICT:account"
+      if defaultId is ${literal2(id2)} then return "SAFETY_REFUSED:default folder"
+      if sharedAny then return "SAFETY_REFUSED:shared folder"
+      if childCount is not 0 then return "SAFETY_REFUSED:folder has child folders"
+      if noteCount is not 0 then return "SAFETY_REFUSED:folder has notes"
+      delete f
+      return "SAFETY_DELETED"`);
+    const result = executeMutationAppleScript(script);
+    if (!result.success) {
+      console.error(`Failed guarded folder delete for "${id2}":`, result.error);
+      return { status: "failed", reason: result.error || "AppleScript failed" };
+    }
+    const output = result.output.trim();
+    const colon = output.indexOf(":");
+    const status = colon === -1 ? output : output.slice(0, colon);
+    const reason = colon === -1 ? "" : output.slice(colon + 1);
+    if (status === "SAFETY_DELETED") return { status: "deleted" };
+    if (status === "SAFETY_CONFLICT") return { status: "conflict", reason };
+    if (status === "SAFETY_REFUSED") return { status: "refused", reason };
+    return { status: "failed", reason: "Unexpected AppleScript result" };
+  }
+  /**
+   * Counts how many of the given notes Notes.app currently places outside the
+   * folder: in another folder, or in Recently Deleted (a note trashed this
+   * session reports a non-folder container). A note Notes.app cannot resolve
+   * is not counted, so the caller keeps treating it as present.
+   *
+   * The local store can keep a just-trashed note in its old folder for
+   * minutes; this lets guarded folder deletion discount such notes using
+   * Notes.app's live view instead of refusing until the store catches up.
+   */
+  countNotesOutsideFolder(folderId2, noteIds) {
+    if (!FOLDER_ID_PATTERN.test(folderId2)) throw new Error("An exact folder ID is required");
+    if (noteIds.length === 0) return 0;
+    const ids = noteIds.map((noteId3) => `"${sanitizeNoteId(noteId3)}"`).join(", ");
+    const result = executeAppleScript(
+      buildAppLevelScript(`
+      set movedCount to 0
+      repeat with noteIdRef in {${ids}}
+        try
+          set c to container of note id (contents of noteIdRef)
+          if class of c is not folder then
+            set movedCount to movedCount + 1
+          else if (id of c) is not "${folderId2}" then
+            set movedCount to movedCount + 1
+          end if
+        end try
+      end repeat
+      return movedCount as text`)
+    );
+    if (!result.success) return 0;
+    const moved = Number(result.output.trim());
+    return Number.isInteger(moved) && moved >= 0 && moved <= noteIds.length ? moved : 0;
+  }
+  /** Whether Notes.app still resolves an exact folder id. */
+  folderExistsById(id2) {
+    if (!FOLDER_ID_PATTERN.test(id2)) throw new Error("An exact folder ID is required");
+    const result = executeAppleScript(
+      buildAppLevelScript(`return (exists folder id "${id2}") as text`)
+    );
+    if (!result.success) throw new Error(result.error || "Could not check folder existence");
+    return result.output.trim() === "true";
   }
   /** Insert one file into an unchanged exact note and return Notes' attachment ID. */
   addAttachmentById(id2, expectedBody, filePath) {
@@ -43519,10 +43715,10 @@ var AppleNotesManager = class {
     }
     for (let i = 0; i < parts.length; i++) {
       const currentPath = parts.slice(0, i + 1).map((p) => escapeFolderName(p)).join("/");
-      const currentRef = buildFolderReference(currentPath);
       const checkScript = buildAccountScopedScript(
         { account: targetAccount },
-        `return id of ${currentRef}`
+        `${buildLiveFolderResolution(currentPath, "__folder", { rootOnly: true })}
+        return id of __folder`
       );
       const checkResult = executeAppleScript(checkScript);
       if (checkResult.success) {
@@ -43534,8 +43730,8 @@ var AppleNotesManager = class {
         createCommand = `make new folder with properties {name:"${segmentName}"}`;
       } else {
         const parentPath = parts.slice(0, i).map((p) => escapeFolderName(p)).join("/");
-        const parentRef = buildFolderReference(parentPath);
-        createCommand = `make new folder at ${parentRef} with properties {name:"${segmentName}"}`;
+        createCommand = `${buildLiveFolderResolution(parentPath, "__parent", { rootOnly: true })}
+        make new folder at __parent with properties {name:"${segmentName}"}`;
       }
       const script = buildAccountScopedScript({ account: targetAccount }, createCommand);
       const result = executeMutationAppleScript(script);
@@ -43545,14 +43741,23 @@ var AppleNotesManager = class {
         return null;
       }
     }
-    const fullRef = buildFolderReference(name);
     const idScript = buildAccountScopedScript(
       { account: targetAccount },
-      `return (id of ${fullRef}) & ${AS_FIELD_SEP} & (name of it)`
+      `${buildLiveFolderResolution(name, "__folder", { rootOnly: true })}
+      return (id of __folder) & ${AS_FIELD_SEP} & (name of it)`
     );
     const idResult = executeAppleScript(idScript);
     const [rawId = "", rawAccount = ""] = idResult.success ? idResult.output.split(FIELD_SEP) : [];
-    const folderId2 = idResult.success ? extractCoreDataId(rawId, "folder") : "";
+    const bareId = rawId.trim();
+    const folderId2 = !idResult.success ? "" : FOLDER_ID_PATTERN.test(bareId) ? bareId : extractCoreDataId(rawId, "folder");
+    if (!folderId2) {
+      throwIfAccountResolutionFailed(idResult.error);
+      console.error(
+        `Folder "${name}" could not be confirmed after creation:`,
+        idResult.error ?? "no folder id returned"
+      );
+      return null;
+    }
     return {
       id: folderId2,
       name,
@@ -43570,7 +43775,8 @@ var AppleNotesManager = class {
    */
   deleteFolder(name, account) {
     const targetAccount = this.resolveAccount(account);
-    const deleteCommand = `delete ${buildFolderReference(name)}`;
+    const deleteCommand = `${buildLiveFolderResolution(name, "__folder")}
+    delete __folder`;
     const script = buildAccountScopedScript({ account: targetAccount }, deleteCommand);
     const result = executeMutationAppleScript(script);
     if (!result.success) {
@@ -43596,10 +43802,10 @@ var AppleNotesManager = class {
   moveNoteById(id2, destinationFolder, account, scope2) {
     const targetAccount = this.resolveAccount(account);
     const safeId = sanitizeNoteId(id2);
-    const destFolderRef = `${buildFolderReference(destinationFolder)} of ${AS_ACCOUNT_REF}`;
+    const destFolderSetup = buildLiveFolderResolution(destinationFolder, "destFolder");
     const moveCommand = `
       ${buildAccountResolution(targetAccount)}
-      set destFolder to ${destFolderRef}
+      ${destFolderSetup}
       set noteRef to note id "${safeId}"${buildScopeGuardScript("noteRef", scope2, "destFolder")}
       move noteRef to destFolder
       set movedNoteRef to note id "${safeId}"
@@ -44505,7 +44711,7 @@ var AppleNotesManager = class {
   batchMoveNotes(ids, folder, account) {
     if (ids.length === 0) return [];
     const targetAccount = this.resolveAccount(account);
-    const destFolderRef = `${buildFolderReference(folder)} of ${AS_ACCOUNT_REF}`;
+    const destFolderSetup = buildLiveFolderResolution(folder, "destFolder");
     const results = new Array(ids.length);
     const runnable = [];
     ids.forEach((id2, i) => {
@@ -44523,7 +44729,7 @@ var AppleNotesManager = class {
       const idList2 = runnable.map((r) => `"${r.safe}"`).join(", ");
       const script = buildAppLevelScript(`
         ${buildAccountResolution(targetAccount)}
-        set destFolder to ${destFolderRef}
+        ${destFolderSetup}
         set out to ""
         repeat with rawId in {${idList2}}
           set theId to (rawId as text)
@@ -46401,12 +46607,12 @@ function resolveFolders(rows) {
     seen.add(pk);
     const parent = row.parent !== null ? resolve5(row.parent, seen) : void 0;
     const name = row.name ?? "";
-    const path9 = parent ? `${parent.path}/${escapeSegment(name)}` : escapeSegment(name);
+    const path10 = parent ? `${parent.path}/${escapeSegment(name)}` : escapeSegment(name);
     const plainPath = parent ? `${parent.plainPath}/${name}` : name;
     const info = {
-      path: path9,
+      path: path10,
       plainPath,
-      keys: [...new Set([name, plainPath, path9].map(normalizeForMatch))],
+      keys: [...new Set([name, plainPath, path10].map(normalizeForMatch))],
       accountPk: row.owner ?? parent?.accountPk ?? null,
       shared: Boolean(row.shared) || Boolean(parent?.shared)
     };
@@ -46747,9 +46953,9 @@ function runNativeTagsShortcut(input) {
     throw new Error(`Import the supplied ${status.shortcut}.shortcut in Shortcuts first`);
   const directory = mkdtempSync2(join15(tmpdir2(), "apple-notes-native-tags-"));
   try {
-    const path9 = join15(directory, "request.json");
-    writeFileSync(path9, JSON.stringify(input), { mode: 384 });
-    execFileSync14("/usr/bin/shortcuts", ["run", status.identifier, "--input-path", path9], {
+    const path10 = join15(directory, "request.json");
+    writeFileSync(path10, JSON.stringify(input), { mode: 384 });
+    execFileSync14("/usr/bin/shortcuts", ["run", status.identifier, "--input-path", path10], {
       encoding: "utf8",
       timeout: 6e4,
       maxBuffer: 1024 * 1024,
@@ -47353,7 +47559,7 @@ function createMarkdownNote(manager, request, run = runBackgroundShortcut) {
     throw new Error(
       `Install the supplied "${status.shortcut}" Shortcut once; Shortcuts must list it exactly once`
     );
-  const segments = (path9) => JSON.stringify(splitFolderPath(path9).map((part) => part.toLocaleLowerCase()));
+  const segments = (path10) => JSON.stringify(splitFolderPath(path10).map((part) => part.toLocaleLowerCase()));
   if (request.folder) {
     const wanted = segments(request.folder);
     if (!manager.listAccounts().some(
@@ -47683,9 +47889,9 @@ function getCapabilityMatrix(probe = probeCapabilityEnvironment) {
   return evaluateFeatures(probe());
 }
 function formatCapabilityMatrix(matrix) {
-  const os9 = matrix.runtimeOS;
+  const os10 = matrix.runtimeOS;
   const lines = [
-    `Feature matrix (macOS ${os9.macOSVersion ?? "unknown"}, Darwin ${os9.darwinRelease}):`
+    `Feature matrix (macOS ${os10.macOSVersion ?? "unknown"}, Darwin ${os10.darwinRelease}):`
   ];
   for (const [name, status] of Object.entries(matrix.features)) {
     lines.push(
@@ -47811,11 +48017,11 @@ function fileConfigPath(env = process.env) {
   if (override && override.trim()) return override.trim();
   return join17(homedir14(), "Library", "Application Support", "apple-notes-mcp", "config.json");
 }
-function loadFileConfig(env = process.env, path9 = fileConfigPath(env)) {
+function loadFileConfig(env = process.env, path10 = fileConfigPath(env)) {
   const applied = [];
   try {
-    if (!existsSync11(path9)) return applied;
-    const parsed = JSON.parse(readFileSync2(path9, "utf8"));
+    if (!existsSync11(path10)) return applied;
+    const parsed = JSON.parse(readFileSync2(path10, "utf8"));
     if (!parsed || typeof parsed !== "object") return applied;
     for (const [k, v] of Object.entries(parsed)) {
       if (typeof v !== "string") continue;
@@ -47825,7 +48031,7 @@ function loadFileConfig(env = process.env, path9 = fileConfigPath(env)) {
       }
     }
   } catch (e) {
-    console.error(`Failed to load apple-notes-mcp config file ${path9}: ${String(e)}`);
+    console.error(`Failed to load apple-notes-mcp config file ${path10}: ${String(e)}`);
   }
   return applied;
 }
@@ -48668,10 +48874,10 @@ function listDirectory(dir, limit) {
     return [];
   }
 }
-function isFile(path9) {
+function isFile(path10) {
   let fd;
   try {
-    fd = openSync4(path9, constants4.O_RDONLY | constants4.O_NOFOLLOW);
+    fd = openSync4(path10, constants4.O_RDONLY | constants4.O_NOFOLLOW);
     return fstatSync4(fd).isFile();
   } catch {
     return false;
@@ -48679,9 +48885,9 @@ function isFile(path9) {
     if (fd !== void 0) closeSync4(fd);
   }
 }
-function isDirectory2(path9) {
+function isDirectory2(path10) {
   try {
-    return statSync3(path9).isDirectory();
+    return statSync3(path10).isDirectory();
   } catch {
     return false;
   }
@@ -48765,8 +48971,8 @@ var AssetLocator = class {
       join19(account, "Media", mediaId, filename)
     ];
     for (const candidate of candidates) {
-      const path9 = confine(candidate, account);
-      if (path9 && isFile(path9)) return { path: path9, name: filename, role: "original" };
+      const path10 = confine(candidate, account);
+      if (path10 && isFile(path10)) return { path: path10, name: filename, role: "original" };
     }
     return void 0;
   }
@@ -48781,8 +48987,8 @@ var AssetLocator = class {
     ];
     for (const g of generations)
       for (const name of names) {
-        const path9 = confine(g ? join19(base, g, name) : join19(base, name), account);
-        if (path9 && isFile(path9)) return path9;
+        const path10 = confine(g ? join19(base, g, name) : join19(base, name), account);
+        if (path10 && isFile(path10)) return path10;
       }
     return void 0;
   }
@@ -48815,16 +49021,16 @@ var AssetLocator = class {
   bundleImage(bundle, account) {
     const found = [];
     for (const child of listDirectory(bundle, MAX_BUNDLE_ENTRIES2)) {
-      const path9 = confine(join19(bundle, child), account);
-      if (!path9) continue;
-      if (isFile(path9)) found.push(path9);
+      const path10 = confine(join19(bundle, child), account);
+      if (!path10) continue;
+      if (isFile(path10)) found.push(path10);
       else
-        for (const grandchild of listDirectory(path9, MAX_BUNDLE_ENTRIES2)) {
-          const inner = confine(join19(path9, grandchild), account);
+        for (const grandchild of listDirectory(path10, MAX_BUNDLE_ENTRIES2)) {
+          const inner = confine(join19(path10, grandchild), account);
           if (inner && isFile(inner)) found.push(inner);
         }
     }
-    return found.find((path9) => basename3(path9) === "Preview.png") ?? found.find((path9) => IMAGE_EXTENSIONS.has(extname3(path9).toLowerCase()));
+    return found.find((path10) => basename3(path10) === "Preview.png") ?? found.find((path10) => IMAGE_EXTENSIONS.has(extname3(path10).toLowerCase()));
   }
 };
 function sniffMime(head, name) {
@@ -48872,8 +49078,8 @@ function safeAssetName(name, mime) {
   if (clean.length > 120) clean = clean.slice(0, 120 - ext.length) + ext;
   return clean;
 }
-function encodePathUrl(path9) {
-  return path9.split("/").map(encodeURIComponent).join("/");
+function encodePathUrl(path10) {
+  return path10.split("/").map(encodeURIComponent).join("/");
 }
 function canonicalForm(abs) {
   let current = abs;
@@ -48892,7 +49098,7 @@ function canonicalForm(abs) {
 }
 function assertExportPath(p, container = NOTES_CONTAINER) {
   const abs = assertSafeSavePath(p);
-  const within = (path9, root) => path9 === root || path9.startsWith(root + sep3);
+  const within = (path10, root) => path10 === root || path10.startsWith(root + sep3);
   const roots = [resolve3(container), canonicalForm(resolve3(container))];
   const forms = [abs, canonicalForm(abs)];
   if (forms.some((form) => roots.some((root) => within(form, root))))
@@ -48902,16 +49108,16 @@ function assertExportPath(p, container = NOTES_CONTAINER) {
 var CREATE_FLAGS = constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | constants4.O_NOFOLLOW;
 var OutputExistsError = class extends Error {
   code = "output_exists";
-  constructor(path9) {
-    super(`Output file already exists: ${path9}. Choose a new path or remove the old file first.`);
+  constructor(path10) {
+    super(`Output file already exists: ${path10}. Choose a new path or remove the old file first.`);
     this.name = "OutputExistsError";
   }
 };
-function openCreateOnly(path9) {
+function openCreateOnly(path10) {
   try {
-    return openSync4(path9, CREATE_FLAGS, 420);
+    return openSync4(path10, CREATE_FLAGS, 420);
   } catch (error2) {
-    if (error2.code === "EEXIST") throw new OutputExistsError(path9);
+    if (error2.code === "EEXIST") throw new OutputExistsError(path10);
     throw error2;
   }
 }
@@ -48925,8 +49131,8 @@ function writeAllAndClose(fd, content) {
     closeSync4(fd);
   }
 }
-function openSource(path9) {
-  const fd = openSync4(path9, constants4.O_RDONLY | constants4.O_NOFOLLOW);
+function openSource(path10) {
+  const fd = openSync4(path10, constants4.O_RDONLY | constants4.O_NOFOLLOW);
   const stat = fstatSync4(fd);
   if (!stat.isFile()) {
     closeSync4(fd);
@@ -49908,9 +50114,9 @@ var NotesExportError = class extends Error {
   }
   code;
 };
-function validPath(path9, what) {
+function validPath(path10, what) {
   try {
-    return assertExportPath(path9);
+    return assertExportPath(path10);
   } catch (error2) {
     throw new NotesExportError(
       "invalid-path",
@@ -50099,9 +50305,9 @@ function assertExistingContentPreserved(before, after) {
       throw new Error("Existing native object content or presentation changed");
   }
 }
-function localAttachment(path9) {
-  if (!isAbsolute3(path9)) throw new Error("An absolute local file path is required");
-  const descriptor = openSync5(path9, constants5.O_RDONLY | constants5.O_NOFOLLOW);
+function localAttachment(path10) {
+  if (!isAbsolute3(path10)) throw new Error("An absolute local file path is required");
+  const descriptor = openSync5(path10, constants5.O_RDONLY | constants5.O_NOFOLLOW);
   try {
     const stat = fstatSync5(descriptor);
     if (!stat.isFile() || stat.size === 0 || stat.size > 64 * 1024 * 1024)
@@ -50139,7 +50345,7 @@ function registerDirectOperations(server2, manager) {
   }
   tool(
     "get-folder-by-id",
-    "Use when: reading the exact folder name and parent before a guarded rename.\nReturns: folder id, current name, and parent id.\nDo not use when: listing folders by path (list-folders).\nSafety: read-only.",
+    "Use when: reading the exact folder name, parent, and account before a guarded rename or delete-folder-by-id.\nReturns: folder id, current name, parent id, accountId, and isRoot (true when the folder sits at the account root; pass expectedRoot: true to delete-folder-by-id then, otherwise parentId as expectedParentId).\nDo not use when: listing folders by path (list-folders).\nSafety: read-only.",
     { id: folderId },
     ({ id: id2 }) => {
       const folder = manager.getFolderById(id2);
@@ -50223,8 +50429,8 @@ function registerDirectOperations(server2, manager) {
     }
   );
 }
-function attachmentName(path9, filename) {
-  const source = basename5(path9);
+function attachmentName(path10, filename) {
+  const source = basename5(path10);
   if (filename === void 0) return source;
   if (Buffer.byteLength(filename, "utf8") > 255)
     throw new Error("filename must be at most 255 bytes");
@@ -50239,11 +50445,11 @@ function attachmentName(path9, filename) {
   return filename;
 }
 function attachFile(manager, args) {
-  const { id: id2, expectedContentHash, path: path9 } = args;
-  const name = attachmentName(path9, args.filename);
+  const { id: id2, expectedContentHash, path: path10 } = args;
+  const name = attachmentName(path10, args.filename);
   const before = readSnapshot(manager, id2);
   if (before.hash !== expectedContentHash) throw new Error("Note revision changed");
-  const bytes = localAttachment(path9);
+  const bytes = localAttachment(path10);
   const beforeAttachments = manager.listAttachmentsById(id2);
   const directory = mkdtempSync4(join22(tmpdir4(), "notes-attachment-add-"));
   const temporaryFile = join22(directory, name);
@@ -50300,6 +50506,329 @@ function attachFile(manager, args) {
   }
 }
 
+// src/tools/folderDelete.ts
+import { createHash as createHash3 } from "node:crypto";
+
+// src/utils/folderStore.ts
+import { execFileSync as execFileSync19 } from "child_process";
+import * as os9 from "os";
+import * as path9 from "path";
+var NOTE_STORE_PATH = path9.join(
+  os9.homedir(),
+  "Library/Group Containers/group.com.apple.notes/NoteStore.sqlite"
+);
+var NOTE_KEY_LIMIT = 50;
+var FolderStoreError = class extends Error {
+  constructor(message, reason) {
+    super(message);
+    this.reason = reason;
+    this.name = "FolderStoreError";
+  }
+  reason;
+};
+var REQUIRED_FOLDER_COLUMNS = [
+  "ZFOLDERTYPE",
+  "ZIDENTIFIER",
+  "ZMARKEDFORDELETION",
+  "ZPARENT",
+  "ZOWNER",
+  "ZFOLDER",
+  "ZSERVERSHAREDATA"
+];
+function buildFolderFactsSql(hasSmartQueryColumn) {
+  const smart = hasSmartQueryColumn ? "coalesce(f.ZSMARTFOLDERQUERYJSON, '') <> ''" : "0";
+  return `WITH RECURSIVE anc(pk, depth) AS (
+  SELECT ZPARENT, 1 FROM ZICCLOUDSYNCINGOBJECT WHERE Z_PK = @pk
+  UNION ALL
+  SELECT o.ZPARENT, anc.depth + 1 FROM ZICCLOUDSYNCINGOBJECT o JOIN anc ON o.Z_PK = anc.pk
+  WHERE anc.pk IS NOT NULL AND anc.depth < 64
+)
+SELECT json_object(
+  'pk', f.Z_PK,
+  'entity', e.Z_NAME,
+  'identifier', f.ZIDENTIFIER,
+  'folderType', f.ZFOLDERTYPE,
+  'markedForDeletion', coalesce(f.ZMARKEDFORDELETION, 0),
+  'parentPk', f.ZPARENT,
+  'accountPk', f.ZOWNER,
+  'hasSmartQuery', ${smart},
+  'sharedRecord', f.ZSERVERSHAREDATA IS NOT NULL,
+  'sharedAncestor', (SELECT count(*) FROM ZICCLOUDSYNCINGOBJECT a JOIN anc ON a.Z_PK = anc.pk
+                     WHERE a.ZSERVERSHAREDATA IS NOT NULL) > 0,
+  'childFolderCount', (SELECT count(*) FROM ZICCLOUDSYNCINGOBJECT c
+                       WHERE c.Z_ENT = f.Z_ENT AND c.ZPARENT = f.Z_PK
+                         AND coalesce(c.ZMARKEDFORDELETION, 0) = 0),
+  'noteCount', (SELECT count(*) FROM ZICCLOUDSYNCINGOBJECT n
+                WHERE n.Z_ENT = (SELECT Z_ENT FROM Z_PRIMARYKEY WHERE Z_NAME = 'ICNote')
+                  AND n.ZFOLDER = f.Z_PK AND coalesce(n.ZMARKEDFORDELETION, 0) = 0),
+  'noteKeys', json((SELECT json_group_array(k.Z_PK) FROM (
+                SELECT n.Z_PK FROM ZICCLOUDSYNCINGOBJECT n
+                WHERE n.Z_ENT = (SELECT Z_ENT FROM Z_PRIMARYKEY WHERE Z_NAME = 'ICNote')
+                  AND n.ZFOLDER = f.Z_PK AND coalesce(n.ZMARKEDFORDELETION, 0) = 0
+                ORDER BY n.Z_PK LIMIT ${NOTE_KEY_LIMIT}) k))
+)
+FROM ZICCLOUDSYNCINGOBJECT f JOIN Z_PRIMARYKEY e ON e.Z_ENT = f.Z_ENT
+WHERE f.Z_PK = @pk;`;
+}
+function runSqlite7(dbPath2, sql, pk) {
+  const args = ["-readonly"];
+  if (pk !== void 0) args.push("-cmd", `.parameter set @pk ${pk}`);
+  args.push(dbPath2, sql);
+  return execFileSync19("sqlite3", args, {
+    encoding: "utf8",
+    timeout: 5e3,
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+function classify(error2) {
+  const message = error2 instanceof Error ? error2.message : String(error2);
+  if (/authorization denied|unable to open database|not authorized/i.test(message)) {
+    return new FolderStoreError(
+      "Full Disk Access is required to verify folder type and contents before deleting. Grant it to the app that launches this server, then relaunch it.",
+      "no_fda"
+    );
+  }
+  return new FolderStoreError(`Failed to read folder facts: ${message}`, "query_error");
+}
+function numberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readFolderStoreFacts(pk, dbPath2 = NOTE_STORE_PATH) {
+  if (!Number.isSafeInteger(pk) || pk <= 0) {
+    throw new FolderStoreError("Folder key must be a positive integer", "query_error");
+  }
+  let columns;
+  let row;
+  try {
+    columns = new Set(
+      runSqlite7(dbPath2, "PRAGMA table_info(ZICCLOUDSYNCINGOBJECT);").split("\n").map((line) => line.split("|")[1]).filter(Boolean)
+    );
+    const missing = REQUIRED_FOLDER_COLUMNS.filter((column) => !columns.has(column));
+    if (missing.length > 0) {
+      throw new FolderStoreError(
+        `This macOS Notes schema lacks ${missing.join(", ")}; folder safety cannot be verified`,
+        "schema"
+      );
+    }
+    row = runSqlite7(dbPath2, buildFolderFactsSql(columns.has("ZSMARTFOLDERQUERYJSON")), pk);
+  } catch (error2) {
+    if (error2 instanceof FolderStoreError) throw error2;
+    throw classify(error2);
+  }
+  if (!row) return null;
+  const raw = JSON.parse(row);
+  if (raw.entity !== "ICFolder") {
+    throw new FolderStoreError("That identifier does not name a folder", "not_folder");
+  }
+  return {
+    pk,
+    identifier: typeof raw.identifier === "string" ? raw.identifier : null,
+    folderType: numberOrNull(raw.folderType),
+    markedForDeletion: raw.markedForDeletion === 1,
+    parentPk: numberOrNull(raw.parentPk),
+    accountPk: numberOrNull(raw.accountPk),
+    hasSmartQuery: raw.hasSmartQuery === 1,
+    sharedRecord: raw.sharedRecord === 1,
+    sharedAncestor: raw.sharedAncestor === 1,
+    childFolderCount: numberOrNull(raw.childFolderCount) ?? 0,
+    noteCount: numberOrNull(raw.noteCount) ?? 0,
+    noteKeys: Array.isArray(raw.noteKeys) ? raw.noteKeys.filter((key) => typeof key === "number") : []
+  };
+}
+
+// src/tools/folderDelete.ts
+var folderIdSchema = external_exports.string().max(2e3).transform(looseIdTransform("ICFolder"));
+var accountIdSchema = external_exports.string().max(2e3).regex(/^x-coredata:\/\/[0-9a-f-]+\/ICAccount\/p\d+$/i, "An exact account ID is required");
+var revisionSchema = external_exports.string().regex(/^sha256:[a-f0-9]{64}$/);
+var defaultDeps = {
+  readStore: (pk) => readFolderStoreFacts(pk),
+  sleep: (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms)
+};
+function conflict(message) {
+  return new CodedError(`Conflict: ${message}`, { code: "revision_conflict", committed: false });
+}
+function refused(message) {
+  return new CodedError(`Refused: ${message}`, { code: "unsupported", committed: false });
+}
+function uncertain(message) {
+  return new CodedError(message, { code: "verification_failed", indeterminate: true });
+}
+function invalid(message) {
+  return new CodedError(message, { code: "validation_error", committed: false });
+}
+function coreDataPk(id2) {
+  const match = /\/p(\d+)$/.exec(id2);
+  if (!match) throw new Error(`Not an x-coredata id: ${id2}`);
+  return Number(match[1]);
+}
+function folderDeleteRefusal(app, store) {
+  if (store.folderType === 1 || store.identifier?.startsWith("TrashFolder-"))
+    return "Refusing to delete the Recently Deleted folder";
+  if (store.folderType === 2 || store.hasSmartQuery) return "Refusing to delete a smart folder";
+  if (store.folderType !== 0)
+    return `Refusing to delete a folder with unsupported folder type ${String(store.folderType)}`;
+  if (!store.identifier)
+    return "Refusing to delete a folder without a stable identifier (it cannot be verified)";
+  if (store.identifier.startsWith("DefaultFolder-") || app.defaultFolderId === app.id)
+    return "Refusing to delete a system or default folder";
+  if (app.shared || store.sharedRecord || store.sharedAncestor)
+    return "Refusing to delete a shared or collaborated folder";
+  return null;
+}
+function folderDeleteRevision(app, store) {
+  const state = [
+    app.id,
+    store.identifier,
+    app.name,
+    app.accountId,
+    app.parentId,
+    app.defaultFolderId === app.id,
+    app.shared,
+    app.childFolderCount,
+    app.noteCount,
+    store.folderType,
+    store.markedForDeletion,
+    store.hasSmartQuery,
+    store.sharedRecord,
+    store.sharedAncestor,
+    store.childFolderCount,
+    store.noteCount
+  ];
+  return `sha256:${createHash3("sha256").update(JSON.stringify(state)).digest("hex")}`;
+}
+function checkFolder(manager, args, deps) {
+  const app = manager.readFolderForDelete(args.id);
+  const store = deps.readStore(coreDataPk(args.id));
+  if (!store)
+    throw conflict(
+      "the folder is not in the local Notes store yet; wait for Notes to save it and plan again"
+    );
+  if (store.markedForDeletion) throw conflict("the folder is already deleted");
+  const expectedParentPk = app.parentId ? coreDataPk(app.parentId) : null;
+  if (store.accountPk !== coreDataPk(app.accountId) || store.parentPk !== expectedParentPk)
+    throw conflict(
+      "Notes.app and the local store disagree about this folder's location; wait a moment and plan again"
+    );
+  if (app.name !== args.expectedName) throw conflict("the folder name changed");
+  if (app.accountId !== args.expectedAccountId)
+    throw conflict("the folder is in a different account");
+  if (args.expectedRoot ? app.parentId !== null : app.parentId !== args.expectedParentId)
+    throw conflict("the folder's parent changed");
+  const refusal = folderDeleteRefusal(app, store);
+  if (refusal) throw refused(refusal);
+  let storeNotes = store.noteCount;
+  if (storeNotes > app.noteCount && store.noteKeys.length === storeNotes) {
+    const notePrefix = args.id.replace(/\/ICFolder\/p\d+$/, "/ICNote/p");
+    storeNotes -= manager.countNotesOutsideFolder(
+      args.id,
+      store.noteKeys.map((key) => `${notePrefix}${key}`)
+    );
+  }
+  const children = Math.max(app.childFolderCount, store.childFolderCount);
+  const notes = Math.max(app.noteCount, storeNotes);
+  if (children > 0 || notes > 0)
+    throw refused(
+      `the folder is not empty (${children} child folder(s), ${notes} note(s)); move or delete them first`
+    );
+  return {
+    app,
+    store,
+    identifier: store.identifier,
+    revision: folderDeleteRevision(app, { ...store, noteCount: storeNotes })
+  };
+}
+function runFolderDelete(manager, args, deps = defaultDeps) {
+  if (Boolean(args.expectedRoot) === (args.expectedParentId !== void 0))
+    throw invalid("Pass exactly one of expectedParentId or expectedRoot: true");
+  if (args.dryRun && args.expectedRevision)
+    throw invalid("expectedRevision belongs to the apply call (dryRun: false)");
+  if (!args.dryRun && !args.expectedRevision)
+    throw invalid("Apply requires expectedRevision from a matching dry run");
+  const checked = checkFolder(manager, args, deps);
+  const base = {
+    ok: true,
+    id: args.id,
+    identifier: checked.identifier,
+    name: checked.app.name,
+    accountId: checked.app.accountId,
+    parentId: checked.app.parentId,
+    folderType: 0,
+    childFolderCount: 0,
+    noteCount: 0,
+    revision: checked.revision
+  };
+  if (args.dryRun)
+    return { ...base, status: "planned", dryRun: true, committed: false, wouldDelete: true };
+  if (checked.revision !== args.expectedRevision)
+    throw conflict("the folder changed since the dry run; plan again");
+  const outcome = manager.deleteEmptyFolderIfUnchanged(args.id, {
+    name: checked.app.name,
+    parentId: checked.app.parentId,
+    accountId: checked.app.accountId
+  });
+  if (outcome.status === "conflict")
+    throw conflict(`the folder ${outcome.reason} changed before deletion; plan again`);
+  if (outcome.status === "refused") throw refused(outcome.reason);
+  if (outcome.status === "failed")
+    throw uncertain(
+      `The delete outcome is uncertain (${outcome.reason}); read folder ${args.id} before retrying`
+    );
+  if (manager.folderExistsById(args.id))
+    throw uncertain(
+      `The delete outcome is uncertain: Notes.app still resolves folder ${args.id}; read it before retrying`
+    );
+  let storeTombstoned = false;
+  for (let attempt = 0; attempt < 5 && !storeTombstoned; attempt++) {
+    if (attempt > 0) deps.sleep(200);
+    const after = deps.readStore(coreDataPk(args.id));
+    storeTombstoned = !after || after.markedForDeletion;
+  }
+  return {
+    ...base,
+    status: "deleted",
+    dryRun: false,
+    committed: true,
+    wouldDelete: true,
+    verified: true,
+    storeTombstoned
+  };
+}
+function registerFolderDelete(server2, manager, deps = defaultDeps) {
+  const inputSchema = {
+    id: folderIdSchema.describe(
+      "Exact folder id (x-coredata://\u2026/ICFolder/pN) from list-folders, or the folder's Notes UUID or numeric key"
+    ),
+    expectedName: external_exports.string().min(1).max(1e3).describe("Current folder name (not a path), matched case-sensitively"),
+    expectedAccountId: accountIdSchema.describe(
+      "Owning account id, from get-folder-by-id or list-accounts"
+    ),
+    expectedParentId: folderIdSchema.optional().describe("Current parent folder id; omit and pass expectedRoot for a top-level folder"),
+    expectedRoot: external_exports.literal(true).optional().describe("Pass true when the folder sits at the account root (no parent folder)"),
+    dryRun: external_exports.boolean().describe("true plans and returns a revision; false applies with expectedRevision"),
+    expectedRevision: revisionSchema.optional().describe("The revision returned by the dry run; required when dryRun is false")
+  };
+  server2.registerTool(
+    "delete-folder-by-id",
+    {
+      description: "Use when: deleting one exact, empty, ordinary folder by id, with a plan-then-apply handshake.\nReturns: a plan (status planned, wouldDelete, identity fields, zero counts, revision) or, on apply, status deleted with verified readback.\nDo not use when: the folder holds notes or subfolders, or you only have a name or path (delete-folder).\nSafety: requires the exact id plus expectedName, expectedAccountId, and expectedParentId or expectedRoot. Call with dryRun true, then repeat the same guards with dryRun false and expectedRevision. Always refuses Recently Deleted, smart folders, the account's default and other system folders, shared folders, and non-empty folders; there is no override. Not atomic: the guard is a pre-check followed by an AppleScript delete. The Notes.app-visible checks repeat inside the delete script, but folder type is read from the local store just before it. Needs Full Disk Access and fails closed without it.",
+      inputSchema,
+      outputSchema: external_exports.object({ ok: external_exports.boolean().optional() }).passthrough(),
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false }
+    },
+    (async (args) => {
+      try {
+        const result = runFolderDelete(manager, args, deps);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result) }],
+          structuredContent: result
+        };
+      } catch (error2) {
+        return errorResult(error2 instanceof Error ? error2.message : String(error2), error2);
+      }
+    })
+  );
+}
+
 // src/tools/nativeTagsBridge.ts
 var noteId2 = exactIdInput(
   "ICNote",
@@ -50825,15 +51354,15 @@ var shortcutFiles = [
 function setupShortcuts(checkOnly, dependencies = {}) {
   const status = dependencies.status || nativeTagsStatus;
   const exists = dependencies.exists || existsSync13;
-  const open = dependencies.open || ((path9) => {
-    const result = spawnSync2("/usr/bin/open", [path9], { encoding: "utf8" });
+  const open = dependencies.open || ((path10) => {
+    const result = spawnSync2("/usr/bin/open", [path10], { encoding: "utf8" });
     return result.status === 0 ? { ok: true } : { ok: false, error: result.stderr || result.error?.message || "open failed" };
   });
   const baseDirectory = dependencies.baseDirectory || resolve4(dirname5(fileURLToPath(import.meta.url)), "../shortcuts");
   const osRelease = (dependencies.osRelease || release2)();
   const darwinMajor = Number.parseInt(osRelease.split(".")[0], 10);
   const items = shortcutFiles.map(({ name, file, optional: optional2 }) => {
-    const path9 = resolve4(baseDirectory, file);
+    const path10 = resolve4(baseDirectory, file);
     let installed = false;
     let identifier;
     let error2;
@@ -50849,9 +51378,9 @@ function setupShortcuts(checkOnly, dependencies = {}) {
     if (!installed && !checkOnly) {
       if (optional2 && !(darwinMajor >= MARKDOWN_MIN_DARWIN_MAJOR))
         skipped = `requires macOS 26 or later (this Mac reports Darwin ${osRelease})`;
-      else if (!exists(path9)) error2 = `Packaged Shortcut is missing: ${path9}`;
+      else if (!exists(path10)) error2 = `Packaged Shortcut is missing: ${path10}`;
       else {
-        const result = open(path9);
+        const result = open(path10);
         opened = result.ok;
         if (!result.ok) error2 = result.error || `Could not open ${file}`;
       }
@@ -50860,7 +51389,7 @@ function setupShortcuts(checkOnly, dependencies = {}) {
       name,
       installed,
       identifier,
-      file: path9,
+      file: path10,
       opened,
       ...optional2 ? { optional: optional2 } : {},
       ...skipped ? { skipped } : {},
@@ -50907,6 +51436,7 @@ var server = new McpServer({
 });
 var notesManager = new AppleNotesManager();
 registerDirectOperations(server, notesManager);
+registerFolderDelete(server, notesManager);
 registerNativeTagsBridge(server, notesManager);
 registerNativeOperations(server, notesManager);
 function successResponse(message, structured) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apple-notes-mcp",
-  "version": "2.8.44",
+  "version": "2.8.46",
   "description": "MCP server for Apple Notes - create, search, update, and manage notes via Claude and other AI assistants",
   "type": "module",
   "main": "build/index.js",