apple-notes-mcp 2.12.0 → 2.14.0

package/build/index.js

@@ -417,11 +417,11 @@ var require_codegen = __commonJS({
         const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
         return `${varKind} ${this.name}${rhs};` + _n;
       }
-      optimizeNames(names, constants9) {
+      optimizeNames(names, constants10) {
         if (!names[this.name.str])
           return;
         if (this.rhs)
-          this.rhs = optimizeExpr(this.rhs, names, constants9);
+          this.rhs = optimizeExpr(this.rhs, names, constants10);
         return this;
       }
       get names() {
@@ -438,10 +438,10 @@ var require_codegen = __commonJS({
       render({ _n }) {
         return `${this.lhs} = ${this.rhs};` + _n;
       }
-      optimizeNames(names, constants9) {
+      optimizeNames(names, constants10) {
         if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
           return;
-        this.rhs = optimizeExpr(this.rhs, names, constants9);
+        this.rhs = optimizeExpr(this.rhs, names, constants10);
         return this;
       }
       get names() {
@@ -502,8 +502,8 @@ var require_codegen = __commonJS({
       optimizeNodes() {
         return `${this.code}` ? this : void 0;
       }
-      optimizeNames(names, constants9) {
-        this.code = optimizeExpr(this.code, names, constants9);
+      optimizeNames(names, constants10) {
+        this.code = optimizeExpr(this.code, names, constants10);
         return this;
       }
       get names() {
@@ -532,12 +532,12 @@ var require_codegen = __commonJS({
         }
         return nodes.length > 0 ? this : void 0;
       }
-      optimizeNames(names, constants9) {
+      optimizeNames(names, constants10) {
         const { nodes } = this;
         let i = nodes.length;
         while (i--) {
           const n = nodes[i];
-          if (n.optimizeNames(names, constants9))
+          if (n.optimizeNames(names, constants10))
             continue;
           subtractNames(names, n.names);
           nodes.splice(i, 1);
@@ -590,12 +590,12 @@ var require_codegen = __commonJS({
           return void 0;
         return this;
       }
-      optimizeNames(names, constants9) {
+      optimizeNames(names, constants10) {
         var _a;
-        this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants9);
-        if (!(super.optimizeNames(names, constants9) || this.else))
+        this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants10);
+        if (!(super.optimizeNames(names, constants10) || this.else))
           return;
-        this.condition = optimizeExpr(this.condition, names, constants9);
+        this.condition = optimizeExpr(this.condition, names, constants10);
         return this;
       }
       get names() {
@@ -618,10 +618,10 @@ var require_codegen = __commonJS({
       render(opts) {
         return `for(${this.iteration})` + super.render(opts);
       }
-      optimizeNames(names, constants9) {
-        if (!super.optimizeNames(names, constants9))
+      optimizeNames(names, constants10) {
+        if (!super.optimizeNames(names, constants10))
           return;
-        this.iteration = optimizeExpr(this.iteration, names, constants9);
+        this.iteration = optimizeExpr(this.iteration, names, constants10);
         return this;
       }
       get names() {
@@ -657,10 +657,10 @@ var require_codegen = __commonJS({
       render(opts) {
         return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
       }
-      optimizeNames(names, constants9) {
-        if (!super.optimizeNames(names, constants9))
+      optimizeNames(names, constants10) {
+        if (!super.optimizeNames(names, constants10))
           return;
-        this.iterable = optimizeExpr(this.iterable, names, constants9);
+        this.iterable = optimizeExpr(this.iterable, names, constants10);
         return this;
       }
       get names() {
@@ -702,11 +702,11 @@ var require_codegen = __commonJS({
         (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes();
         return this;
       }
-      optimizeNames(names, constants9) {
+      optimizeNames(names, constants10) {
         var _a, _b;
-        super.optimizeNames(names, constants9);
-        (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants9);
-        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants9);
+        super.optimizeNames(names, constants10);
+        (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants10);
+        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants10);
         return this;
       }
       get names() {
@@ -1007,7 +1007,7 @@ var require_codegen = __commonJS({
     function addExprNames(names, from) {
       return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
     }
-    function optimizeExpr(expr, names, constants9) {
+    function optimizeExpr(expr, names, constants10) {
       if (expr instanceof code_1.Name)
         return replaceName(expr);
       if (!canOptimize(expr))
@@ -1022,14 +1022,14 @@ var require_codegen = __commonJS({
         return items;
       }, []));
       function replaceName(n) {
-        const c = constants9[n.str];
+        const c = constants10[n.str];
         if (c === void 0 || names[n.str] !== 1)
           return n;
         delete names[n.str];
         return c;
       }
       function canOptimize(e) {
-        return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants9[c.str] !== void 0);
+        return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants10[c.str] !== void 0);
       }
     }
     function subtractNames(names, from) {
@@ -2991,7 +2991,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve9.call(this, root, ref);
+      let _sch = resolve10.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -3018,7 +3018,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve9(root, ref) {
+    function resolve10(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3848,7 +3848,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve9(baseURI, relativeURI, options) {
+    function resolve10(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const {
         parsed: baseParsed,
@@ -4217,7 +4217,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve9,
+      resolve: resolve10,
       resolveComponent,
       equal,
       serialize,
@@ -7434,7 +7434,7 @@ var require_DOMException = __commonJS({
       "INVALID_NODE_TYPE_ERR (24): the supplied node is invalid or has an invalid ancestor for this operation",
       "DATA_CLONE_ERR (25): the object can not be cloned."
     ];
-    var constants9 = {
+    var constants10 = {
       INDEX_SIZE_ERR,
       DOMSTRING_SIZE_ERR: 2,
       // historical
@@ -7473,8 +7473,8 @@ var require_DOMException = __commonJS({
       this.name = names[code];
     }
     DOMException.prototype.__proto__ = Error.prototype;
-    for (c in constants9) {
-      v = { value: constants9[c] };
+    for (c in constants10) {
+      v = { value: constants10[c] };
       Object.defineProperty(DOMException, c, v);
       Object.defineProperty(DOMException.prototype, c, v);
     }
@@ -24477,14 +24477,14 @@ var require_turndown_cjs = __commonJS({
         } else if (node.nodeType === 1) {
           replacement = replacementForNode.call(self, node);
         }
-        return join32(output, replacement);
+        return join33(output, replacement);
       }, "");
     }
     function postProcess(output) {
       var self = this;
       this.rules.forEach(function(rule) {
         if (typeof rule.append === "function") {
-          output = join32(output, rule.append(self.options));
+          output = join33(output, rule.append(self.options));
         }
       });
       return output.replace(/^[\t\r\n]+/, "").replace(/[\t\r\n\s]+$/, "");
@@ -24496,7 +24496,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 join32(output, replacement) {
+    function join33(output, replacement) {
       var s1 = trimTrailingNewlines(output);
       var s2 = trimLeadingNewlines(replacement);
       var nls = Math.max(output.length - s1.length, replacement.length - s2.length);
@@ -36620,7 +36620,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve9) => setTimeout(resolve9, pollInterval));
+        await new Promise((resolve10) => setTimeout(resolve10, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -36637,7 +36637,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -36715,7 +36715,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve9(parseResult.data);
+            resolve10(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -36976,12 +36976,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve9, interval);
+      const timeoutId = setTimeout(resolve10, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -38294,7 +38294,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve9) => setTimeout(resolve9, pollInterval));
+      await new Promise((resolve10) => setTimeout(resolve10, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -38982,12 +38982,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       const json2 = serializeMessage(message);
       if (this._stdout.write(json2)) {
-        resolve9();
+        resolve10();
       } else {
-        this._stdout.once("drain", resolve9);
+        this._stdout.once("drain", resolve10);
       }
     });
   }
@@ -47866,13 +47866,13 @@ var escapeSegment = escapeFolderName;
 function resolveFolders(rows) {
   const byPk = new Map(rows.map((row) => [row.pk, row]));
   const resolved = /* @__PURE__ */ new Map();
-  const resolve9 = (pk, seen) => {
+  const resolve10 = (pk, seen) => {
     const cached2 = resolved.get(pk);
     if (cached2) return cached2;
     const row = byPk.get(pk);
     if (!row || seen.has(pk)) return void 0;
     seen.add(pk);
-    const parent = row.parent !== null ? resolve9(row.parent, seen) : void 0;
+    const parent = row.parent !== null ? resolve10(row.parent, seen) : void 0;
     const name = row.name ?? "";
     const path10 = parent ? `${parent.path}/${escapeSegment(name)}` : escapeSegment(name);
     const plainPath = parent ? `${parent.plainPath}/${name}` : name;
@@ -47886,7 +47886,7 @@ function resolveFolders(rows) {
     resolved.set(pk, info);
     return info;
   };
-  for (const row of rows) resolve9(row.pk, /* @__PURE__ */ new Set());
+  for (const row of rows) resolve10(row.pk, /* @__PURE__ */ new Set());
   return resolved;
 }
 var coreDataMs = (seconds) => seconds === null || !Number.isFinite(seconds) ? void 0 : CORE_DATA_EPOCH_MS2 + seconds * 1e3;
@@ -52889,16 +52889,16 @@ var NOTE_PLACEHOLDERS = [
   "exportStem"
 ];
 var PLACEHOLDER_MODIFIERS = ["raw", "yaml"];
-var wrap2 = (before, after = "", join32) => ({
+var wrap2 = (before, after = "", join33) => ({
   mode: "wrap",
   before,
   after,
-  ...join32 ? { join: join32 } : {}
+  ...join33 ? { join: join33 } : {}
 });
-var pattern = (value, join32) => ({
+var pattern = (value, join33) => ({
   mode: "pattern",
   value,
-  ...join32 ? { join: join32 } : {}
+  ...join33 ? { join: join33 } : {}
 });
 var STANDARD = {
   schemaVersion: 1,
@@ -56826,7 +56826,7 @@ function parseXml(source, limits) {
       (own ??= /* @__PURE__ */ new Map()).set(prefix, a.value);
     }
     const scope2 = own ? { own, parent: parentScope } : parentScope ?? { own: null, parent: null };
-    const resolve9 = (qualified, isAttribute) => {
+    const resolve10 = (qualified, isAttribute) => {
       const colon = qualified.indexOf(":");
       if (colon < 0)
         return {
@@ -56840,12 +56840,12 @@ function parseXml(source, limits) {
       if (ns === void 0) fail(`Undeclared namespace prefix "${prefix.slice(0, 40)}"`);
       return { local, ns };
     };
-    const resolved = resolve9(name, false);
+    const resolved = resolve10(name, false);
     const element = {
       name,
       local: resolved.local,
       ns: resolved.ns,
-      attributes: rawAttributes.filter((a) => a.name !== "xmlns" && !a.name.startsWith("xmlns:")).map((a) => ({ name: a.name, value: a.value, ...resolve9(a.name, true) })),
+      attributes: rawAttributes.filter((a) => a.name !== "xmlns" && !a.name.startsWith("xmlns:")).map((a) => ({ name: a.name, value: a.value, ...resolve10(a.name, true) })),
       children: [],
       text: "",
       line: tagLine
@@ -60219,6 +60219,1494 @@ function registerPrivateHelperTools(server2, manager, depsFactory = () => defaul
   );
 }
 
+// src/utils/localServer.ts
+import { randomBytes as randomBytes3, timingSafeEqual } from "node:crypto";
+import { networkInterfaces } from "node:os";
+function isTailnetIPv4(address) {
+  const match = /^100\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(address);
+  if (!match) return false;
+  const [second, third, fourth] = match.slice(1).map(Number);
+  return second >= 64 && second <= 127 && third <= 255 && fourth <= 255;
+}
+function findTailnetAddress(interfaces = networkInterfaces()) {
+  const candidates = [];
+  for (const [name, infos] of Object.entries(interfaces)) {
+    for (const info of infos ?? []) {
+      if (info.family === "IPv4" && !info.internal && isTailnetIPv4(info.address))
+        candidates.push({ address: info.address, interface: name });
+    }
+  }
+  return candidates.find((c) => c.interface.startsWith("utun")) ?? candidates[0];
+}
+function newServerToken() {
+  return randomBytes3(32).toString("hex");
+}
+function bearerToken(req) {
+  const auth = req.headers.authorization;
+  return auth?.startsWith("Bearer ") ? auth.slice(7) : void 0;
+}
+function tokenMatches(given, token) {
+  if (!given) return false;
+  const a = Buffer.from(given, "utf8");
+  const b = Buffer.from(token, "utf8");
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+function hostAuthority(host, port) {
+  return host.includes(":") ? `[${host}]:${port}` : `${host}:${port}`;
+}
+function crossOriginRefusal(req, origin, requireOrigin = false) {
+  const site = req.headers["sec-fetch-site"];
+  if (site && site !== "same-origin" && site !== "none") return "cross-site";
+  const requestOrigin = req.headers.origin;
+  if (requestOrigin !== void 0 && requestOrigin !== origin) return "foreign-origin";
+  if (requireOrigin && requestOrigin !== origin) return "missing-origin";
+  return void 0;
+}
+
+// src/services/templateEditor.ts
+import { randomBytes as randomBytes4 } from "node:crypto";
+import { createServer } from "node:http";
+
+// src/utils/templateSamples.ts
+function sampleBlock(text2, style = "body", extra = {}, runs = [{ text: text2 }]) {
+  return {
+    index: 0,
+    start: 0,
+    length: runs.reduce((sum, run) => sum + run.text.length, 0),
+    text: runs.map((run) => run.text).join(""),
+    style,
+    styleType: null,
+    indent: 0,
+    alignment: "left",
+    blockQuote: false,
+    ...extra,
+    runs: runs.map((run) => ({ start: 0, length: run.text.length, ...run })),
+    attachments: []
+  };
+}
+var sampleAttachmentRun = (id2, uti) => ({
+  text: "\uFFFC",
+  attachment: { id: id2, uti }
+});
+function sampleAttachment(id2, uti, extra = {}) {
+  return { id: id2, pk: 0, uti, kind: classifyUti(uti), children: [], ...extra };
+}
+function sampleNote(pk, blocks, attachments = []) {
+  let offset = 0;
+  const indexed = blocks.map((b, index) => {
+    const start = offset;
+    offset += b.length + 1;
+    let at = start;
+    const runs = b.runs.map((run) => {
+      const shifted = { ...run, start: at };
+      at += run.length;
+      return shifted;
+    });
+    const markers2 = runs.flatMap(
+      (run) => run.attachment ? [{ ...run.attachment, start: run.start, blockIndex: index }] : []
+    );
+    return { ...b, index, start, runs, attachments: markers2 };
+  });
+  const markers = indexed.flatMap((b) => b.attachments);
+  return {
+    id: `x-coredata://SAMPLE/ICNote/p${pk}`,
+    title: indexed[0]?.text ?? "",
+    doc: {
+      text: indexed.map((b) => b.text).join("\n"),
+      textLength: offset,
+      blocks: indexed,
+      attachments: markers,
+      undecodedFields: { attributeRun: {}, paragraphStyle: {} },
+      summary: summarize(indexed, markers)
+    },
+    attachments: new Map(attachments.map((a) => [a.id, a])),
+    ordered: attachments.map((a, i) => ({ ...a, pk: i + 1 }))
+  };
+}
+function sampleMeta(uuid2) {
+  return {
+    uuid: uuid2,
+    created: "2026-01-05T14:30:00.000Z",
+    modified: "2026-02-10T09:15:00.000Z",
+    folder: "Sample Folder",
+    account: "iCloud"
+  };
+}
+function templateSamples() {
+  return [
+    {
+      id: "structure",
+      label: "Headings, lists and checklists",
+      meta: sampleMeta("00000000-0000-4000-8000-000000000001"),
+      note: sampleNote(1, [
+        sampleBlock("Weekly Plan", "title"),
+        sampleBlock("Goals", "heading"),
+        sampleBlock("Details", "subheading"),
+        sampleBlock("A plain paragraph with *characters* that need escaping."),
+        sampleBlock("First step", "numbered"),
+        sampleBlock("Second step", "numbered"),
+        sampleBlock("Nested step", "numbered", { indent: 1 }),
+        sampleBlock("A bullet", "bulleted"),
+        sampleBlock("A dash", "dashed"),
+        sampleBlock("Nested bullet", "bulleted", { indent: 1 }),
+        sampleBlock("Done task", "checklist", { checklist: { id: "sample-a", done: true } }),
+        sampleBlock("Open task", "checklist", { checklist: { id: "sample-b", done: false } }),
+        sampleBlock("A quoted line", "body", { blockQuote: true }),
+        sampleBlock("const answer = 42;", "monospaced"),
+        sampleBlock('console.log("sample");', "monospaced")
+      ])
+    },
+    {
+      id: "inline",
+      label: "Inline formatting and links",
+      meta: sampleMeta("00000000-0000-4000-8000-000000000002"),
+      note: sampleNote(2, [
+        sampleBlock("Formatting Sample", "title"),
+        sampleBlock("", "body", {}, [
+          { text: "Bold", bold: true },
+          { text: ", " },
+          { text: "italic", italic: true },
+          { text: ", " },
+          { text: "both", bold: true, italic: true },
+          { text: ", " },
+          { text: "struck", strikethrough: true },
+          { text: ", " },
+          { text: "underlined", underline: true },
+          { text: "." }
+        ]),
+        sampleBlock("", "body", {}, [
+          { text: "Highlighted", highlight: "purple" },
+          { text: ", x" },
+          { text: "2", superscript: true },
+          { text: ", H" },
+          { text: "2", subscript: true },
+          { text: "O, and " },
+          { text: "red text", color: "#FF3B30" },
+          { text: "." }
+        ]),
+        sampleBlock("", "body", {}, [
+          { text: "A " },
+          { text: "web link", link: "https://example.com/page", linkSafe: true },
+          { text: " and a " },
+          { text: "bold link", link: "https://example.com/bold", linkSafe: true, bold: true },
+          { text: "." }
+        ])
+      ])
+    },
+    {
+      id: "attachments",
+      label: "Attachments and tags",
+      meta: sampleMeta("00000000-0000-4000-8000-000000000003"),
+      note: sampleNote(
+        3,
+        [
+          sampleBlock("Trip Notes", "title"),
+          sampleBlock("", "body", {}, [
+            { text: "Tagged " },
+            sampleAttachmentRun("SAMPLE-TAG", "com.apple.notes.inlinetextattachment.hashtag"),
+            { text: " for later." }
+          ]),
+          sampleBlock("", "body", {}, [sampleAttachmentRun("SAMPLE-IMG", "public.jpeg")]),
+          sampleBlock("", "body", {}, [sampleAttachmentRun("SAMPLE-PDF", "com.adobe.pdf")]),
+          sampleBlock("", "body", {}, [
+            sampleAttachmentRun("SAMPLE-DIV", "com.apple.notes.inlinetextattachment.dividerline")
+          ]),
+          sampleBlock("", "body", {}, [sampleAttachmentRun("SAMPLE-URL", "public.url")]),
+          sampleBlock("", "body", {}, [sampleAttachmentRun("SAMPLE-IMGURL", "public.url")])
+        ],
+        [
+          sampleAttachment("SAMPLE-TAG", "com.apple.notes.inlinetextattachment.hashtag", {
+            altText: "#travel"
+          }),
+          sampleAttachment("SAMPLE-IMG", "public.jpeg", { title: "harbor.jpg" }),
+          sampleAttachment("SAMPLE-PDF", "com.adobe.pdf", { title: "itinerary.pdf" }),
+          sampleAttachment("SAMPLE-DIV", "com.apple.notes.inlinetextattachment.dividerline"),
+          sampleAttachment("SAMPLE-URL", "public.url", {
+            title: "Example Domain",
+            url: "https://example.com/"
+          }),
+          sampleAttachment("SAMPLE-IMGURL", "public.url", {
+            title: "Harbor at dusk",
+            url: "https://example.com/photos/harbor.jpg"
+          })
+        ]
+      )
+    }
+  ];
+}
+
+// src/services/templateEditorPage.ts
+var EDITOR_STYLE = `
+:root { color-scheme: light dark; --bg: #fafafa; --fg: #1d1d1f; --muted: #6e6e73;
+  --panel: #ffffff; --border: #d2d2d7; --accent: #0a66d8; --bad: #c1272d; --ok: #1f7a3a; }
+@media (prefers-color-scheme: dark) { :root { --bg: #1c1c1e; --fg: #f2f2f7; --muted: #a1a1a6;
+  --panel: #2c2c2e; --border: #3a3a3c; --accent: #4c9bff; --bad: #ff6b6b; --ok: #4cd07d; } }
+* { box-sizing: border-box; }
+body { margin: 0; font: 14px/1.4 -apple-system, BlinkMacSystemFont, "Helvetica Neue", sans-serif;
+  background: var(--bg); color: var(--fg); }
+header { display: flex; flex-wrap: wrap; gap: 8px 16px; align-items: center; padding: 10px 16px;
+  border-bottom: 1px solid var(--border); background: var(--panel); }
+header h1 { font-size: 15px; margin: 0 12px 0 0; }
+label { display: inline-flex; gap: 6px; align-items: center; color: var(--muted); }
+select, input, button, textarea { font: inherit; color: var(--fg); background: var(--bg);
+  border: 1px solid var(--border); border-radius: 6px; padding: 4px 8px; }
+button { background: var(--accent); color: #fff; border-color: var(--accent); cursor: pointer; }
+main { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; padding: 12px 16px;
+  height: calc(100vh - 110px); min-height: 360px; }
+@media (max-width: 800px) { main { grid-template-columns: 1fr; height: auto; } }
+section { display: flex; flex-direction: column; min-height: 0; min-width: 0; }
+h2 { font-size: 13px; margin: 0 0 6px; color: var(--muted); font-weight: 600; }
+textarea { flex: 1; min-height: 300px; width: 100%; resize: none;
+  font: 12px/1.45 ui-monospace, SFMono-Regular, Menlo, monospace; }
+pre { flex: 1; margin: 0; overflow: auto; padding: 8px; background: var(--panel);
+  border: 1px solid var(--border); border-radius: 6px; min-height: 300px;
+  font: 12px/1.45 ui-monospace, SFMono-Regular, Menlo, monospace; white-space: pre-wrap; }
+ul { margin: 6px 0 0; padding-left: 18px; max-height: 120px; overflow: auto; }
+.bad { color: var(--bad); } .ok { color: var(--ok); } .muted { color: var(--muted); }
+footer { padding: 0 16px 12px; }
+`;
+var EDITOR_SCRIPT = `
+"use strict";
+const token = new URLSearchParams(location.search).get("token") || "";
+const $ = (id) => document.getElementById(id);
+const api = async (path, body) => {
+  const res = await fetch(path, body === undefined
+    ? { headers: { Authorization: "Bearer " + token } }
+    : { method: "POST", headers: { Authorization: "Bearer " + token,
+        "Content-Type": "application/json" }, body: JSON.stringify(body) });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) { const e = new Error((data.error && data.error.message) || res.statusText);
+    e.detail = data.error; throw e; }
+  return data;
+};
+const setText = (id, text, cls) => { const el = $(id); el.textContent = text;
+  el.className = cls || ""; };
+const list = (id, items) => { const ul = $(id); ul.replaceChildren();
+  for (const item of items) { const li = document.createElement("li");
+    li.textContent = item; ul.append(li); } };
+let timer;
+async function refresh() {
+  try {
+    const out = await api("/api/preview", { template: $("json").value, sample: $("sample").value });
+    if (out.valid) setText("status", "Valid template.", "ok");
+    else setText("status", out.errors.length + " problem(s):", "bad");
+    list("errors", out.errors.map((e) => e.path + ": " + e.message));
+    list("warnings", out.warnings.map((w) => w.code + (w.attachmentId ? " (" + w.attachmentId + ")" : "")));
+    $("preview").textContent = out.valid ? out.markdown : "";
+  } catch (e) { setText("status", "Preview failed: " + e.message, "bad"); }
+}
+const schedule = () => { clearTimeout(timer); timer = setTimeout(refresh, 250); };
+async function load(name) {
+  try {
+    const out = await api("/api/template?name=" + encodeURIComponent(name));
+    $("json").value = JSON.stringify(out.template, null, 2) + "\\n";
+    $("name").value = out.source === "saved" ? out.name : "";
+    refresh();
+  } catch (e) { setText("status", "Could not open " + name + ": " + e.message, "bad"); }
+}
+async function save() {
+  try {
+    const out = await api("/api/save", { name: $("name").value.trim(),
+      template: $("json").value, force: $("force").checked });
+    setText("saved", (out.replaced ? "Replaced " : "Saved ") + out.name + " at " + out.path, "ok");
+    $("force").checked = false;
+    await fillPicker(out.name);
+  } catch (e) {
+    const errors = (e.detail && e.detail.errors) || [];
+    setText("saved", e.message + (errors.length ? " " + errors.map((x) => x.path + ": " + x.message).join("; ") : ""), "bad");
+  }
+}
+async function fillPicker(selected) {
+  const state = await api("/api/state");
+  const picker = $("picker"); picker.replaceChildren();
+  const group = (label, names) => { const g = document.createElement("optgroup");
+    g.label = label; for (const n of names) { const o = document.createElement("option");
+      o.value = n; o.textContent = n; g.append(o); } picker.append(g); };
+  group("Built-in", state.builtins);
+  if (state.saved.length) group("Saved", state.saved);
+  picker.value = selected;
+  setText("dir", "Library: " + state.dir, "muted");
+  return state;
+}
+(async () => {
+  try {
+    const state = await fillPicker("");
+    const sample = $("sample");
+    for (const s of state.samples) { const o = document.createElement("option");
+      o.value = s.id; o.textContent = s.label; sample.append(o); }
+    $("picker").value = state.initial.name;
+    $("json").value = JSON.stringify(state.initial.template, null, 2) + "\\n";
+    $("name").value = state.initial.source === "saved" ? state.initial.name : "";
+    $("json").addEventListener("input", schedule);
+    sample.addEventListener("change", refresh);
+    $("picker").addEventListener("change", () => load($("picker").value));
+    $("save").addEventListener("click", save);
+    refresh();
+  } catch (e) { setText("status", "Could not start: " + e.message, "bad"); }
+})();
+`;
+var EDITOR_BODY = `
+<header>
+  <h1>Markdown template editor</h1>
+  <label>Open <select id="picker"></select></label>
+  <label>Preview <select id="sample"></select></label>
+  <span id="dir" class="muted"></span>
+</header>
+<main>
+  <section>
+    <h2>Template JSON</h2>
+    <textarea id="json" spellcheck="false" aria-label="Template JSON"></textarea>
+    <div id="status" role="status"></div>
+    <ul id="errors" class="bad"></ul>
+  </section>
+  <section>
+    <h2>Markdown preview</h2>
+    <pre id="preview" aria-label="Markdown preview"></pre>
+    <ul id="warnings" class="muted" aria-label="Warnings"></ul>
+  </section>
+</main>
+<footer>
+  <label>Save as <input id="name" placeholder="my-template" maxlength="64" autocomplete="off"></label>
+  <label><input id="force" type="checkbox"> Replace an existing template</label>
+  <button id="save" type="button">Save</button>
+  <span id="saved" role="status"></span>
+</footer>
+`;
+function templateEditorPage(nonce) {
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><meta name="referrer" content="no-referrer"><title>Template Editor</title><style nonce="${nonce}">${EDITOR_STYLE}</style></head><body>${EDITOR_BODY}<script nonce="${nonce}">${EDITOR_SCRIPT}</script></body></html>`;
+}
+
+// src/services/templateEditor.ts
+var DEFAULT_EDITOR_IDLE_MS = 30 * 60 * 1e3;
+var MAX_EDITOR_BODY_BYTES = MAX_TEMPLATE_BYTES * 2 + 4096;
+var EditorHttpError = class extends Error {
+  constructor(status, code, message, errors) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.errors = errors;
+  }
+  status;
+  code;
+  errors;
+};
+function editorPresentedToken(req, url) {
+  return bearerToken(req)?.trim() ?? url.searchParams.get("token") ?? void 0;
+}
+var CROSS_ORIGIN_MESSAGE = {
+  "cross-site": "Cross-site requests are refused.",
+  "foreign-origin": "Cross-origin requests are refused.",
+  "missing-origin": "POST requires the editor's own Origin."
+};
+async function readEditorJson(req) {
+  const type = req.headers["content-type"] ?? "";
+  if (!/^application\/json(?:\s*;|$)/i.test(type))
+    throw new EditorHttpError(415, "unsupported-media-type", "Send JSON (application/json).");
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > MAX_EDITOR_BODY_BYTES)
+      throw new EditorHttpError(413, "too-large", "Request body too large.");
+    chunks.push(chunk);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw new EditorHttpError(400, "bad-request", "Request body is not valid JSON.");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    throw new EditorHttpError(400, "bad-request", "Request body must be a JSON object.");
+  return parsed;
+}
+var editorStringField = (body, key) => {
+  const value = body[key];
+  if (typeof value !== "string")
+    throw new EditorHttpError(400, "bad-request", `"${key}" must be a string.`);
+  return value;
+};
+async function startTemplateEditor(options = {}) {
+  const host = options.host ?? "127.0.0.1";
+  const idleMs = options.idleMs ?? DEFAULT_EDITOR_IDLE_MS;
+  const store = options.store ?? new TemplateStore();
+  const token = options.token ?? newServerToken();
+  const samples = templateSamples();
+  const initialName = options.name ?? "standard-markdown";
+  const initial = isBuiltinTemplate(initialName) ? builtinTemplate(initialName) : store.get(initialName);
+  const initialSource = isBuiltinTemplate(initialName) ? "builtin" : "saved";
+  let origin = "";
+  let hostHeader = "";
+  let idleTimer;
+  let closeReason = "closed";
+  const sockets = /* @__PURE__ */ new Set();
+  const loadTemplate = (name) => {
+    if (isBuiltinTemplate(name))
+      return { name, source: "builtin", template: builtinTemplate(name) };
+    return { name, source: "saved", template: store.get(name) };
+  };
+  const state = () => {
+    const listing = store.list();
+    return {
+      builtins: BUILTIN_TEMPLATE_NAMES,
+      saved: listing.templates.map((t) => t.name),
+      dir: listing.dir,
+      samples: [
+        ...samples.map((s) => ({ id: s.id, label: s.label })),
+        ...options.note ? [{ id: "note", label: `Note: ${options.note.note.title}` }] : []
+      ],
+      initial: { name: initialName, source: initialSource, template: initial }
+    };
+  };
+  const preview = (body) => {
+    const text2 = editorStringField(body, "template");
+    const sampleId = typeof body.sample === "string" ? body.sample : samples[0].id;
+    const source = sampleId === "note" && options.note ? options.note : samples.find((s) => s.id === sampleId);
+    if (!source) throw new EditorHttpError(400, "bad-request", `Unknown sample "${sampleId}".`);
+    let portable;
+    try {
+      portable = parseTemplate(text2);
+    } catch (error2) {
+      if (error2 instanceof TemplateValidationError)
+        return { valid: false, errors: error2.errors, markdown: "", warnings: [] };
+      throw error2;
+    }
+    const result = renderNotesWithTemplate(
+      [source.note],
+      { stats: emptyStats() },
+      {
+        template: resolveTemplate(portable),
+        exportStem: "preview",
+        metaFor: () => source.meta
+      }
+    );
+    return { valid: true, errors: [], markdown: result.markdown, warnings: result.warnings };
+  };
+  const save = (body) => {
+    const name = editorStringField(body, "name");
+    const text2 = editorStringField(body, "template");
+    const force = body.force === true;
+    try {
+      const saved = store.save(name, text2, { force });
+      return { name, path: saved.path, bytes: saved.bytes, replaced: saved.replaced };
+    } catch (error2) {
+      if (error2 instanceof TemplateValidationError)
+        throw new EditorHttpError(
+          422,
+          "invalid-template",
+          "The template is invalid.",
+          error2.errors
+        );
+      if (error2 instanceof TemplateStoreError && error2.code === "template-exists")
+        throw new EditorHttpError(
+          409,
+          error2.code,
+          `A template named "${name}" already exists. Tick "Replace an existing template" to replace it.`
+        );
+      if (error2 instanceof TemplateStoreError)
+        throw new EditorHttpError(400, error2.code, error2.message);
+      throw error2;
+    }
+  };
+  const send = (res, status, type, body, extra = {}) => {
+    res.writeHead(status, {
+      "Content-Type": type,
+      "Cache-Control": "no-store",
+      "Referrer-Policy": "no-referrer",
+      "X-Content-Type-Options": "nosniff",
+      "X-Frame-Options": "DENY",
+      "Cross-Origin-Resource-Policy": "same-origin",
+      "Cross-Origin-Opener-Policy": "same-origin",
+      ...extra
+    });
+    res.end(body);
+  };
+  const sendJson = (res, status, value) => send(res, status, "application/json; charset=utf-8", JSON.stringify(value));
+  const touch = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    if (idleMs > 0)
+      idleTimer = setTimeout(() => {
+        closeReason = "idle";
+        void close();
+      }, idleMs);
+  };
+  const handle = async (req, res) => {
+    if (req.headers.host !== hostHeader)
+      throw new EditorHttpError(421, "wrong-host", "Unexpected Host header.");
+    const url = new URL(req.url ?? "/", origin);
+    if (!tokenMatches(editorPresentedToken(req, url), token))
+      throw new EditorHttpError(401, "unauthorized", "Missing or wrong token.");
+    const refusal = crossOriginRefusal(req, origin, req.method === "POST");
+    if (refusal) throw new EditorHttpError(403, "cross-origin", CROSS_ORIGIN_MESSAGE[refusal]);
+    touch();
+    const route = `${req.method} ${url.pathname}`;
+    switch (route) {
+      case "GET /": {
+        const nonce = randomBytes4(16).toString("base64");
+        return send(res, 200, "text/html; charset=utf-8", templateEditorPage(nonce), {
+          "Content-Security-Policy": `default-src 'none'; script-src 'nonce-${nonce}'; style-src 'nonce-${nonce}'; connect-src 'self'; img-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'`
+        });
+      }
+      case "GET /api/state":
+        return sendJson(res, 200, state());
+      case "GET /api/template": {
+        const name = url.searchParams.get("name") ?? "";
+        try {
+          return sendJson(res, 200, loadTemplate(name));
+        } catch (error2) {
+          if (error2 instanceof TemplateStoreError)
+            throw new EditorHttpError(404, error2.code, error2.message);
+          if (error2 instanceof TemplateValidationError)
+            throw new EditorHttpError(
+              422,
+              "invalid-template",
+              "The saved template is invalid.",
+              error2.errors
+            );
+          throw error2;
+        }
+      }
+      case "POST /api/preview":
+        return sendJson(res, 200, preview(await readEditorJson(req)));
+      case "POST /api/save":
+        return sendJson(res, 200, save(await readEditorJson(req)));
+      default:
+        throw new EditorHttpError(404, "not-found", "Not found.");
+    }
+  };
+  const server2 = createServer((req, res) => {
+    handle(req, res).catch((error2) => {
+      const http = error2 instanceof EditorHttpError ? error2 : new EditorHttpError(
+        500,
+        "internal-error",
+        "The editor could not complete the request."
+      );
+      if (!res.headersSent)
+        sendJson(res, http.status, {
+          error: {
+            code: http.code,
+            message: http.message,
+            ...http.errors ? { errors: http.errors } : {}
+          }
+        });
+      else res.end();
+    });
+  });
+  server2.on("connection", (socket) => {
+    sockets.add(socket);
+    socket.on("close", () => sockets.delete(socket));
+  });
+  let resolveClosed;
+  const closed = new Promise((resolve10) => resolveClosed = resolve10);
+  let closing;
+  const close = () => {
+    closing ??= new Promise((resolve10) => {
+      if (idleTimer) clearTimeout(idleTimer);
+      server2.close(() => {
+        resolveClosed(closeReason);
+        resolve10();
+      });
+      for (const socket of sockets) socket.destroy();
+    });
+    return closing;
+  };
+  await new Promise((resolve10, reject) => {
+    server2.once("error", reject);
+    server2.listen({ host, port: options.port ?? 0, exclusive: true }, () => {
+      server2.off("error", reject);
+      resolve10();
+    });
+  });
+  const port = server2.address().port;
+  const authority = hostAuthority(host, port);
+  origin = `http://${authority}`;
+  hostHeader = authority;
+  touch();
+  return { url: `${origin}/?token=${token}`, host, port, token, closed, close };
+}
+
+// src/services/templateEditorCli.ts
+var TEMPLATES_USAGE = `Usage: apple-notes-mcp templates edit [name] [options]
+
+Open a local web editor for Markdown export templates. The editor validates
+and previews as you type, against built-in sample notes, and saves into the
+template library (create-only unless you tick "replace").
+
+  name                 Template to open: standard-markdown, obsidian, or a saved name
+  --port N             Port to listen on (default: a free port)
+  --idle-minutes N     Stop after N minutes without a request (default 30; 0: never)
+  --note ID            Also preview one real note (x-coredata://.../ICNote/pN), read-only
+  --tailnet            Listen on this Mac's Tailscale address instead of 127.0.0.1,
+                       so other devices on your tailnet can open the editor.
+                       Anyone on the tailnet who has the printed URL can read and save
+                       templates, and with --note can read the full body of that note.
+
+Every request needs the per-run token in the printed URL. Press Ctrl-C to stop.
+`;
+function parseTemplatesArgs(argv) {
+  if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) return "help";
+  const [command, ...rest] = argv;
+  if (command !== "edit") throw new Error(`Unknown templates command "${command}".`);
+  const args = {
+    idleMinutes: DEFAULT_EDITOR_IDLE_MS / 6e4,
+    tailnet: false
+  };
+  const number3 = (flag3, value, max) => {
+    if (value === void 0 || !/^\d+$/.test(value) || Number(value) > max)
+      throw new Error(`${flag3} needs a whole number from 0 to ${max}.`);
+    return Number(value);
+  };
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === "--port") args.port = number3(arg, rest[++i], 65535);
+    else if (arg === "--idle-minutes") args.idleMinutes = number3(arg, rest[++i], 24 * 60);
+    else if (arg === "--note") {
+      const id2 = rest[++i];
+      if (!id2 || !/^x-coredata:\/\/[^/\s]+\/ICNote\/p[0-9]{1,18}$/.test(id2))
+        throw new Error("--note needs a note id such as x-coredata://\u2026/ICNote/p123.");
+      args.noteId = id2;
+    } else if (arg === "--tailnet") args.tailnet = true;
+    else if (arg.startsWith("-")) throw new Error(`Unknown option ${arg}.`);
+    else if (args.name === void 0) args.name = arg;
+    else throw new Error(`Unexpected argument "${arg}".`);
+  }
+  return args;
+}
+var editorSignals = (stop) => {
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  return () => {
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
+  };
+};
+function tailnetWarning(host, withNote) {
+  const lines = [
+    `Listening on the tailnet address ${host}. Any device on your tailnet that has this URL can read and save templates. Keep the URL private.`,
+    withNote ? "--note is set: the full body of that note is shown in the preview, so anyone with this URL can read the entire note. Stop the editor when you are done." : "--note exposes the full note body to anyone with this URL, so do not combine it with --tailnet unless you want that."
+  ];
+  return `${lines.join("\n")}
+`;
+}
+async function runTemplatesCommand(argv, deps = {}) {
+  const out = deps.out ?? ((text2) => process.stdout.write(text2));
+  const err = deps.err ?? ((text2) => process.stderr.write(text2));
+  let args;
+  try {
+    args = parseTemplatesArgs(argv);
+  } catch (error2) {
+    err(`${error2.message}
+
+${TEMPLATES_USAGE}`);
+    return 2;
+  }
+  if (args === "help") {
+    out(TEMPLATES_USAGE);
+    return 0;
+  }
+  let host = "127.0.0.1";
+  if (args.tailnet) {
+    const found = (deps.tailnetAddress ?? findTailnetAddress)();
+    if (!found) {
+      err(
+        "No Tailscale address found (no 100.64.0.0/10 IPv4 address on this Mac). Connect Tailscale first, or run without --tailnet.\n"
+      );
+      return 1;
+    }
+    host = found.address;
+  }
+  let handle;
+  try {
+    const note = args.noteId ? (deps.readNote ?? ((id2) => ({ note: readExportNote(id2), meta: readExportNoteMeta(id2) })))(args.noteId) : void 0;
+    handle = await (deps.start ?? startTemplateEditor)({
+      host,
+      port: args.port,
+      idleMs: args.idleMinutes * 6e4,
+      name: args.name,
+      note
+    });
+  } catch (error2) {
+    err(`Could not start the template editor: ${error2.message}
+`);
+    return 1;
+  }
+  out(`Template editor: ${handle.url}
+`);
+  if (args.tailnet) err(tailnetWarning(handle.host, args.noteId !== void 0));
+  err(
+    args.idleMinutes > 0 ? `Press Ctrl-C to stop. Stops by itself after ${args.idleMinutes} idle minute(s).
+` : "Press Ctrl-C to stop.\n"
+  );
+  const unregister = (deps.onSignal ?? editorSignals)(() => void handle.close());
+  const reason = await handle.closed;
+  unregister();
+  err(
+    reason === "idle" ? "Template editor stopped after the idle timeout.\n" : "Template editor stopped.\n"
+  );
+  return 0;
+}
+
+// src/services/anchorServer.ts
+import { createServer as createServer2 } from "node:http";
+
+// src/utils/paragraphAnchors.ts
+import { createHash as createHash8 } from "node:crypto";
+var ANCHOR_ID_PATTERN = /^pa_[0-9a-f]{24}$/;
+var DEFAULT_MIN_CONFIDENCE = 0.6;
+var textFingerprint = (normalized2) => createHash8("sha256").update(normalized2, "utf8").digest("hex").slice(0, 32);
+function textSimilarity(a, b) {
+  if (a === b) return 1;
+  if (!a || !b) return 0;
+  const size = Math.min(a.length, b.length) < 3 ? 2 : 3;
+  const grams = (s) => {
+    const out = /* @__PURE__ */ new Map();
+    const padded = ` ${s} `;
+    for (let i = 0; i + size <= padded.length; i++) {
+      const g = padded.slice(i, i + size);
+      out.set(g, (out.get(g) ?? 0) + 1);
+    }
+    return out;
+  };
+  const ga = grams(a);
+  const gb = grams(b);
+  let shared = 0;
+  let total = 0;
+  for (const count of ga.values()) total += count;
+  for (const [g, count] of gb) {
+    total += count;
+    shared += Math.min(count, ga.get(g) ?? 0);
+  }
+  return total ? 2 * shared / total : 0;
+}
+var round2 = (value) => Math.round(value * 100) / 100;
+function anchorFor(note, paragraph, { anchorId, now }) {
+  if (!note.identifier)
+    throw new CodedError("The note has no stored identifier, so no anchor can be recorded", {
+      code: "unsupported"
+    });
+  const i = note.paragraphs.indexOf(paragraph);
+  if (i < 0) throw new Error("The paragraph does not belong to this note");
+  const fp = (p) => p ? textFingerprint(normalizeParagraphText(p.text)) : null;
+  const text2 = normalizeParagraphText(paragraph.text);
+  return {
+    anchorId,
+    noteIdentifier: note.identifier.toUpperCase(),
+    noteId: note.id,
+    paragraphId: paragraph.paragraphId,
+    paragraphIdStatus: paragraph.paragraphIdStatus,
+    text: text2,
+    fingerprint: textFingerprint(text2),
+    prevFingerprint: fp(note.paragraphs[i - 1]),
+    nextFingerprint: fp(note.paragraphs[i + 1]),
+    blockIndex: paragraph.blockIndex,
+    style: paragraph.style,
+    createdAt: now.toISOString()
+  };
+}
+function matchAnchor(anchor, paragraphs, { minConfidence = DEFAULT_MIN_CONFIDENCE } = {}) {
+  const result = findAnchor(anchor, paragraphs);
+  return result.status === "matched" && result.confidence < minConfidence ? { ...result, status: "low-confidence" } : result;
+}
+function findAnchor(anchor, paragraphs) {
+  const normalized2 = paragraphs.map((p) => normalizeParagraphText(p.text));
+  const fps = normalized2.map(textFingerprint);
+  const neighbours = (i) => Number((fps[i - 1] ?? null) === anchor.prevFingerprint) + Number((fps[i + 1] ?? null) === anchor.nextFingerprint);
+  const all = paragraphs.map((_, i) => i);
+  const byNeighbours = (candidates) => {
+    const scored2 = candidates.map((i) => ({ i, n: neighbours(i) }));
+    const best = Math.max(...scored2.map((s) => s.n));
+    const top = scored2.filter((s) => s.n === best);
+    return best > 0 && top.length === 1 ? top[0] : void 0;
+  };
+  if (anchor.paragraphId) {
+    const owners = all.filter((i) => paragraphs[i].paragraphId === anchor.paragraphId);
+    if (owners.length === 1 && paragraphs[owners[0]].paragraphIdStatus === "unique") {
+      const i = owners[0];
+      const same = fps[i] === anchor.fingerprint;
+      const confidence = same ? 1 : 0.8 + 0.15 * Math.max(textSimilarity(anchor.text, normalized2[i]), neighbours(i) / 2);
+      return { status: "matched", index: i, method: "paragraph-id", confidence: round2(confidence) };
+    }
+    const exact2 = owners.filter((i) => fps[i] === anchor.fingerprint);
+    if (exact2.length === 1)
+      return { status: "matched", index: exact2[0], method: "paragraph-id", confidence: 0.95 };
+    if (exact2.length > 1) {
+      const pick2 = byNeighbours(exact2);
+      if (pick2)
+        return { status: "matched", index: pick2.i, method: "paragraph-id", confidence: 0.9 };
+    }
+  }
+  const exact = all.filter((i) => fps[i] === anchor.fingerprint);
+  if (exact.length === 1) {
+    const confidence = neighbours(exact[0]) > 0 ? 0.95 : 0.85;
+    return { status: "matched", index: exact[0], method: "exact-text", confidence };
+  }
+  if (exact.length > 1) {
+    const pick2 = byNeighbours(exact);
+    if (pick2) return { status: "matched", index: pick2.i, method: "exact-text", confidence: 0.8 };
+    return { status: "ambiguous", confidence: 0, candidates: exact.length };
+  }
+  const scored = all.map((i) => ({ i, sim: textSimilarity(anchor.text, normalized2[i]), n: neighbours(i) })).filter(({ sim, n }) => n === 2 && sim >= 0.5 || n === 1 && sim >= 0.8).map((s) => ({ ...s, score: 0.4 * s.sim + 0.2 * s.n })).sort((a, b) => b.score - a.score);
+  if (!scored.length) return { status: "not-found", confidence: 0 };
+  if (scored.length > 1 && scored[0].score - scored[1].score < 0.1)
+    return {
+      status: "ambiguous",
+      confidence: 0,
+      candidates: scored.filter((s) => scored[0].score - s.score < 0.1).length
+    };
+  return {
+    status: "matched",
+    index: scored[0].i,
+    method: "text-and-neighbours",
+    confidence: round2(scored[0].score)
+  };
+}
+function resolutionFor(anchor, note, options = {}) {
+  const base = {
+    anchorId: anchor.anchorId,
+    noteId: note.id,
+    needsReminting: false,
+    resolved: false
+  };
+  const result = matchAnchor(anchor, note.paragraphs, options);
+  if (result.status === "ambiguous")
+    return {
+      ...base,
+      status: "ambiguous",
+      confidence: 0,
+      candidates: result.candidates,
+      message: `${result.candidates} paragraphs match the anchor equally well; refusing to guess`
+    };
+  if (result.status === "not-found")
+    return {
+      ...base,
+      status: "not-found",
+      confidence: 0,
+      message: "The anchored paragraph is no longer in the note (deleted, or edited beyond recognition)"
+    };
+  const p = note.paragraphs[result.index];
+  const match = {
+    blockIndex: p.blockIndex,
+    text: p.text,
+    paragraphId: p.paragraphId,
+    paragraphIdStatus: p.paragraphIdStatus,
+    ...p.sharedWith !== void 0 ? { sharedWith: p.sharedWith } : {}
+  };
+  const changes = {
+    textChanged: textFingerprint(normalizeParagraphText(p.text)) !== anchor.fingerprint,
+    blockIndexChanged: p.blockIndex !== anchor.blockIndex,
+    paragraphIdChanged: p.paragraphId !== anchor.paragraphId
+  };
+  const found = { ...base, method: result.method, confidence: result.confidence, match, changes };
+  if (result.status === "low-confidence")
+    return {
+      ...found,
+      status: "low-confidence",
+      message: `The best candidate scored ${result.confidence}, below the minimum; refusing to link it`
+    };
+  if (p.paragraphIdStatus === "unique" && note.identifier)
+    return {
+      ...found,
+      status: "resolved",
+      resolved: true,
+      url: paragraphUrl(note.identifier, p.paragraphId),
+      message: `Resolved by ${result.method} (confidence ${result.confidence})`
+    };
+  return {
+    ...found,
+    status: "needs-reminting",
+    needsReminting: true,
+    message: p.paragraphIdStatus === "shared" ? `Found the paragraph by ${result.method}, but its ID is shared with ${p.sharedWith} other paragraph(s); it needs a new paragraph ID before it can be linked` : `Found the paragraph by ${result.method}, but it has no paragraph ID; it needs one before it can be linked`
+  };
+}
+function noteByIdentifierSql(columns) {
+  return `SELECT json_object('pk', n.Z_PK, 'active', CASE WHEN ${activeNoteSql(columns, "n", "f")} THEN 1 ELSE 0 END, 'store', (SELECT Z_UUID FROM Z_METADATA LIMIT 1)) FROM ZICCLOUDSYNCINGOBJECT n LEFT JOIN ZICCLOUDSYNCINGOBJECT f ON f.Z_PK = n.ZFOLDER WHERE n.Z_ENT = ${entity("ICNote")} AND n.ZIDENTIFIER IN (CAST(@upper AS TEXT), CAST(@lower AS TEXT)) ORDER BY n.Z_PK;`;
+}
+function resolveAnchorDetailed(anchor, { dbPath: dbPath2 = NOTES_DB_PATH8, minConfidence } = {}) {
+  const none = { anchorId: anchor.anchorId, resolved: false, needsReminting: false, confidence: 0 };
+  const columns = readColumns(dbPath2);
+  const rows = parseJsonLines(
+    runReadOnlySql(dbPath2, noteByIdentifierSql(columns), {
+      upper: { blob: Buffer.from(anchor.noteIdentifier.toUpperCase(), "utf8") },
+      lower: { blob: Buffer.from(anchor.noteIdentifier.toLowerCase(), "utf8") }
+    })
+  );
+  if (!rows.length || !rows[0].store)
+    return {
+      resolution: {
+        ...none,
+        status: "note-not-found",
+        message: `No note with identifier ${anchor.noteIdentifier} is in the Notes database`
+      }
+    };
+  if (rows.length > 1)
+    return {
+      resolution: {
+        ...none,
+        status: "ambiguous",
+        candidates: rows.length,
+        message: `${rows.length} notes carry identifier ${anchor.noteIdentifier}; refusing to guess`
+      }
+    };
+  const noteId3 = noteIdFor(rows[0].store, rows[0].pk);
+  if (!rows[0].active)
+    return {
+      resolution: {
+        ...none,
+        noteId: noteId3,
+        status: "note-deleted",
+        message: "The note is in Recently Deleted or awaiting deletion"
+      }
+    };
+  let note;
+  try {
+    note = readNoteParagraphs({ id: noteId3 }, { dbPath: dbPath2 });
+  } catch (error2) {
+    if (error2 instanceof ParagraphLinkError)
+      return {
+        resolution: {
+          ...none,
+          noteId: noteId3,
+          status: error2.reason === "not-found" ? "note-not-found" : "note-unreadable",
+          message: error2.message
+        }
+      };
+    throw error2;
+  }
+  return { resolution: resolutionFor(anchor, note, { minConfidence }), note };
+}
+
+// src/services/anchorServer.ts
+var MIN_TOKEN_LENGTH = 32;
+var FAILURE_WINDOW_MS = 6e4;
+var MAX_TRACKED_PEERS = 256;
+var STATUS_CODE = {
+  resolved: 302,
+  "needs-reminting": 409,
+  ambiguous: 409,
+  "low-confidence": 409,
+  "not-found": 404,
+  "note-not-found": 404,
+  "note-deleted": 404,
+  "note-unreadable": 409
+};
+function createAnchorServer(options) {
+  if (options.token.length < MIN_TOKEN_LENGTH)
+    throw new Error(`The resolver token must be at least ${MIN_TOKEN_LENGTH} characters`);
+  const log = options.log ?? ((line) => process.stderr.write(line + "\n"));
+  const maxFailures = options.maxAuthFailures ?? 20;
+  const failuresByPeer = /* @__PURE__ */ new Map();
+  const recentFailures = (peer, now) => {
+    const recent = (failuresByPeer.get(peer) ?? []).filter((t) => now - t < FAILURE_WINDOW_MS);
+    if (recent.length) failuresByPeer.set(peer, recent);
+    else failuresByPeer.delete(peer);
+    return recent;
+  };
+  const server2 = createServer2((req, res) => {
+    const send = (status, body, headers = {}) => {
+      res.writeHead(status, {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Cache-Control": "no-store",
+        "Referrer-Policy": "no-referrer",
+        "X-Content-Type-Options": "nosniff",
+        ...headers
+      });
+      res.end(req.method === "HEAD" ? void 0 : body + "\n");
+      const path10 = (req.url ?? "").split("?")[0].slice(0, 64);
+      log(`${req.method} ${path10} ${status}`);
+    };
+    const now = Date.now();
+    const peer = req.socket.remoteAddress ?? "unknown";
+    if (failuresByPeer.size > MAX_TRACKED_PEERS)
+      for (const other of [...failuresByPeer.keys()]) recentFailures(other, now);
+    if (recentFailures(peer, now).length >= maxFailures)
+      return send(429, "Too many failed requests; wait a minute.");
+    if (req.method !== "GET" && req.method !== "HEAD")
+      return send(405, "Method not allowed.", { Allow: "GET, HEAD" });
+    const address = server2.address();
+    const port = address && typeof address === "object" ? address.port : options.port;
+    const hosts = /* @__PURE__ */ new Set([hostAuthority(options.host, port)]);
+    if (options.host === "127.0.0.1") hosts.add(`localhost:${port}`);
+    if (!hosts.has((req.headers.host ?? "").toLowerCase()))
+      return send(403, "Unexpected Host header.");
+    let url;
+    try {
+      url = new URL(req.url ?? "/", "http://resolver.invalid");
+    } catch {
+      return send(400, "Bad request.");
+    }
+    if (!tokenMatches(url.searchParams.get("token") ?? bearerToken(req), options.token)) {
+      failuresByPeer.set(peer, [...recentFailures(peer, now), now]);
+      return send(401, "Missing or wrong token.");
+    }
+    const match = /^\/a\/([^/]+)$/.exec(url.pathname);
+    if (!match || !ANCHOR_ID_PATTERN.test(match[1])) return send(404, "Not found.");
+    let resolution;
+    try {
+      resolution = options.resolve(match[1]);
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      return send(503, `Could not read the Notes database: ${message}`);
+    }
+    if (!resolution) return send(404, "No such anchor.");
+    if (resolution.status === "resolved" && resolution.url)
+      return send(302, `Redirecting to ${resolution.url}`, { Location: resolution.url });
+    return send(STATUS_CODE[resolution.status], `${resolution.status}: ${resolution.message}`);
+  });
+  server2.requestTimeout = 3e4;
+  server2.headersTimeout = 1e4;
+  return server2;
+}
+function startAnchorServer(options) {
+  const server2 = createAnchorServer(options);
+  return new Promise((resolve10, reject) => {
+    server2.once("error", reject);
+    server2.listen(options.port, options.host, () => {
+      server2.off("error", reject);
+      const address = server2.address();
+      const port = address && typeof address === "object" ? address.port : options.port;
+      resolve10({
+        server: server2,
+        baseUrl: `http://${hostAuthority(options.host, port)}`,
+        close: () => new Promise((done) => {
+          server2.closeAllConnections();
+          server2.close(() => done());
+        })
+      });
+    });
+  });
+}
+var ANCHORS_USAGE = `Usage: apple-notes-mcp anchors serve [--port N] [--tailnet]
+
+Serves GET /a/<anchor-id>?token=<token>, redirecting to the paragraph's
+current applenotes:// link. Binds 127.0.0.1 unless --tailnet is given, in
+which case it binds this Mac's Tailscale address (it never changes Tailscale
+or firewall settings). The token is APPLE_NOTES_MCP_ANCHORS_TOKEN (at least
+${MIN_TOKEN_LENGTH} characters) or a random one printed at startup. The process
+that runs it needs Full Disk Access. Stop it with Ctrl-C.`;
+function parseAnchorsArgs(argv) {
+  const args = { port: 0, tailnet: false, help: false };
+  if (!argv.length || argv[0] === "--help" || argv[0] === "-h") return { ...args, help: true };
+  if (argv[0] !== "serve") throw new Error(`Unknown anchors command "${argv[0]}"`);
+  for (let i = 1; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--tailnet") args.tailnet = true;
+    else if (arg === "--help" || arg === "-h") args.help = true;
+    else if (arg === "--port") {
+      const value = argv[++i];
+      if (!value || !/^\d{1,5}$/.test(value) || Number(value) > 65535)
+        throw new Error("--port needs a number from 0 to 65535");
+      args.port = Number(value);
+    } else throw new Error(`Unknown option "${arg}"`);
+  }
+  return args;
+}
+async function runAnchorsCli(argv, {
+  env = process.env,
+  resolve: resolve10,
+  out = (text2) => process.stdout.write(text2),
+  interfaces,
+  signals = process
+}) {
+  let args;
+  try {
+    args = parseAnchorsArgs(argv);
+  } catch (error2) {
+    out(`${error2.message}
+
+${ANCHORS_USAGE}
+`);
+    return 2;
+  }
+  if (args.help) {
+    out(ANCHORS_USAGE + "\n");
+    return 0;
+  }
+  const host = args.tailnet ? findTailnetAddress(interfaces)?.address : "127.0.0.1";
+  if (!host) {
+    out("No Tailscale address (100.64.0.0/10) found on this Mac; is Tailscale connected?\n");
+    return 1;
+  }
+  const fromEnv = env.APPLE_NOTES_MCP_ANCHORS_TOKEN?.trim();
+  if (fromEnv !== void 0 && fromEnv !== "" && fromEnv.length < MIN_TOKEN_LENGTH) {
+    out(`APPLE_NOTES_MCP_ANCHORS_TOKEN must be at least ${MIN_TOKEN_LENGTH} characters.
+`);
+    return 1;
+  }
+  const token = fromEnv || newServerToken();
+  let started;
+  try {
+    started = await startAnchorServer({ host, port: args.port, token, resolve: resolve10 });
+  } catch (error2) {
+    out(`Could not listen on ${host}:${args.port}: ${error2.message}
+`);
+    return 1;
+  }
+  out(
+    `Paragraph anchor resolver listening on ${started.baseUrl}
+Links: ${started.baseUrl}/a/<anchor-id>?token=<token>
+` + (fromEnv ? "Token: from APPLE_NOTES_MCP_ANCHORS_TOKEN\n" : `Token (this run only): ${token}
+`) + "Press Ctrl-C to stop.\n"
+  );
+  await new Promise((done) => {
+    signals.once("SIGINT", () => done());
+    signals.once("SIGTERM", () => done());
+  });
+  await started.close();
+  return 0;
+}
+
+// src/services/anchorRegistry.ts
+import { randomBytes as randomBytes5 } from "node:crypto";
+import {
+  closeSync as closeSync9,
+  constants as constants9,
+  fstatSync as fstatSync9,
+  fsyncSync,
+  lstatSync as lstatSync6,
+  mkdirSync as mkdirSync11,
+  openSync as openSync9,
+  readSync as readSync7,
+  renameSync as renameSync5,
+  statSync as statSync6,
+  unlinkSync as unlinkSync5,
+  writeSync as writeSync6
+} from "node:fs";
+import { homedir as homedir23 } from "node:os";
+import { dirname as dirname10, isAbsolute as isAbsolute6, join as join32, resolve as resolve9 } from "node:path";
+var MAX_ANCHORS = 2e4;
+var MAX_REGISTRY_BYTES = 32 * 1024 * 1024;
+var LOCK_WAIT_MS = 3e3;
+var LOCK_STALE_MS = 3e4;
+var ENVELOPE = {
+  "unsafe-path": "validation_error",
+  "corrupt-registry": "operation_failed",
+  "registry-full": "validation_error",
+  "registry-busy": "operation_failed",
+  "anchor-not-found": "not_found",
+  "invalid-anchor-id": "validation_error"
+};
+var AnchorRegistryError = class extends CodedError {
+  constructor(reason, message) {
+    super(message, { code: ENVELOPE[reason], reason });
+    this.reason = reason;
+    this.name = "AnchorRegistryError";
+  }
+  reason;
+};
+function anchorRegistryPath(env = process.env) {
+  const override = env.APPLE_NOTES_MCP_ANCHOR_FILE?.trim();
+  if (override) {
+    if (!isAbsolute6(override))
+      throw new AnchorRegistryError(
+        "unsafe-path",
+        "APPLE_NOTES_MCP_ANCHOR_FILE must be an absolute path."
+      );
+    return resolve9(override);
+  }
+  return join32(homedir23(), "Library/Application Support/apple-notes-mcp/paragraph-anchors.json");
+}
+var STRING_OR_NULL = (v) => v === null || typeof v === "string";
+function isAnchor(v) {
+  if (!v || typeof v !== "object") return false;
+  const a = v;
+  return typeof a.anchorId === "string" && ANCHOR_ID_PATTERN.test(a.anchorId) && typeof a.noteIdentifier === "string" && STRING_OR_NULL(a.noteId) && STRING_OR_NULL(a.paragraphId) && ["unique", "shared", "missing"].includes(a.paragraphIdStatus) && typeof a.text === "string" && typeof a.fingerprint === "string" && STRING_OR_NULL(a.prevFingerprint) && STRING_OR_NULL(a.nextFingerprint) && Number.isInteger(a.blockIndex) && typeof a.style === "string" && typeof a.createdAt === "string" && (a.updatedAt === void 0 || typeof a.updatedAt === "string");
+}
+var sleep2 = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+var AnchorRegistry = class _AnchorRegistry {
+  constructor(path10 = anchorRegistryPath(), lockWaitMs = LOCK_WAIT_MS) {
+    this.path = path10;
+    this.lockWaitMs = lockWaitMs;
+  }
+  path;
+  lockWaitMs;
+  /** A new random anchor id. */
+  static newId() {
+    return `pa_${randomBytes5(12).toString("hex")}`;
+  }
+  ensureDir() {
+    const dir = dirname10(this.path);
+    try {
+      if (!lstatSync6(dir).isDirectory())
+        throw new AnchorRegistryError(
+          "unsafe-path",
+          `${dir} is not a directory (symlinks are refused).`
+        );
+    } catch (error2) {
+      if (error2 instanceof AnchorRegistryError) throw error2;
+      mkdirSync11(dir, { recursive: true, mode: 448 });
+    }
+  }
+  /** Every anchor in the file, in the order recorded. A missing file is an empty registry. */
+  load() {
+    let fd;
+    try {
+      fd = openSync9(this.path, constants9.O_RDONLY | constants9.O_NOFOLLOW);
+    } catch (error2) {
+      if (error2.code === "ENOENT") return [];
+      throw new AnchorRegistryError(
+        "unsafe-path",
+        `Refusing to read ${this.path}: not a regular file.`
+      );
+    }
+    let text2;
+    try {
+      const stat = fstatSync9(fd);
+      if (!stat.isFile())
+        throw new AnchorRegistryError(
+          "unsafe-path",
+          `Refusing to read ${this.path}: not a regular file.`
+        );
+      if (stat.size > MAX_REGISTRY_BYTES)
+        throw new AnchorRegistryError(
+          "corrupt-registry",
+          `${this.path} is ${stat.size} bytes; the limit is ${MAX_REGISTRY_BYTES}.`
+        );
+      const data = Buffer.alloc(stat.size);
+      let read = 0;
+      while (read < stat.size) {
+        const n = readSync7(fd, data, read, stat.size - read, read);
+        if (n <= 0) break;
+        read += n;
+      }
+      text2 = data.subarray(0, read).toString("utf8");
+    } finally {
+      closeSync9(fd);
+    }
+    if (text2.trim() === "") return [];
+    let parsed;
+    try {
+      parsed = JSON.parse(text2);
+    } catch {
+      throw new AnchorRegistryError(
+        "corrupt-registry",
+        `${this.path} is not valid JSON; it was left unchanged. Move it aside to start a new registry.`
+      );
+    }
+    const anchors = parsed?.anchors;
+    if (parsed?.version !== 1 || !Array.isArray(anchors) || !anchors.every(isAnchor))
+      throw new AnchorRegistryError(
+        "corrupt-registry",
+        `${this.path} is not a version 1 anchor registry; it was left unchanged.`
+      );
+    return anchors;
+  }
+  /** One anchor, or an `anchor-not-found` error. */
+  get(anchorId) {
+    if (!ANCHOR_ID_PATTERN.test(anchorId))
+      throw new AnchorRegistryError(
+        "invalid-anchor-id",
+        `Invalid anchor id "${anchorId}": expected pa_ and 24 hex digits.`
+      );
+    const anchor = this.load().find((a) => a.anchorId === anchorId);
+    if (!anchor) throw new AnchorRegistryError("anchor-not-found", `No anchor ${anchorId}.`);
+    return anchor;
+  }
+  /**
+   * Apply `change` to the current anchors under the lock and save the result.
+   * Returns what `change` returns.
+   */
+  update(change) {
+    this.ensureDir();
+    const release5 = this.lock();
+    try {
+      const { anchors, result } = change(this.load());
+      if (anchors.length > MAX_ANCHORS)
+        throw new AnchorRegistryError(
+          "registry-full",
+          `The registry holds at most ${MAX_ANCHORS} anchors; prune stale anchors first.`
+        );
+      this.write(anchors);
+      return result;
+    } finally {
+      release5();
+    }
+  }
+  write(anchors) {
+    try {
+      if (!lstatSync6(this.path).isFile())
+        throw new AnchorRegistryError(
+          "unsafe-path",
+          `Refusing to replace ${this.path}: it is not a regular file.`
+        );
+    } catch (error2) {
+      if (error2 instanceof AnchorRegistryError) throw error2;
+    }
+    const temp = join32(
+      dirname10(this.path),
+      `.paragraph-anchors.${randomBytes5(6).toString("hex")}.tmp`
+    );
+    const fd = openSync9(
+      temp,
+      constants9.O_WRONLY | constants9.O_CREAT | constants9.O_EXCL | constants9.O_NOFOLLOW,
+      384
+    );
+    try {
+      const data = Buffer.from(JSON.stringify({ version: 1, anchors }, null, 1) + "\n", "utf8");
+      let written = 0;
+      while (written < data.length) written += writeSync6(fd, data, written);
+      fsyncSync(fd);
+    } catch (error2) {
+      closeSync9(fd);
+      unlinkSync5(temp);
+      throw error2;
+    }
+    closeSync9(fd);
+    try {
+      renameSync5(temp, this.path);
+    } catch (error2) {
+      unlinkSync5(temp);
+      throw error2;
+    }
+  }
+  /** Take the lock file, waiting briefly; a lock older than 30 s is treated as abandoned. */
+  lock() {
+    const lockPath = `${this.path}.lock`;
+    const deadline = Date.now() + this.lockWaitMs;
+    for (; ; ) {
+      try {
+        const fd = openSync9(
+          lockPath,
+          constants9.O_WRONLY | constants9.O_CREAT | constants9.O_EXCL | constants9.O_NOFOLLOW,
+          384
+        );
+        writeSync6(fd, String(process.pid));
+        closeSync9(fd);
+        return () => {
+          try {
+            unlinkSync5(lockPath);
+          } catch {
+          }
+        };
+      } catch (error2) {
+        if (error2.code !== "EEXIST") throw error2;
+      }
+      try {
+        if (Date.now() - statSync6(lockPath).mtimeMs > LOCK_STALE_MS) {
+          unlinkSync5(lockPath);
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (Date.now() > deadline)
+        throw new AnchorRegistryError(
+          "registry-busy",
+          `Another process holds ${lockPath}; try again shortly.`
+        );
+      sleep2(25);
+    }
+  }
+  /**
+   * Record anchors, reusing an existing anchor for the same note, paragraph ID,
+   * text and block index. Each new anchor gets a fresh id (a candidate's own
+   * anchorId is ignored). Returns each anchor with whether it was new.
+   */
+  record(candidates) {
+    return this.update((anchors) => {
+      const out = [];
+      const next = [...anchors];
+      for (const candidate of candidates) {
+        const existing = next.find(
+          (a) => a.noteIdentifier === candidate.noteIdentifier && a.paragraphId === candidate.paragraphId && a.fingerprint === candidate.fingerprint && a.blockIndex === candidate.blockIndex
+        );
+        if (existing) {
+          out.push({ anchor: existing, created: false });
+          continue;
+        }
+        const anchor = { ...candidate, anchorId: _AnchorRegistry.newId() };
+        next.push(anchor);
+        out.push({ anchor, created: true });
+      }
+      return { anchors: next, result: out };
+    });
+  }
+  /** Replace one anchor's fields (not its id or creation time). */
+  replace(anchor) {
+    return this.update((anchors) => {
+      const i = anchors.findIndex((a) => a.anchorId === anchor.anchorId);
+      if (i < 0) throw new AnchorRegistryError("anchor-not-found", `No anchor ${anchor.anchorId}.`);
+      const saved = { ...anchor, createdAt: anchors[i].createdAt };
+      const next = [...anchors];
+      next[i] = saved;
+      return { anchors: next, result: saved };
+    });
+  }
+  /** Remove anchors by id; returns the ids that were present. */
+  remove(anchorIds) {
+    const wanted = new Set(anchorIds);
+    return this.update((anchors) => ({
+      anchors: anchors.filter((a) => !wanted.has(a.anchorId)),
+      result: anchors.filter((a) => wanted.has(a.anchorId)).map((a) => a.anchorId)
+    }));
+  }
+};
+
+// src/services/paragraphAnchorOps.ts
+var MAX_ANCHORS_PER_CALL = 500;
+function recordParagraphAnchors(note, paragraphs, registry2 = new AnchorRegistry(), now = /* @__PURE__ */ new Date()) {
+  const candidates = paragraphs.slice(0, MAX_ANCHORS_PER_CALL).map((p) => anchorFor(note, p, { anchorId: "", now }));
+  return candidates.length ? registry2.record(candidates) : [];
+}
+var REFRESH_MIN_CONFIDENCE = 0.8;
+function resolveStoredAnchor(anchorId, {
+  registry: registry2 = new AnchorRegistry(),
+  dbPath: dbPath2,
+  minConfidence,
+  refresh = false,
+  now = () => /* @__PURE__ */ new Date()
+} = {}) {
+  const anchor = registry2.get(anchorId);
+  const { resolution, note } = resolveAnchorDetailed(anchor, { dbPath: dbPath2, minConfidence });
+  const out = { ...resolution };
+  if (refresh) {
+    if (!out.match || !note || !["resolved", "needs-reminting"].includes(out.status))
+      out.refreshSkipped = "nothing was matched";
+    else if (out.confidence < REFRESH_MIN_CONFIDENCE)
+      out.refreshSkipped = `confidence ${out.confidence} is below ${REFRESH_MIN_CONFIDENCE}`;
+    else {
+      const paragraph = note.paragraphs.find((p) => p.blockIndex === out.match.blockIndex);
+      const fresh = anchorFor(note, paragraph, { anchorId, now: now() });
+      registry2.replace({ ...fresh, updatedAt: fresh.createdAt });
+      out.refreshed = true;
+    }
+  }
+  return out;
+}
+var DEFAULT_PRUNE_STATUSES = ["not-found", "note-not-found"];
+function pruneParagraphAnchors({
+  registry: registry2 = new AnchorRegistry(),
+  dbPath: dbPath2,
+  anchorIds,
+  noteIdentifier,
+  statuses = DEFAULT_PRUNE_STATUSES,
+  dryRun = true
+} = {}) {
+  let anchors = registry2.load();
+  if (noteIdentifier)
+    anchors = anchors.filter((a) => a.noteIdentifier === noteIdentifier.toUpperCase());
+  let stale;
+  if (anchorIds) {
+    const wanted = new Set(anchorIds);
+    stale = anchors.filter((a) => wanted.has(a.anchorId)).map((a) => ({ anchorId: a.anchorId, status: "listed", message: "Listed by id" }));
+  } else {
+    const wanted = new Set(statuses);
+    stale = [];
+    for (const anchor of anchors) {
+      const r = resolveAnchorDetailed(anchor, { dbPath: dbPath2 }).resolution;
+      if (wanted.has(r.status))
+        stale.push({ anchorId: anchor.anchorId, status: r.status, message: r.message });
+    }
+  }
+  const removed = dryRun || !stale.length ? [] : registry2.remove(stale.map((s) => s.anchorId));
+  return { dryRun, examined: anchorIds ? stale.length : anchors.length, stale, removed };
+}
+function registryLookup(registry2 = new AnchorRegistry(), dbPath2) {
+  return (anchorId) => {
+    const anchor = registry2.load().find((a) => a.anchorId === anchorId);
+    return anchor ? resolveAnchorDetailed(anchor, { dbPath: dbPath2 }).resolution : void 0;
+  };
+}
+
 // src/index.ts
 loadFileConfig();
 var require2 = createRequire(import.meta.url);
@@ -60264,6 +61752,14 @@ if (process.argv[2] === "setup") {
   process.stdout.write(formatShortcutSetup(report) + "\n");
   process.exit(report.ready || !report.checkOnly ? 0 : 1);
 }
+if (process.argv[2] === "templates") {
+  process.exit(await runTemplatesCommand(process.argv.slice(3)));
+}
+if (process.argv[2] === "anchors") {
+  process.exit(
+    await runAnchorsCli(process.argv.slice(3), { resolve: registryLookup(new AnchorRegistry()) })
+  );
+}
 var server = new McpServer({
   name: "apple-notes",
   version: version2,
@@ -61370,6 +62866,9 @@ registerTool(
     );
   }, "Error reading note blocks")
 );
+var recordAnchorsInput = external_exports.boolean().optional().describe(
+  "Also record a paragraph anchor for each returned paragraph (at most 500 per call) so resolve-paragraph-anchor can find it after edits; each row gains anchorId (default false; writes only the local anchor registry)"
+);
 var paragraphNoteSelector = {
   id: noteIdInput.optional().describe(`Exact note ID (${NOTE_ID_FORMS}); give id or title`),
   title: external_exports.string().min(1).max(MAX.TITLE).optional().describe("Exact note title; must match one note unless folder narrows it"),
@@ -61378,41 +62877,57 @@ var paragraphNoteSelector = {
 registerTool(
   "list-note-paragraphs",
   {
-    description: "Use when: you need a note's paragraphs with their style and stored paragraph ID, for example to choose one to link to.\nReturns: one page of non-empty paragraphs in body order, each with blockIndex (as in get-note-blocks), text, style, paragraphId, paragraphIdStatus (unique, shared, missing) and, only when unique, a direct applenotes:// url that opens that paragraph; plus counts per status and page info (call again with offset set to page.nextOffset while page.hasMore is true).\nDo not use when: you need inline formatting (get-note-blocks).\nSafety: read-only; reads the NoteStore database directly and requires Full Disk Access. Paragraph IDs repeat often (Notes copies them when a paragraph is split), so shared IDs get no url. Title lookups ignore Recently Deleted. Password-protected notes are refused.",
+    description: "Use when: you need a note's paragraphs with their style and stored paragraph ID, for example to choose one to link to.\nReturns: one page of non-empty paragraphs in body order, each with blockIndex (as in get-note-blocks), text, style, paragraphId, paragraphIdStatus (unique, shared, missing) and, only when unique, a direct applenotes:// url that opens that paragraph; plus counts per status and page info (call again with offset set to page.nextOffset while page.hasMore is true).\nDo not use when: you need inline formatting (get-note-blocks).\nSafety: never changes Notes; reads the NoteStore database directly and requires Full Disk Access. Without recordAnchors it writes nothing; with recordAnchors it also writes the local anchor registry file (mode 0600), so the tool is not marked read-only. Paragraph IDs repeat often (Notes copies them when a paragraph is split), so shared IDs get no url. Title lookups ignore Recently Deleted. Password-protected notes are refused.",
     inputSchema: {
       ...paragraphNoteSelector,
       linkableOnly: external_exports.boolean().optional().describe("Return only paragraphs that have a direct url (default false)"),
       offset: external_exports.number().int().min(0).optional().describe("Index of the first paragraph to return (default 0); use page.nextOffset"),
-      limit: external_exports.number().int().min(1).max(5e3).optional().describe("Maximum paragraphs to return (default 500, max 5000)")
+      limit: external_exports.number().int().min(1).max(5e3).optional().describe("Maximum paragraphs to return (default 500, max 5000)"),
+      recordAnchors: recordAnchorsInput
     },
     outputSchema: {
       id: external_exports.string().optional(),
       identifier: external_exports.string().nullable().optional(),
       counts: external_exports.record(external_exports.unknown()).optional(),
       paragraphs: external_exports.array(external_exports.record(external_exports.unknown())).optional(),
-      page: external_exports.record(external_exports.unknown()).optional()
+      page: external_exports.record(external_exports.unknown()).optional(),
+      anchorsRecorded: external_exports.number().optional()
     },
-    annotations: { readOnlyHint: true }
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
   },
-  withErrorHandling(({ id: id2, title, folder, linkableOnly, offset, limit }) => {
+  withErrorHandling(({ id: id2, title, folder, linkableOnly, offset, limit, recordAnchors }) => {
     const note = readNoteParagraphs({ id: id2, title, folder });
     const page = pageParagraphs(note.paragraphs, {
       offset,
-      limit,
+      limit: recordAnchors ? Math.min(limit ?? 500, MAX_ANCHORS_PER_CALL) : limit,
       linkableOnly,
       maxBytes: blocksMaxResponseBytes()
     });
+    let anchorsRecorded;
+    let paragraphs = page.paragraphs;
+    if (recordAnchors) {
+      const recorded = recordParagraphAnchors(note, page.paragraphs);
+      anchorsRecorded = recorded.filter((r) => r.created).length;
+      paragraphs = page.paragraphs.map((p, i) => ({ ...p, anchorId: recorded[i].anchor.anchorId }));
+    }
     const { unique, shared, missing } = note.counts;
     return successResponse(
-      `${note.paragraphs.length} paragraphs: ${unique} linkable, ${shared} with a shared ID, ${missing} without an ID; returned ${page.page.returned} from offset ${page.page.offset}` + (page.page.hasMore ? `; more at offset ${page.page.nextOffset}` : "") + ".",
-      { id: note.id, identifier: note.identifier, counts: note.counts, ...page }
+      `${note.paragraphs.length} paragraphs: ${unique} linkable, ${shared} with a shared ID, ${missing} without an ID; returned ${page.page.returned} from offset ${page.page.offset}` + (page.page.hasMore ? `; more at offset ${page.page.nextOffset}` : "") + (anchorsRecorded !== void 0 ? `; ${anchorsRecorded} new anchor(s) recorded` : "") + ".",
+      {
+        id: note.id,
+        identifier: note.identifier,
+        counts: note.counts,
+        paragraphs,
+        page: page.page,
+        ...anchorsRecorded !== void 0 ? { anchorsRecorded } : {}
+      }
     );
   }, "Error listing paragraphs")
 );
 registerTool(
   "get-paragraph-link",
   {
-    description: "Use when: you need a link that opens Notes at one paragraph (for example a heading) of a note.\nReturns: a direct applenotes://showNote?identifier=<note>&paragraphID=<paragraph> url and the selected paragraph, only when that paragraph's stored ID is present and appears in no other paragraph of the note. Otherwise an error whose structuredContent.reason says why: paragraph-id-shared, paragraph-id-missing, no-match, ambiguous-paragraph (pass occurrence or a longer snippet), occurrence-out-of-range, ambiguous-note, encrypted.\nDo not use when: you want a link to the whole note (get-note-link).\nSafety: read-only; never creates or changes a paragraph ID, so a paragraph without a unique ID cannot be linked. Requires Full Disk Access. A later edit in Notes can replace the ID and break the link.",
+    description: "Use when: you need a link that opens Notes at one paragraph (for example a heading) of a note.\nReturns: a direct applenotes://showNote?identifier=<note>&paragraphID=<paragraph> url and the selected paragraph, only when that paragraph's stored ID is present and appears in no other paragraph of the note. Otherwise an error whose structuredContent.reason says why: paragraph-id-shared, paragraph-id-missing, no-match, ambiguous-paragraph (pass occurrence or a longer snippet), occurrence-out-of-range, ambiguous-note, encrypted.\nDo not use when: you want a link to the whole note (get-note-link).\nSafety: never changes Notes or a paragraph ID, so a paragraph without a unique ID cannot be linked. Requires Full Disk Access. Without recordAnchor it writes nothing; with recordAnchor it also writes the local anchor registry file (mode 0600), so the tool is not marked read-only. A later edit in Notes can replace the ID and break the link.",
     inputSchema: {
       ...paragraphNoteSelector,
       contains: external_exports.string().min(1).max(MAX.CONTENT).optional().describe(
@@ -61420,26 +62935,201 @@ registerTool(
       ),
       match: external_exports.string().min(1).max(MAX.CONTENT).optional().describe("The whole paragraph text, compared the same way"),
       blockIndex: external_exports.number().int().min(0).optional().describe("The paragraph's blockIndex from list-note-paragraphs"),
-      occurrence: external_exports.number().int().min(1).optional().describe("Which match to use (1-based) when contains or match hits several paragraphs")
+      occurrence: external_exports.number().int().min(1).optional().describe("Which match to use (1-based) when contains or match hits several paragraphs"),
+      recordAnchor: external_exports.boolean().optional().describe(
+        "Also record a paragraph anchor for the linked paragraph so resolve-paragraph-anchor can find it after edits (default false; writes only the local anchor registry)"
+      )
     },
     outputSchema: {
       url: external_exports.string().optional(),
       id: external_exports.string().optional(),
       identifier: external_exports.string().nullable().optional(),
-      paragraph: external_exports.record(external_exports.unknown()).optional()
+      paragraph: external_exports.record(external_exports.unknown()).optional(),
+      anchorId: external_exports.string().optional()
     },
-    annotations: { readOnlyHint: true }
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
+  },
+  withErrorHandling(
+    ({ id: id2, title, folder, contains, match, blockIndex, occurrence, recordAnchor }) => {
+      const note = readNoteParagraphs({ id: id2, title, folder });
+      const result = paragraphLink(note, { contains, match, blockIndex, occurrence });
+      const anchorId = recordAnchor ? recordParagraphAnchors(note, [result.paragraph])[0].anchor.anchorId : void 0;
+      return successResponse(
+        `Paragraph link: ${result.url}` + (anchorId ? `
+Anchor: ${anchorId}` : ""),
+        {
+          url: result.url,
+          id: note.id,
+          identifier: note.identifier,
+          paragraph: { ...result.paragraph },
+          ...anchorId ? { anchorId } : {}
+        }
+      );
+    },
+    "No paragraph link"
+  )
+);
+var anchorIdInput = external_exports.string().regex(ANCHOR_ID_PATTERN, "Expected an anchor id: pa_ and 24 hex digits").describe(
+  "Anchor id (pa_ and 24 hex digits) from create-paragraph-anchor or list-paragraph-anchors"
+);
+var noteIdentifierInput = external_exports.string().regex(/^[0-9A-Fa-f]{8}(?:-[0-9A-Fa-f]{4}){3}-[0-9A-Fa-f]{12}$/, "Expected a Notes UUID").optional();
+registerTool(
+  "create-paragraph-anchor",
+  {
+    description: "Use when: you want a reference to one paragraph that can be found again after the note is edited, for example before sharing a paragraph link that should keep working.\nReturns: the anchor (anchorId, note identifier, paragraph ID and its status, normalized text, fingerprints of the paragraph and its neighbours, block index, created time), whether it is new, and the paragraph's current direct url when its ID is unique.\nDo not use when: you only need a link right now (get-paragraph-link).\nSafety: reads the NoteStore database (Full Disk Access) and never changes Notes. Writes one local file, the anchor registry (APPLE_NOTES_MCP_ANCHOR_FILE, default ~/Library/Application Support/apple-notes-mcp/paragraph-anchors.json, mode 0600), which stores the paragraph's text. Unlike get-paragraph-link, a paragraph with a shared or missing ID can be anchored. Recording the same paragraph again returns the existing anchor.",
+    inputSchema: {
+      ...paragraphNoteSelector,
+      contains: external_exports.string().min(1).max(MAX.CONTENT).optional().describe("Snippet of the paragraph; give one of contains, match, blockIndex"),
+      match: external_exports.string().min(1).max(MAX.CONTENT).optional().describe("The whole paragraph text"),
+      blockIndex: external_exports.number().int().min(0).optional().describe("The paragraph's blockIndex from list-note-paragraphs"),
+      occurrence: external_exports.number().int().min(1).optional().describe("Which match to use (1-based) when contains or match hits several paragraphs")
+    },
+    outputSchema: {
+      anchor: external_exports.record(external_exports.unknown()).optional(),
+      created: external_exports.boolean().optional(),
+      url: external_exports.string().optional()
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
   },
   withErrorHandling(({ id: id2, title, folder, contains, match, blockIndex, occurrence }) => {
     const note = readNoteParagraphs({ id: id2, title, folder });
-    const result = paragraphLink(note, { contains, match, blockIndex, occurrence });
-    return successResponse(`Paragraph link: ${result.url}`, {
-      url: result.url,
-      id: note.id,
-      identifier: note.identifier,
-      paragraph: { ...result.paragraph }
+    const paragraph = selectParagraph(note.paragraphs, { contains, match, blockIndex, occurrence });
+    const [{ anchor, created }] = recordParagraphAnchors(note, [paragraph]);
+    return successResponse(
+      `${created ? "Recorded" : "Reusing"} anchor ${anchor.anchorId} for block ${anchor.blockIndex} (paragraph ID ${paragraph.paragraphIdStatus}).`,
+      { anchor: { ...anchor }, created, ...paragraph.url ? { url: paragraph.url } : {} }
+    );
+  }, "Error recording paragraph anchor")
+);
+registerTool(
+  "resolve-paragraph-anchor",
+  {
+    description: "Use when: you have an anchorId and need the paragraph's current link, or want to check that an anchored paragraph still exists after edits.\nReturns: status (resolved, needs-reminting, ambiguous, low-confidence, not-found, note-not-found, note-deleted, note-unreadable), method (paragraph-id, exact-text, text-and-neighbours), confidence from 0 to 1, the matched block (blockIndex, text, paragraphId, paragraphIdStatus) and what changed. url is present only when status is resolved.\nDo not use when: you have no anchor yet (create-paragraph-anchor, or get-paragraph-link with recordAnchor).\nSafety: reads the NoteStore database (Full Disk Access); never changes Notes. Fails closed: equally good candidates give ambiguous and no url. needs-reminting means the paragraph was found but its stored ID is shared or missing, so no safe link exists for it; this server cannot give it a new ID. refresh rewrites the stored anchor (local registry only) after a match with confidence 0.8 or more.",
+    inputSchema: {
+      anchorId: anchorIdInput,
+      minConfidence: external_exports.number().min(0).max(1).optional().describe(`Lowest confidence accepted as a match (default ${DEFAULT_MIN_CONFIDENCE})`),
+      refresh: external_exports.boolean().optional().describe(
+        "Update the stored anchor to the matched paragraph as it is now (default false; only at confidence 0.8 or more)"
+      )
+    },
+    outputSchema: {
+      anchorId: external_exports.string().optional(),
+      status: external_exports.string().optional(),
+      resolved: external_exports.boolean().optional(),
+      url: external_exports.string().optional(),
+      needsReminting: external_exports.boolean().optional(),
+      method: external_exports.string().optional(),
+      confidence: external_exports.number().optional(),
+      match: external_exports.record(external_exports.unknown()).optional(),
+      changes: external_exports.record(external_exports.unknown()).optional(),
+      candidates: external_exports.number().optional(),
+      noteId: external_exports.string().optional(),
+      message: external_exports.string().optional(),
+      refreshed: external_exports.boolean().optional(),
+      refreshSkipped: external_exports.string().optional()
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false }
+  },
+  withErrorHandling(({ anchorId, minConfidence, refresh }) => {
+    const result = resolveStoredAnchor(anchorId, { minConfidence, refresh });
+    return successResponse(
+      `${result.status}: ${result.message}` + (result.url ? `
+Link: ${result.url}` : ""),
+      { ...result }
+    );
+  }, "Error resolving paragraph anchor")
+);
+registerTool(
+  "list-paragraph-anchors",
+  {
+    description: "Use when: you need the recorded paragraph anchors, all of them or those of one note.\nReturns: one page of anchors in the order recorded (anchorId, noteIdentifier, paragraphId, text, blockIndex, created time), the total, and the registry path.\nDo not use when: you need an anchor's current location (resolve-paragraph-anchor).\nSafety: read-only; reads only the local anchor registry, never Notes.",
+    inputSchema: {
+      noteIdentifier: noteIdentifierInput.describe(
+        "Only anchors in the note with this Notes UUID (its identifier)"
+      ),
+      offset: external_exports.number().int().min(0).optional().describe("First anchor to return (default 0)"),
+      limit: external_exports.number().int().min(1).max(1e3).optional().describe("Maximum anchors to return (default 100, max 1000)")
+    },
+    outputSchema: {
+      anchors: external_exports.array(external_exports.record(external_exports.unknown())).optional(),
+      total: external_exports.number().optional(),
+      registry: external_exports.string().optional(),
+      page: external_exports.record(external_exports.unknown()).optional()
+    },
+    annotations: { readOnlyHint: true }
+  },
+  withErrorHandling(({ noteIdentifier, offset = 0, limit = 100 }) => {
+    const registry2 = new AnchorRegistry();
+    let anchors = registry2.load();
+    if (noteIdentifier)
+      anchors = anchors.filter((a) => a.noteIdentifier === noteIdentifier.toUpperCase());
+    const slice = anchors.slice(offset, offset + limit);
+    const next = offset + slice.length;
+    return successResponse(`${anchors.length} anchor(s); returned ${slice.length}.`, {
+      anchors: slice.map((a) => ({ ...a })),
+      total: anchors.length,
+      registry: registry2.path,
+      page: {
+        offset,
+        returned: slice.length,
+        hasMore: next < anchors.length,
+        ...next < anchors.length ? { nextOffset: next } : {}
+      }
     });
-  }, "No paragraph link")
+  }, "Error listing paragraph anchors")
+);
+registerTool(
+  "get-paragraph-anchor",
+  {
+    description: "Use when: inspecting one recorded anchor as stored.\nReturns: the stored anchor record.\nDo not use when: you need the paragraph's current location or link (resolve-paragraph-anchor).\nSafety: read-only; reads only the local anchor registry, never Notes.",
+    inputSchema: { anchorId: anchorIdInput },
+    outputSchema: { anchor: external_exports.record(external_exports.unknown()).optional() },
+    annotations: { readOnlyHint: true }
+  },
+  withErrorHandling(({ anchorId }) => {
+    const anchor = new AnchorRegistry().get(anchorId);
+    return successResponse(
+      `Anchor ${anchor.anchorId}: note ${anchor.noteIdentifier}, block ${anchor.blockIndex}, recorded ${anchor.createdAt}.`,
+      { anchor: { ...anchor } }
+    );
+  }, "Error reading paragraph anchor")
+);
+registerTool(
+  "prune-paragraph-anchors",
+  {
+    description: "Use when: cleaning up anchors that no longer resolve, or removing specific anchors.\nReturns: the stale anchors found (anchorId, status, message), how many were examined, and the ids removed (none on a dry run).\nDo not use when: an anchor is only ambiguous or needs reminting; it still points at something.\nSafety: dryRun defaults to true, so nothing is removed until you call again with dryRun false. Removes entries from the local anchor registry only; never changes Notes. Without anchorIds it resolves every anchor in scope (Full Disk Access) and treats not-found and note-not-found as stale unless statuses says otherwise. A note in Recently Deleted gives note-deleted, which is not pruned by default because the note can be restored.",
+    inputSchema: {
+      anchorIds: external_exports.array(anchorIdInput).min(1).max(1e3).optional().describe("Remove exactly these anchors instead of resolving to find stale ones"),
+      noteIdentifier: noteIdentifierInput.describe("Only anchors in the note with this Notes UUID"),
+      statuses: external_exports.array(
+        external_exports.enum([
+          "not-found",
+          "note-not-found",
+          "note-deleted",
+          "note-unreadable",
+          "ambiguous",
+          "low-confidence"
+        ])
+      ).min(1).optional().describe(
+        `Resolution statuses treated as stale (default ${DEFAULT_PRUNE_STATUSES.join(", ")})`
+      ),
+      dryRun: external_exports.boolean().optional().describe("Report without removing (default true)")
+    },
+    outputSchema: {
+      dryRun: external_exports.boolean().optional(),
+      examined: external_exports.number().optional(),
+      stale: external_exports.array(external_exports.record(external_exports.unknown())).optional(),
+      removed: external_exports.array(external_exports.string()).optional()
+    },
+    annotations: { readOnlyHint: false, destructiveHint: true }
+  },
+  withErrorHandling(({ anchorIds, noteIdentifier, statuses, dryRun }) => {
+    const result = pruneParagraphAnchors({ anchorIds, noteIdentifier, statuses, dryRun });
+    return successResponse(
+      result.dryRun ? `Dry run: ${result.stale.length} of ${result.examined} anchor(s) would be removed.` : `Removed ${result.removed.length} of ${result.examined} anchor(s).`,
+      { ...result }
+    );
+  }, "Error pruning paragraph anchors")
 );
 registerTool(
   "get-note-structure",