apple-notes-mcp 2.11.0 → 2.12.0

package/README.md

@@ -2886,6 +2886,45 @@ Every tool that does not read the Notes database works normally without Full Dis
 
 ---
 
+## Permissions check
+
+`apple-notes-mcp setup --permissions` checks, in one report, the four grants that decide what the server can do on this Mac:
+
+| Item | How it is checked | Needed for |
+|------|-------------------|------------|
+| Full Disk Access | one read-only `SELECT 1` against `NoteStore.sqlite` | every database-backed tool (see [Full Disk Access](#full-disk-access)) |
+| Automation of Notes.app | one read-only Apple event (the first account's name), sent only with `--probe-automation` | every AppleScript tool |
+| Shortcut bridges (optional) | `shortcuts list`, like `setup --check` | the native-write tools |
+| Speech Recognition (optional) | the public helper's `speech_status`, read without prompting | `transcribe-note-audio` before macOS 26 |
+
+```bash
+apple-notes-mcp setup --permissions          # report, then press Enter to check again
+apple-notes-mcp setup --permissions --open   # also open the System Settings pane of each missing grant
+apple-notes-mcp setup --permissions --once   # report once and exit (also --json)
+apple-notes-mcp setup --permissions --probe-automation   # also check Automation (sends one Apple event)
+```
+
+For each missing grant the report names the System Settings pane and its URL, for example `x-apple.systempreferences:com.apple.settings.PrivacySecurity.extension?Privacy_AllFiles` (the `com.apple.preference.security` form before macOS 13). Panes open only with `--open`, each once per run. The command never changes a setting or a grant: you make the change in System Settings, then press Enter to check again. Type `q` to stop. It exits 1 when a required grant is missing or could not be verified, and 0 otherwise, so a run that did not probe Automation exits 0 if Full Disk Access is granted.
+
+Automation is the one item that cannot be read without talking to Notes.app, so it is opt-in. By default the command sends no Apple event, and the Automation line reads `unknown` (not probed) with the command that checks it. Add `--probe-automation` to send one read-only event; the first time, macOS may ask whether the app may control Notes, and **Allow** is the only way to add an Automation grant. The probe never runs under `--check` (which reports state only) or when `SSH_CONNECTION` is set, because nobody at the remote shell can answer the prompt. In those cases the line reads `unknown` even if `--probe-automation` was passed. An unprobed Automation line does not change the exit code and the report says Automation was not checked, so run the probe from a terminal on the Mac itself when you need to know. A probe that runs and fails (denied, or no answer) does exit 1.
+
+macOS attributes these grants to the app that launched the process, so the report names it (for example `/Applications/iTerm.app`). Run the check from the app you use as the MCP host when you can. Claude Desktop launches servers as their own responsible process, so for it use the `doctor` tool inside Claude Desktop, and add the Node binary it names to Full Disk Access. The Speech item reads `unknown` until the [public native helper](#public-native-helper) is built.
+
+### Optional checklist window
+
+The same checklist is also available in a small window with **Open Settings** and **Re-check** buttons. Like the public helper, it is built on your Mac from the packaged Swift source, never shipped as a binary:
+
+```bash
+apple-notes-mcp setup --permissions-window           # compile, ad-hoc sign, verify, install
+apple-notes-mcp setup --permissions-window --check   # report the installed state only
+apple-notes-mcp setup --permissions --window         # open the window
+apple-notes-mcp setup --permissions --window --probe-automation   # the window's checks include Automation
+```
+
+Setup compiles `native/permissions-window/apple-notes-permissions-window.swift`, signs it ad hoc, runs its `hello` handshake (which shows no window), and installs it in `~/Library/Application Support/apple-notes-mcp/permissions-window/` with a manifest of source and binary SHA-256 digests; `APPLE_NOTES_MCP_PERMISSIONS_WINDOW_DIR` overrides the folder. The window probes nothing itself. The command runs every check and sends the results to it, and opens a pane only for an item it reported. The window shows an unprobed Automation item as "Not checked", with the command that checks it, and gives it no Open Settings button. If the window is not built, is stale after an upgrade, or was modified, `--window` says so and shows the checklist in the terminal instead. The server never uses the window.
+
+---
+
 ## Public native helper
 
 `get-note-drawings` needs Apple's PencilKit framework and `transcribe-note-audio` needs the Speech framework; neither has an AppleScript or command-line interface. For them, the server uses a small Swift helper that links public Apple frameworks only (AppKit, PencilKit, AVFoundation, and Speech). No prebuilt binary ships with the package. Build it once on your Mac:
@@ -2990,6 +3029,7 @@ In a JSON string literal the two characters `\\` denote **one** literal backslas
 - macOS needs automation permission
 - Go to System Settings > Privacy & Security > Automation
 - Ensure your terminal/Claude has permission to control Notes
+- `apple-notes-mcp setup --permissions --open --probe-automation` checks every grant and opens the pane of each missing one ([Permissions check](#permissions-check))
 
 ### Native writes time out or report an uncertain outcome
 - Symptom: `add-native-tags`, `set-note-pinned`, `append-native` or another native write fails with "Shortcuts timed out waiting for …", "Operation outcome uncertain" or "readback was not verified", while `doctor` and `get-capabilities` report the bridges installed

package/build/index.js

@@ -24477,14 +24477,14 @@ var require_turndown_cjs = __commonJS({
         } else if (node.nodeType === 1) {
           replacement = replacementForNode.call(self, node);
         }
-        return join31(output, replacement);
+        return join32(output, replacement);
       }, "");
     }
     function postProcess(output) {
       var self = this;
       this.rules.forEach(function(rule) {
         if (typeof rule.append === "function") {
-          output = join31(output, rule.append(self.options));
+          output = join32(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 join31(output, replacement) {
+    function join32(output, replacement) {
       var s1 = trimTrailingNewlines(output);
       var s2 = trimLeadingNewlines(replacement);
       var nls = Math.max(output.length - s1.length, replacement.length - s2.length);
@@ -51023,13 +51023,13 @@ var SidecarWriter = class {
         }
         this.created = true;
       }
-      const safe = safeAssetName(name, mime);
-      const ext = extname3(safe);
-      const stem = safe.slice(0, safe.length - ext.length);
+      const safe2 = safeAssetName(name, mime);
+      const ext = extname3(safe2);
+      const stem = safe2.slice(0, safe2.length - ext.length);
       let target;
       let out;
       for (let n = 1; n <= 1e3 && out === void 0; n++) {
-        target = join19(this.dir, n === 1 ? safe : `${stem}-${n}${ext}`);
+        target = join19(this.dir, n === 1 ? safe2 : `${stem}-${n}${ext}`);
         try {
           out = openSync4(target, CREATE_FLAGS, 420);
         } catch (error2) {
@@ -51714,7 +51714,8 @@ var PUBLIC_HELPER_SETUP_COMMAND = "apple-notes-mcp setup --public-helper";
 var PUBLIC_HELPER_ACTIONS = /* @__PURE__ */ new Set([
   "hello",
   "decode_drawing",
-  "transcribe"
+  "transcribe",
+  "speech_status"
 ]);
 var DEFAULT_TIMEOUT_MS2 = 3e4;
 var MAX_OUTPUT_BYTES2 = 256 * 1024 * 1024;
@@ -52888,16 +52889,16 @@ var NOTE_PLACEHOLDERS = [
   "exportStem"
 ];
 var PLACEHOLDER_MODIFIERS = ["raw", "yaml"];
-var wrap2 = (before, after = "", join31) => ({
+var wrap2 = (before, after = "", join32) => ({
   mode: "wrap",
   before,
   after,
-  ...join31 ? { join: join31 } : {}
+  ...join32 ? { join: join32 } : {}
 });
-var pattern = (value, join31) => ({
+var pattern = (value, join32) => ({
   mode: "pattern",
   value,
-  ...join31 ? { join: join31 } : {}
+  ...join32 ? { join: join32 } : {}
 });
 var STANDARD = {
   schemaVersion: 1,
@@ -53969,12 +53970,12 @@ function pathComponent(value) {
   return clean || "untitled";
 }
 function templateAssetsDir(directory, outputDir, values) {
-  const safe = {};
+  const safe2 = {};
   for (const [key, value] of Object.entries(values)) {
     const raw = typeof value === "string" ? value : value?.raw;
-    if (raw !== void 0) safe[key] = pathComponent(raw);
+    if (raw !== void 0) safe2[key] = pathComponent(raw);
   }
-  const filled = fillPlaceholders(directory, safe);
+  const filled = fillPlaceholders(directory, safe2);
   const base = resolve5(outputDir);
   const dir = resolve5(base, filled);
   if (isAbsolute3(filled) || filled.split("/").includes("..") || !dir.startsWith(base + sep4))
@@ -59405,6 +59406,710 @@ function formatHelperBuild(report) {
   return lines.join("\n");
 }
 
+// src/services/permissions.ts
+import { spawnSync as spawnSync6 } from "node:child_process";
+import { createInterface } from "node:readline";
+var PRIVACY = "System Settings > Privacy & Security";
+var PANE_ANCHORS = {
+  fullDiskAccess: { anchor: "Privacy_AllFiles", label: "Full Disk Access" },
+  automation: { anchor: "Privacy_Automation", label: "Automation" },
+  speechRecognition: { anchor: "Privacy_SpeechRecognition", label: "Speech Recognition" }
+};
+function settingsUrl(pane, macOSVersion) {
+  const legacy = macOSVersion !== null && compareVersions(macOSVersion, "13.0") < 0;
+  const base = legacy ? "x-apple.systempreferences:com.apple.preference.security" : "x-apple.systempreferences:com.apple.settings.PrivacySecurity.extension";
+  return `${base}?${PANE_ANCHORS[pane].anchor}`;
+}
+function paneFields(pane, macOSVersion) {
+  return {
+    settingsPane: `${PRIVACY} > ${PANE_ANCHORS[pane].label}`,
+    settingsUrl: settingsUrl(pane, macOSVersion)
+  };
+}
+function defaultCheckOptions() {
+  return { probeAutomation: false, check: false, env: process.env };
+}
+function automationSkipReason(options) {
+  if (!options.probeAutomation)
+    return "this check sends no Apple event to Notes.app unless you pass --probe-automation";
+  if (options.env.SSH_CONNECTION)
+    return "this is an SSH session, where macOS cannot show its permission prompt, so no Apple event was sent";
+  if (options.check)
+    return "--check reports state only and never sends an Apple event to Notes.app";
+  return null;
+}
+function checkPermissions(probes = defaultPermissionProbes(), options = defaultCheckOptions()) {
+  const macOSVersion = safe(probes.macOSVersion, null);
+  const launchingApp = safe(probes.launchingApp, null);
+  const who = launchingApp ?? "the app that launches the server";
+  const items = [
+    fullDiskAccessItem(probes, macOSVersion),
+    automationItem(probes, macOSVersion, who, automationSkipReason(options)),
+    shortcutsItem(probes),
+    speechItem(probes, macOSVersion, who)
+  ];
+  return {
+    ready: items.every((item) => !item.required || item.status === "granted" || item.notProbed),
+    launchingApp,
+    execPath: probes.execPath,
+    macOSVersion,
+    items
+  };
+}
+function safe(fn, fallback) {
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+}
+function errorText(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+function fullDiskAccessItem(probes, macOSVersion) {
+  const base = {
+    id: "fullDiskAccess",
+    title: "Full Disk Access",
+    required: true,
+    ...paneFields("fullDiskAccess", macOSVersion)
+  };
+  let granted;
+  try {
+    granted = probes.fullDiskAccess();
+  } catch (error2) {
+    return {
+      ...base,
+      status: "unknown",
+      detail: `could not probe the Notes database: ${errorText(error2)}`,
+      fix: fdaRemediation(probes.execPath)
+    };
+  }
+  return granted ? {
+    ...base,
+    status: "granted",
+    detail: "the Notes database (NoteStore.sqlite) is readable",
+    fix: null
+  } : {
+    ...base,
+    status: "missing",
+    detail: "the Notes database is not readable, so query-notes, checklist state, note metadata, note links, native objects, exports and the bridges' readback do not work",
+    fix: fdaRemediation(probes.execPath)
+  };
+}
+var PROBE_AUTOMATION_COMMAND = "apple-notes-mcp setup --permissions --probe-automation";
+function automationItem(probes, macOSVersion, who, skipReason) {
+  const base = {
+    id: "notesAutomation",
+    title: "Automation of Notes.app",
+    required: true,
+    ...paneFields("automation", macOSVersion)
+  };
+  if (skipReason !== null)
+    return {
+      ...base,
+      status: "unknown",
+      detail: `not probed: ${skipReason}`,
+      fix: `On this Mac, in a terminal, run \`${PROBE_AUTOMATION_COMMAND}\`. It sends one read-only Apple event to Notes.app, and macOS may ask whether this app may control Notes; choose Allow.`,
+      notProbed: true
+    };
+  let result;
+  try {
+    result = probes.notesAutomation();
+  } catch (error2) {
+    result = { success: false, error: errorText(error2) };
+  }
+  if (result.success)
+    return {
+      ...base,
+      status: "granted",
+      detail: "Notes.app answered a read-only Apple event",
+      fix: null
+    };
+  if (isPermissionDenied(result.error))
+    return {
+      ...base,
+      status: "missing",
+      detail: "macOS refused the Apple event to Notes.app (Automation denied)",
+      fix: `In ${PRIVACY} > Automation, expand ${who} and turn on Notes. Then fully quit (Cmd+Q) and relaunch that app. If Notes is not listed, run this check again and choose Allow when macOS asks to control Notes.`
+    };
+  return {
+    ...base,
+    status: "unknown",
+    detail: `Notes.app did not answer: ${result.error || "no response"}`,
+    fix: "Open Notes.app once, then run this check again. If macOS asks whether this app may control Notes, choose Allow."
+  };
+}
+function shortcutsItem(probes) {
+  const base = {
+    id: "shortcutBridges",
+    title: "Shortcut bridges",
+    required: false,
+    settingsPane: null,
+    settingsUrl: null
+  };
+  let report;
+  try {
+    report = probes.shortcuts();
+  } catch (error2) {
+    return {
+      ...base,
+      status: "unknown",
+      detail: `could not run the shortcuts command: ${errorText(error2)}`,
+      fix: "Run `apple-notes-mcp setup --check`."
+    };
+  }
+  const required2 = report.items.filter((item) => !item.optional);
+  const failed = required2.filter((item) => item.error && !item.installed);
+  const missing = required2.filter((item) => !item.installed);
+  const consent = "After install or upgrade, run each bridge once in Shortcuts.app and choose Always Allow.";
+  if (missing.length === 0)
+    return {
+      ...base,
+      status: "granted",
+      detail: `both required bridges are installed (${required2.map((item) => item.name).join(", ")}). ${consent}`,
+      fix: null
+    };
+  if (failed.length === missing.length && failed.length > 0)
+    return {
+      ...base,
+      status: "unknown",
+      detail: `could not inspect: ${failed.map((item) => `${item.name}: ${item.error}`).join("; ")}`,
+      fix: "Run `apple-notes-mcp setup --check`."
+    };
+  return {
+    ...base,
+    status: "missing",
+    detail: `not installed: ${missing.map((item) => item.name).join(", ")}. The native-write tools (append-native, checklists, tables, native tags, pinning, note links) need them; everything else works without them`,
+    fix: `Run \`apple-notes-mcp setup\` and approve Add Shortcut in macOS. ${consent}`
+  };
+}
+function speechItem(probes, macOSVersion, who) {
+  const base = {
+    id: "speechRecognition",
+    title: "Speech Recognition",
+    required: false,
+    ...paneFields("speechRecognition", macOSVersion)
+  };
+  let answer;
+  try {
+    answer = probes.speech();
+  } catch (error2) {
+    answer = { ok: false, reason: errorText(error2) };
+  }
+  if (!answer.ok)
+    return {
+      ...base,
+      status: "unknown",
+      detail: `only transcribe-note-audio needs this; could not read the status: ${answer.reason}`,
+      fix: `Build the public native helper with \`${PUBLIC_HELPER_SETUP_COMMAND}\`, then run this check again.`
+    };
+  const state = answer.speechAuthorization;
+  if (state === "authorized")
+    return {
+      ...base,
+      status: "granted",
+      detail: "transcribe-note-audio can use on-device speech recognition",
+      fix: null
+    };
+  if (state === "restricted")
+    return {
+      ...base,
+      status: "missing",
+      detail: "Speech Recognition is restricted on this Mac (for example by a management profile)",
+      fix: "Ask the Mac's administrator; the restriction cannot be lifted in System Settings."
+    };
+  if (state === "denied")
+    return {
+      ...base,
+      status: "missing",
+      detail: "Speech Recognition was denied, so transcribe-note-audio stops with permission_required",
+      fix: `In ${PRIVACY} > Speech Recognition, turn on ${who}, then relaunch it.`
+    };
+  if (!answer.requiresGrant)
+    return {
+      ...base,
+      status: "not_needed",
+      detail: "not granted, and not needed: on macOS 26 and later transcription runs on-device without a Speech Recognition grant",
+      fix: null
+    };
+  return {
+    ...base,
+    status: "missing",
+    detail: `status ${state}. Before macOS 26, transcription needs this grant, and the server never shows the permission prompt`,
+    fix: `In ${PRIVACY} > Speech Recognition, turn on ${who} if it is listed, then relaunch it.`
+  };
+}
+function findLaunchingApp(startPid = process.ppid, readProcess = readProcessEntry) {
+  let pid = startPid;
+  for (let depth = 0; depth < 32 && pid > 1; depth++) {
+    const entry = readProcess(pid);
+    if (!entry) return null;
+    const match = /^(.*?\.app)\//.exec(entry.command);
+    if (match) return match[1];
+    pid = entry.ppid;
+  }
+  return null;
+}
+function readProcessEntry(pid) {
+  const result = spawnSync6("/bin/ps", ["-o", "ppid=", "-o", "comm=", "-p", String(pid)], {
+    encoding: "utf8",
+    timeout: 3e3
+  });
+  const match = /^\s*(\d+)\s+(.+)$/.exec(String(result.stdout ?? "").trim());
+  return match ? { ppid: Number(match[1]), command: match[2] } : null;
+}
+var AUTOMATION_TIMEOUT_MS = 6e4;
+function defaultPermissionProbes() {
+  return {
+    fullDiskAccess: hasFullDiskAccess,
+    notesAutomation: () => {
+      const result = executeAppleScript('tell application "Notes" to get name of account 1', {
+        timeoutMs: AUTOMATION_TIMEOUT_MS,
+        maxRetries: 1
+      });
+      return { success: result.success, error: result.error };
+    },
+    shortcuts: () => setupShortcuts(true),
+    speech: () => {
+      const install = inspectPublicHelper();
+      if (!install.ready)
+        return { ok: false, reason: install.detail ?? "the public native helper is not built" };
+      const answer = callPublicHelper("speech_status");
+      return {
+        ok: true,
+        speechAuthorization: String(answer.speechAuthorization ?? "unknown"),
+        requiresGrant: answer.requiresGrant !== false
+      };
+    },
+    macOSVersion: readMacOSVersion,
+    launchingApp: () => findLaunchingApp(),
+    execPath: process.execPath
+  };
+}
+function openSettingsPane(item, open = openUrl) {
+  if (!item.settingsUrl || !item.settingsUrl.startsWith("x-apple.systempreferences:"))
+    return { ok: false, error: `${item.title} has no System Settings pane` };
+  return open(item.settingsUrl);
+}
+function openUrl(url) {
+  const result = spawnSync6("/usr/bin/open", [url], { encoding: "utf8" });
+  return result.status === 0 ? { ok: true } : { ok: false, error: result.stderr || result.error?.message || "open failed" };
+}
+function pendingItems(report) {
+  return report.items.filter(
+    (item) => !item.notProbed && (item.status === "missing" || item.status === "unknown")
+  );
+}
+var ICONS = {
+  granted: "\u2713",
+  not_needed: "\u2713",
+  missing: "\u2717",
+  unknown: "?"
+};
+function formatPermissionsReport(report) {
+  const lines = ["Apple Notes MCP permissions", ""];
+  lines.push(
+    report.launchingApp ? `macOS attributes these grants to ${report.launchingApp}, the app that launched this check.` : `No launching app was found above this process, so macOS attributes these grants to ${report.execPath}.`
+  );
+  lines.push(
+    "An MCP host (Claude Desktop, an editor) can hold different grants: run this check from the same app, or use the doctor tool there.",
+    ""
+  );
+  for (const item of report.items) {
+    const tag = item.required ? "" : " (optional)";
+    lines.push(`${ICONS[item.status]} ${item.title}${tag}: ${item.detail}`);
+    if (item.notProbed) {
+      if (item.fix) lines.push(`    To check: ${item.fix}`);
+    } else if (item.status === "missing" || item.status === "unknown") {
+      if (item.settingsPane) lines.push(`    Pane: ${item.settingsPane}`);
+      if (item.settingsUrl) lines.push(`    URL:  ${item.settingsUrl}`);
+      if (item.fix) lines.push(`    Fix:  ${item.fix}`);
+    }
+  }
+  lines.push("");
+  const unchecked = report.items.some((item) => item.notProbed);
+  lines.push(
+    !report.ready ? "Required permissions are missing; the server works only partly until they are granted." : unchecked ? "Every required permission that was checked is granted. Automation of Notes.app was not checked." : "Every required permission is granted."
+  );
+  return lines.join("\n");
+}
+function parsePermissionsArgs(args) {
+  return {
+    open: args.includes("--open"),
+    once: args.includes("--once") || args.includes("--check"),
+    json: args.includes("--json"),
+    probeAutomation: args.includes("--probe-automation"),
+    check: args.includes("--check")
+  };
+}
+async function runPermissionsCli(options, deps) {
+  const opened = /* @__PURE__ */ new Set();
+  for (; ; ) {
+    const report = deps.check();
+    deps.write(
+      options.json ? JSON.stringify(report, null, 2) + "\n" : formatPermissionsReport(report) + "\n"
+    );
+    const pending = pendingItems(report);
+    if (options.open) {
+      for (const item of pending) {
+        if (!item.settingsUrl || opened.has(item.id)) continue;
+        opened.add(item.id);
+        const result = deps.open(item);
+        if (!options.json)
+          deps.write(
+            result.ok ? `Opened ${item.settingsPane}.
+` : `Could not open ${item.settingsPane}: ${result.error}
+`
+          );
+      }
+    }
+    if (pending.length === 0 || options.once || !deps.interactive) return report.ready ? 0 : 1;
+    deps.write("\nPress Enter to check again, or type q and press Enter to quit. ");
+    const line = await deps.waitForEnter();
+    if (line === null || line.trim().toLowerCase() === "q") return report.ready ? 0 : 1;
+    deps.write("\n");
+  }
+}
+function defaultPermissionsCliDeps(options) {
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const rl = interactive ? createInterface({ input: process.stdin }) : null;
+  const lines = [];
+  const waiters = [];
+  let closed = false;
+  rl?.on("line", (line) => {
+    const waiter = waiters.shift();
+    if (waiter) waiter(line);
+    else lines.push(line);
+  });
+  rl?.on("close", () => {
+    closed = true;
+    for (const waiter of waiters.splice(0)) waiter(null);
+  });
+  return {
+    check: () => checkPermissions(defaultPermissionProbes(), {
+      probeAutomation: options.probeAutomation,
+      check: options.check,
+      env: process.env
+    }),
+    open: (item) => openSettingsPane(item),
+    write: (text2) => process.stdout.write(text2),
+    waitForEnter: () => new Promise((resolveLine) => {
+      if (lines.length) resolveLine(lines.shift());
+      else if (closed || !rl) resolveLine(null);
+      else waiters.push(resolveLine);
+    }),
+    interactive,
+    close: () => rl?.close()
+  };
+}
+
+// src/services/permissionsWindow.ts
+import { spawn as spawn2, spawnSync as spawnSync7 } from "node:child_process";
+import {
+  chmodSync as chmodSync3,
+  existsSync as existsSync17,
+  mkdirSync as mkdirSync10,
+  mkdtempSync as mkdtempSync9,
+  readFileSync as readFileSync6,
+  renameSync as renameSync4,
+  rmSync as rmSync9,
+  writeFileSync as writeFileSync8
+} from "node:fs";
+import { homedir as homedir22 } from "node:os";
+import { join as join31 } from "node:path";
+import { createInterface as createInterface2 } from "node:readline";
+var PERMISSIONS_WINDOW_PROTOCOL = 1;
+var PERMISSIONS_WINDOW_DIR_ENV = "APPLE_NOTES_MCP_PERMISSIONS_WINDOW_DIR";
+var PERMISSIONS_WINDOW_BINARY = "apple-notes-permissions-window";
+var PERMISSIONS_WINDOW_SOURCE = "native/permissions-window/apple-notes-permissions-window.swift";
+var PERMISSIONS_WINDOW_MANIFEST = "manifest.json";
+var PERMISSIONS_WINDOW_SETUP_COMMAND = "apple-notes-mcp setup --permissions-window";
+var PERMISSIONS_WINDOW_BUNDLE_ID = "apple-notes-mcp.permissions-window";
+var windowManifestSchema = external_exports.object({
+  schemaVersion: external_exports.literal(1),
+  protocolVersion: external_exports.number().int(),
+  sourceSha256: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  binarySha256: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  builtAt: external_exports.string(),
+  compiler: external_exports.string()
+});
+function defaultPermissionsWindowDeps(overrides = {}) {
+  return {
+    env: process.env,
+    platform: process.platform,
+    sourcePath: join31(packageRoot(), PERMISSIONS_WINDOW_SOURCE),
+    exists: existsSync17,
+    readFile: (path10) => readFileSync6(path10),
+    spawn: spawnSync7,
+    now: () => /* @__PURE__ */ new Date(),
+    ...overrides
+  };
+}
+function permissionsWindowInstallDir(env = process.env) {
+  const override = env[PERMISSIONS_WINDOW_DIR_ENV]?.trim();
+  if (override) return override;
+  return join31(homedir22(), "Library", "Application Support", "apple-notes-mcp", "permissions-window");
+}
+function inspectPermissionsWindow(deps = defaultPermissionsWindowDeps()) {
+  const installDir = permissionsWindowInstallDir(deps.env);
+  const binaryPath = join31(installDir, PERMISSIONS_WINDOW_BINARY);
+  const fail = (reason, detail) => ({ ready: false, reason, detail, installDir, binaryPath });
+  if (deps.platform !== "darwin") return fail("unsupported_platform", "macOS only");
+  const rebuild = `Run \`${PERMISSIONS_WINDOW_SETUP_COMMAND}\`.`;
+  if (!deps.exists(deps.sourcePath))
+    return fail("window_not_installed", `Packaged window source is missing: ${deps.sourcePath}`);
+  const manifestPath = join31(installDir, PERMISSIONS_WINDOW_MANIFEST);
+  if (!deps.exists(binaryPath) || !deps.exists(manifestPath))
+    return fail("window_not_installed", `The permissions window is not built. ${rebuild}`);
+  let manifest;
+  try {
+    manifest = windowManifestSchema.parse(JSON.parse(deps.readFile(manifestPath).toString("utf8")));
+  } catch {
+    return fail("window_manifest_invalid", `The window manifest is unreadable. ${rebuild}`);
+  }
+  if (manifest.sourceSha256 !== sha256Hex(deps.readFile(deps.sourcePath)) || manifest.protocolVersion !== PERMISSIONS_WINDOW_PROTOCOL)
+    return fail(
+      "window_stale",
+      `The installed window was built from a different source than this version ships. ${rebuild}`
+    );
+  if (sha256Hex(deps.readFile(binaryPath)) !== manifest.binarySha256)
+    return fail(
+      "window_modified",
+      `The window binary no longer matches the checksum recorded when it was built. ${rebuild}`
+    );
+  return { ready: true, reason: null, detail: null, installDir, binaryPath };
+}
+function permissionsWindowInfoPlist() {
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    '<plist version="1.0">',
+    "<dict>",
+    "  <key>CFBundleIdentifier</key>",
+    `  <string>${PERMISSIONS_WINDOW_BUNDLE_ID}</string>`,
+    "  <key>CFBundleName</key>",
+    "  <string>Apple Notes MCP Permissions</string>",
+    "  <key>CFBundleInfoDictionaryVersion</key>",
+    "  <string>6.0</string>",
+    "</dict>",
+    "</plist>",
+    ""
+  ].join("\n");
+}
+function permissionsWindowCompileArguments(sourcePath, digestPath, plistPath, outputPath) {
+  return [
+    "swiftc",
+    "-O",
+    "-parse-as-library",
+    "-framework",
+    "AppKit",
+    "-framework",
+    "SwiftUI",
+    "-Xlinker",
+    "-sectcreate",
+    "-Xlinker",
+    "__TEXT",
+    "-Xlinker",
+    "__info_plist",
+    "-Xlinker",
+    plistPath,
+    sourcePath,
+    digestPath,
+    "-o",
+    outputPath
+  ];
+}
+var helloSchema2 = external_exports.object({
+  type: external_exports.literal("hello"),
+  protocolVersion: external_exports.number().int(),
+  sourceSha256: external_exports.string()
+});
+function buildPermissionsWindow(checkOnly, deps = defaultPermissionsWindowDeps()) {
+  const steps = [];
+  const finish = () => {
+    const installation2 = inspectPermissionsWindow(deps);
+    return {
+      ok: installation2.ready && steps.every((s) => s.ok),
+      checkOnly,
+      steps,
+      installation: installation2
+    };
+  };
+  if (checkOnly) {
+    const installation2 = inspectPermissionsWindow(deps);
+    steps.push({
+      step: "inspect installed window",
+      ok: installation2.ready,
+      detail: installation2.ready ? installation2.binaryPath : installation2.detail ?? void 0
+    });
+    return finish();
+  }
+  if (deps.platform !== "darwin") {
+    steps.push({ step: "platform", ok: false, detail: "macOS only" });
+    return finish();
+  }
+  if (!deps.exists(deps.sourcePath)) {
+    steps.push({ step: "locate source", ok: false, detail: deps.sourcePath });
+    return finish();
+  }
+  const sourceSha = sha256Hex(deps.readFile(deps.sourcePath));
+  steps.push({ step: "locate source", ok: true, detail: `sha256 ${sourceSha}` });
+  const version3 = deps.spawn("/usr/bin/xcrun", ["swiftc", "--version"], { encoding: "utf8" });
+  if (version3.status !== 0) {
+    steps.push({
+      step: "find compiler",
+      ok: false,
+      detail: "No Swift compiler found. Install the Command Line Tools with `xcode-select --install`."
+    });
+    return finish();
+  }
+  const compiler = String(version3.stdout || version3.stderr || "").split("\n").find((line) => line.includes("Swift version"))?.trim() || "swiftc";
+  steps.push({ step: "find compiler", ok: true, detail: compiler });
+  const installDir = permissionsWindowInstallDir(deps.env);
+  mkdirSync10(installDir, { recursive: true, mode: 448 });
+  const staging = mkdtempSync9(join31(installDir, ".staging-"));
+  try {
+    const stagedBinary = join31(staging, PERMISSIONS_WINDOW_BINARY);
+    const digestPath = join31(staging, "source-digest.swift");
+    const plistPath = join31(staging, "Info.plist");
+    writeFileSync8(digestPath, sourceDigestSwift(sourceSha), { mode: 384 });
+    writeFileSync8(plistPath, permissionsWindowInfoPlist(), { mode: 384 });
+    const compile = deps.spawn(
+      "/usr/bin/xcrun",
+      permissionsWindowCompileArguments(deps.sourcePath, digestPath, plistPath, stagedBinary),
+      { encoding: "utf8", timeout: 3e5 }
+    );
+    if (compile.status !== 0) {
+      steps.push({
+        step: "compile",
+        ok: false,
+        detail: String(compile.stderr || compile.error?.message || "swiftc failed").slice(0, 4e3)
+      });
+      return finish();
+    }
+    steps.push({ step: "compile", ok: true });
+    const sign = deps.spawn(
+      "/usr/bin/codesign",
+      ["--force", "--sign", "-", "--identifier", PERMISSIONS_WINDOW_BUNDLE_ID, stagedBinary],
+      { encoding: "utf8" }
+    );
+    if (sign.status !== 0) {
+      steps.push({ step: "ad-hoc sign", ok: false, detail: String(sign.stderr || "failed") });
+      return finish();
+    }
+    steps.push({ step: "ad-hoc sign", ok: true });
+    const hello = deps.spawn(stagedBinary, [], {
+      input: JSON.stringify({ type: "hello" }) + "\n",
+      encoding: "utf8",
+      timeout: 1e4,
+      killSignal: "SIGKILL"
+    });
+    let parsed = null;
+    try {
+      parsed = helloSchema2.parse(JSON.parse(String(hello.stdout ?? "").trim()));
+    } catch {
+      parsed = null;
+    }
+    if (!parsed || parsed.protocolVersion !== PERMISSIONS_WINDOW_PROTOCOL || parsed.sourceSha256 !== sourceSha) {
+      steps.push({
+        step: "handshake",
+        ok: false,
+        detail: parsed ? `window reported protocol ${parsed.protocolVersion}, source ${parsed.sourceSha256}` : `no valid hello (exit ${hello.status})`
+      });
+      return finish();
+    }
+    steps.push({ step: "handshake", ok: true });
+    const manifest = {
+      schemaVersion: 1,
+      protocolVersion: parsed.protocolVersion,
+      sourceSha256: sourceSha,
+      binarySha256: sha256Hex(deps.readFile(stagedBinary)),
+      builtAt: deps.now().toISOString(),
+      compiler
+    };
+    chmodSync3(stagedBinary, 448);
+    renameSync4(stagedBinary, join31(installDir, PERMISSIONS_WINDOW_BINARY));
+    writeFileSync8(
+      join31(installDir, PERMISSIONS_WINDOW_MANIFEST),
+      JSON.stringify(manifest, null, 2) + "\n",
+      { mode: 384 }
+    );
+    steps.push({ step: "install", ok: true, detail: installDir });
+  } finally {
+    rmSync9(staging, { recursive: true, force: true });
+  }
+  const installation = inspectPermissionsWindow(deps);
+  steps.push({
+    step: "verify installation",
+    ok: installation.ready,
+    detail: installation.ready ? void 0 : installation.detail ?? void 0
+  });
+  return finish();
+}
+function formatPermissionsWindowBuild(report) {
+  const lines = ["Apple Notes MCP permissions window", ""];
+  for (const step of report.steps)
+    lines.push(`${step.ok ? "\u2713" : "\u2717"} ${step.step}${step.detail ? `: ${step.detail}` : ""}`);
+  lines.push("");
+  if (report.ok)
+    lines.push(
+      `Installed at ${report.installation.binaryPath}. Open it with \`apple-notes-mcp setup --permissions --window\`.`
+    );
+  else if (report.checkOnly) lines.push(`Run \`${PERMISSIONS_WINDOW_SETUP_COMMAND}\` to build it.`);
+  else lines.push("The window was not installed. Fix the failed step above and run setup again.");
+  return lines.join("\n");
+}
+var windowMessageSchema = external_exports.discriminatedUnion("type", [
+  external_exports.object({ type: external_exports.literal("open"), id: external_exports.string().max(64) }),
+  external_exports.object({ type: external_exports.literal("recheck") })
+]);
+function runPermissionsWindow(binaryPath, session) {
+  const launch = session.launch ?? ((path10) => spawn2(path10, [], { stdio: ["pipe", "pipe", "inherit"] }));
+  const log = session.log ?? (() => {
+  });
+  let report = session.check();
+  const child2 = launch(binaryPath);
+  const sendReport = () => {
+    if (child2.stdin && !child2.stdin.destroyed)
+      child2.stdin.write(JSON.stringify({ type: "report", report }) + "\n");
+  };
+  child2.stdin?.on("error", () => {
+  });
+  sendReport();
+  if (child2.stdout) {
+    const lines = createInterface2({ input: child2.stdout });
+    lines.on("line", (line) => {
+      let message;
+      try {
+        message = windowMessageSchema.parse(JSON.parse(line));
+      } catch {
+        return;
+      }
+      if (message.type === "recheck") {
+        report = session.check();
+        sendReport();
+        return;
+      }
+      const item = report.items.find((candidate) => candidate.id === message.id);
+      if (!item || item.notProbed) return;
+      const result = session.open(item);
+      log(
+        result.ok ? `Opened ${item.settingsPane}.
+` : `Could not open ${item.settingsPane ?? item.title}: ${result.error}
+`
+      );
+    });
+  }
+  return new Promise((resolveExit) => {
+    child2.on("error", (error2) => {
+      log(`Could not run the permissions window: ${error2.message}
+`);
+      resolveExit(report.ready ? 0 : 1);
+    });
+    child2.on("close", () => resolveExit(report.ready ? 0 : 1));
+  });
+}
+
 // src/tools/privateHelperTools.ts
 var coreDataId2 = external_exports.string().regex(/^x-coredata:\/\/[0-9A-F-]+\/ICNote\/p\d+$/i);
 var notesUuid = external_exports.string().regex(UUID_PATTERN);
@@ -59528,6 +60233,32 @@ if (process.argv[2] === "setup" && process.argv.slice(3).includes("--native-help
   process.stdout.write(formatHelperBuild(report) + "\n");
   process.exit(report.ok ? 0 : 1);
 }
+if (process.argv[2] === "setup" && process.argv.slice(3).includes("--permissions-window")) {
+  const report = buildPermissionsWindow(process.argv.slice(3).includes("--check"));
+  process.stdout.write(formatPermissionsWindowBuild(report) + "\n");
+  process.exit(report.ok ? 0 : 1);
+}
+if (process.argv[2] === "setup" && process.argv.slice(3).includes("--permissions")) {
+  const args = process.argv.slice(3);
+  const options = parsePermissionsArgs(args);
+  const cli = defaultPermissionsCliDeps(options);
+  let code;
+  const window2 = args.includes("--window") ? inspectPermissionsWindow() : null;
+  if (window2?.ready) {
+    code = await runPermissionsWindow(window2.binaryPath, {
+      check: cli.check,
+      open: (item) => openSettingsPane(item),
+      log: cli.write
+    });
+  } else {
+    if (window2) cli.write(`${window2.detail} Showing the checklist here instead.
+
+`);
+    code = await runPermissionsCli(options, cli);
+  }
+  cli.close();
+  process.exit(code);
+}
 if (process.argv[2] === "setup") {
   const report = setupShortcuts(process.argv.slice(3).includes("--check"));
   process.stdout.write(formatShortcutSetup(report) + "\n");

package/native/permissions-window/apple-notes-permissions-window.swift

@@ -0,0 +1,215 @@
+// apple-notes-permissions-window
+//
+// An optional setup window for apple-notes-mcp. It shows the permissions
+// checklist that `apple-notes-mcp setup --permissions` prints, with an
+// "Open Settings" button per missing grant and a "Re-check" button. It probes
+// nothing itself: the TypeScript side runs every check and sends the results,
+// so the window and the terminal report always agree. It never reads the Notes
+// database, never sends Notes an Apple event, and never changes a setting.
+//
+// Protocol: JSON lines on stdin and stdout.
+//   in:  {"type": "hello"}                  answer the handshake and exit, no UI
+//   in:  {"type": "report", "report": {...}} show or refresh the checklist
+//   out: {"type": "hello", "protocolVersion": 1, "sourceSha256": "..."}
+//   out: {"type": "open", "id": "<item id>"}  the user asked to open that item's pane
+//   out: {"type": "recheck"}                  the user asked for a fresh check
+// The window closes when stdin ends; closing the window ends the process.
+//
+// Build (done by `apple-notes-mcp setup --permissions-window`, which also
+// generates the one-line source-digest file that defines helperSourceSHA256
+// and the Info.plist linked into __TEXT,__info_plist):
+//   xcrun swiftc -O -parse-as-library -framework AppKit -framework SwiftUI \
+//     -Xlinker -sectcreate -Xlinker __TEXT -Xlinker __info_plist -Xlinker Info.plist \
+//     apple-notes-permissions-window.swift source-digest.swift -o apple-notes-permissions-window
+
+import AppKit
+import Foundation
+import SwiftUI
+
+let protocolVersion = 1
+
+func send(_ object: [String: Any]) {
+    guard let data = try? JSONSerialization.data(withJSONObject: object, options: [.sortedKeys]) else { return }
+    FileHandle.standardOutput.write(data)
+    FileHandle.standardOutput.write(Data([0x0A]))
+}
+
+struct Item: Identifiable {
+    let id: String
+    let title: String
+    let status: String
+    let required: Bool
+    let detail: String
+    let settingsPane: String?
+    let hasSettings: Bool
+    let fix: String?
+    /// The command deliberately did not probe this item (Automation is opt-in).
+    let notProbed: Bool
+
+    init?(_ object: [String: Any]) {
+        guard let id = object["id"] as? String, let title = object["title"] as? String,
+              let status = object["status"] as? String else { return nil }
+        self.id = id
+        self.title = title
+        self.status = status
+        required = object["required"] as? Bool ?? false
+        detail = object["detail"] as? String ?? ""
+        settingsPane = object["settingsPane"] as? String
+        hasSettings = (object["settingsUrl"] as? String)?.hasPrefix("x-apple.systempreferences:") ?? false
+        fix = object["fix"] as? String
+        notProbed = object["notProbed"] as? Bool ?? false
+    }
+
+    var pending: Bool { !notProbed && (status == "missing" || status == "unknown") }
+}
+
+final class Model: ObservableObject {
+    @Published var items: [Item] = []
+    @Published var ready = false
+    @Published var launchingApp: String?
+    @Published var checking = false
+
+    func apply(_ report: [String: Any]) {
+        items = (report["items"] as? [[String: Any]] ?? []).compactMap(Item.init)
+        ready = report["ready"] as? Bool ?? false
+        launchingApp = report["launchingApp"] as? String
+        checking = false
+    }
+
+    func recheck() {
+        checking = true
+        send(["type": "recheck"])
+    }
+
+    func open(_ item: Item) {
+        send(["type": "open", "id": item.id])
+    }
+}
+
+struct StatusIcon: View {
+    let status: String
+    var body: some View {
+        switch status {
+        case "granted", "not_needed":
+            Image(systemName: "checkmark.circle.fill").foregroundStyle(.green)
+        case "missing":
+            Image(systemName: "xmark.circle.fill").foregroundStyle(.red)
+        case "not_checked":
+            Image(systemName: "minus.circle.fill").foregroundStyle(.secondary)
+        default:
+            Image(systemName: "questionmark.circle.fill").foregroundStyle(.orange)
+        }
+    }
+}
+
+struct ChecklistView: View {
+    @ObservedObject var model: Model
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 14) {
+            Text("Apple Notes MCP permissions").font(.title2).bold()
+            Text(model.launchingApp.map { "Grants shown are for \($0), the app that launched this check." }
+                ?? "Grants shown are for the process that launched this check.")
+                .font(.callout).foregroundStyle(.secondary)
+            ForEach(model.items) { item in
+                HStack(alignment: .top, spacing: 10) {
+                    StatusIcon(status: item.notProbed ? "not_checked" : item.status).font(.title3)
+                    VStack(alignment: .leading, spacing: 4) {
+                        Text(item.required ? item.title : "\(item.title) (optional)").font(.headline)
+                        if item.notProbed {
+                            Text("Not checked").font(.caption).bold().foregroundStyle(.secondary)
+                        }
+                        Text(item.detail).font(.callout).fixedSize(horizontal: false, vertical: true)
+                        if item.pending || item.notProbed, let fix = item.fix {
+                            Text(fix).font(.caption).foregroundStyle(.secondary)
+                                .fixedSize(horizontal: false, vertical: true)
+                                .textSelection(.enabled)
+                        }
+                    }
+                    Spacer(minLength: 8)
+                    if item.pending && item.hasSettings {
+                        Button("Open Settings") { model.open(item) }
+                            .help(item.settingsPane ?? "")
+                    }
+                }
+            }
+            Divider()
+            HStack {
+                Text(!model.ready ? "Required permissions are missing."
+                    : model.items.contains { $0.notProbed } ? "Every required permission that was checked is granted."
+                    : "Every required permission is granted.")
+                    .font(.callout)
+                Spacer()
+                if model.checking { ProgressView().controlSize(.small) }
+                Button("Re-check") { model.recheck() }
+                    .keyboardShortcut("r")
+                    .disabled(model.checking)
+            }
+        }
+        .padding(20)
+        .frame(width: 620)
+    }
+}
+
+final class AppDelegate: NSObject, NSApplicationDelegate, NSWindowDelegate {
+    let model = Model()
+    var window: NSWindow?
+
+    func applicationDidFinishLaunching(_ notification: Notification) {
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 620, height: 420),
+            styleMask: [.titled, .closable, .miniaturizable],
+            backing: .buffered,
+            defer: false
+        )
+        window.title = "Apple Notes MCP Permissions"
+        window.contentView = NSHostingView(rootView: ChecklistView(model: model))
+        window.delegate = self
+        window.center()
+        window.makeKeyAndOrderFront(nil)
+        self.window = window
+        NSApp.activate(ignoringOtherApps: true)
+    }
+
+    func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool { true }
+}
+
+/// Reads JSON lines from stdin on a background thread and hands reports to the UI.
+func readReports(into delegate: AppDelegate) {
+    Thread.detachNewThread {
+        while let line = readLine(strippingNewline: true) {
+            guard let data = line.data(using: .utf8),
+                  let message = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any],
+                  message["type"] as? String == "report",
+                  let report = message["report"] as? [String: Any] else { continue }
+            DispatchQueue.main.async { delegate.model.apply(report) }
+        }
+        // The server side went away: nothing can re-check any more.
+        DispatchQueue.main.async { NSApp.terminate(nil) }
+    }
+}
+
+@main
+struct PermissionsWindow {
+    static func main() {
+        guard let first = readLine(strippingNewline: true),
+              let data = first.data(using: .utf8),
+              let message = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any] else {
+            exit(2)
+        }
+        if message["type"] as? String == "hello" {
+            send(["type": "hello", "protocolVersion": protocolVersion, "sourceSha256": helperSourceSHA256])
+            exit(0)
+        }
+        guard message["type"] as? String == "report", let report = message["report"] as? [String: Any] else {
+            exit(2)
+        }
+        let app = NSApplication.shared
+        let delegate = AppDelegate()
+        app.delegate = delegate
+        app.setActivationPolicy(.regular)
+        delegate.model.apply(report)
+        readReports(into: delegate)
+        app.run()
+    }
+}

package/native/public-helper/apple-notes-public-helper.swift

@@ -17,6 +17,8 @@
 //   encode_drawing  strokes -> PencilKit drawing bytes (base64); used to build
 //                   synthetic test fixtures, never to write to Notes
 //   transcribe      on-device Speech transcription of one audio file
+//   speech_status   the Speech Recognition authorization status, read without
+//                   prompting, and whether transcription would need a grant
 //
 // Build (done by `apple-notes-mcp setup --public-helper`, which also generates
 // the one-line source-digest file that defines helperSourceSHA256 and the
@@ -613,9 +615,22 @@ func transcribe(_ request: [String: Any]) async throws -> [String: Any] {
     return response
 }
 
+/// Reports what `transcribe` would find, without asking for access. On
+/// macOS 26+ SpeechAnalyzer needs no grant, so only an explicit refusal
+/// blocks it; earlier releases use the legacy recognizer, which needs one.
+func speechStatus() -> [String: Any] {
+    var requiresGrant = true
+    if #available(macOS 26, *) { requiresGrant = false }
+    return [
+        "status": "ok",
+        "speechAuthorization": authorizationName(SFSpeechRecognizer.authorizationStatus()),
+        "requiresGrant": requiresGrant,
+    ]
+}
+
 // MARK: - Dispatch
 
-let actions = ["hello", "decode_drawing", "encode_drawing", "transcribe"]
+let actions = ["hello", "decode_drawing", "encode_drawing", "transcribe", "speech_status"]
 
 func handle(_ request: [String: Any]) async throws -> [String: Any] {
     guard (request["protocol"] as? NSNumber)?.intValue == protocolVersion else {
@@ -635,6 +650,8 @@ func handle(_ request: [String: Any]) async throws -> [String: Any] {
         return try encodeDrawing(request)
     case "transcribe":
         return try await transcribe(request)
+    case "speech_status":
+        return speechStatus()
     default:
         throw HelperFailure(code: "unknown_action", message: "unknown action")
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apple-notes-mcp",
-  "version": "2.11.0",
+  "version": "2.12.0",
   "description": "MCP server for Apple Notes - read, search, create, edit, organize, and export notes on macOS via Claude and other AI assistants",
   "type": "module",
   "main": "build/index.js",