seekstone 0.9.0 → 0.10.0

package/dist/index.js

@@ -10,13 +10,21 @@ import {
 
 // src/cli-args.ts
 function parseCliIntent(argv) {
-  if (argv[0] === "init") return "init";
+  if (argv[0] === "init") {
+    for (const arg of argv.slice(1)) {
+      if (arg === "--help" || arg === "-h") return "init-help";
+    }
+    return "init";
+  }
   for (const arg of argv) {
     if (arg === "--version" || arg === "-v") return "version";
     if (arg === "--help" || arg === "-h") return "help";
   }
   return "run";
 }
+var initOptionLines = `  --vault <path>       Vault to use (auto-detected from Obsidian if omitted; fallback: $SEEKSTONE_VAULT)
+  --client <name>      desktop (default) | code | cursor | vscode
+  --write              Patch the client config in place (backs it up first)`;
 function helpText(version) {
   return `seekstone ${version} \u2014 an Obsidian MCP server (filesystem-direct, low context-tax)
 
@@ -30,9 +38,7 @@ Usage:
   seekstone --help     Print this help and exit
 
 "seekstone init" options:
-  --vault <path>       Vault to use (auto-detected from Obsidian if omitted; fallback: $SEEKSTONE_VAULT)
-  --client <name>      desktop (default) | code | cursor | vscode
-  --write              Patch the client config in place (backs it up first)
+${initOptionLines}
 
 Required environment:
   SEEKSTONE_VAULT      Absolute path to your Obsidian vault
@@ -45,6 +51,25 @@ Optional environment:
 Add to Claude Code:
   claude mcp add seekstone --env SEEKSTONE_VAULT=/path/to/vault -- npx -y seekstone
 
+Docs: https://github.com/shaqmughal/seekstone`;
+}
+function initHelpText(version) {
+  return `seekstone ${version} \u2014 seekstone init
+
+Validate an Obsidian vault and print (or, with --write, patch) the MCP config
+for the chosen client (Claude Desktop, Claude Code, Cursor, VS Code).
+
+Usage:
+  seekstone init [options]
+
+Options:
+${initOptionLines}
+  --help, -h           Print this help and exit
+
+Examples:
+  seekstone init
+  seekstone init --vault "/Users/you/Obsidian/My Vault" --client code --write
+
 Docs: https://github.com/shaqmughal/seekstone`;
 }
 
@@ -117,6 +142,37 @@ function parseFrontmatter(text) {
 
 // src/tools/append_note.ts
 import { z } from "zod";
+
+// src/policy.ts
+import picomatch from "picomatch";
+function parseWritePolicy(env) {
+  const ro = (env.SEEKSTONE_READ_ONLY ?? "").toLowerCase();
+  const readOnly = ro === "1" || ro === "true";
+  const globs = (env.SEEKSTONE_WRITE_PATHS ?? "").split(",").map((g) => g.trim()).filter((g) => g.length > 0);
+  return globs.length > 0 ? { readOnly, writeGlobs: globs } : { readOnly };
+}
+function normalizeRel(relPath) {
+  let p = relPath.replaceAll("\\", "/");
+  while (p.startsWith("./")) p = p.slice(2);
+  return p;
+}
+function isWritable(policy2, relPath) {
+  if (policy2.readOnly) return false;
+  if (!policy2.writeGlobs) return true;
+  return picomatch(policy2.writeGlobs, { dot: true })(normalizeRel(relPath));
+}
+function assertWritable(policy2, relPath) {
+  if (policy2.readOnly) {
+    throw new Error("Server is read-only (SEEKSTONE_READ_ONLY=1); write tools are disabled.");
+  }
+  if (!isWritable(policy2, relPath)) {
+    throw new Error(
+      `Write not permitted: "${relPath}" is outside SEEKSTONE_WRITE_PATHS (${policy2.writeGlobs?.join(", ")}).`
+    );
+  }
+}
+
+// src/tools/append_note.ts
 var AppendNoteInput = z.object({
   path: z.string().describe("Vault-relative path to the note."),
   content: z.string().min(1).describe(
@@ -128,6 +184,7 @@ async function appendNote(ctx2, input) {
   if (!absPath.startsWith(ctx2.vaultRoot)) {
     throw new Error(`Path outside vault: ${input.path}`);
   }
+  assertWritable(ctx2.policy, input.path);
   const original = await readFile(absPath, "utf8");
   const fm = parseFrontmatter(original);
   const body = fm.body.endsWith("\n") ? fm.body : `${fm.body}
@@ -232,6 +289,7 @@ async function createNote(ctx2, input) {
   if (!absPath.startsWith(ctx2.vaultRoot)) {
     throw new Error(`Path outside vault: ${input.path}`);
   }
+  assertWritable(ctx2.policy, input.path);
   if (!input.overwrite) {
     try {
       await access(absPath);
@@ -265,6 +323,7 @@ async function deleteNote(ctx2, input) {
   if (!absPath.startsWith(ctx2.vaultRoot)) {
     throw new Error(`Path outside vault: ${input.path}`);
   }
+  assertWritable(ctx2.policy, input.path);
   await rm(absPath);
   if (ctx2.notes.has(input.path)) {
     ctx2.index.discard(input.path);
@@ -422,19 +481,149 @@ function listTags(ctx2, input) {
 }
 
 // src/tools/move_note.ts
-import { access as access2, mkdir as mkdir2, rename } from "fs/promises";
+import { access as access2, mkdir as mkdir2, rename, writeFile as writeFile3 } from "fs/promises";
 import { dirname as dirname2, join as join6 } from "path";
 import { z as z8 } from "zod";
+
+// src/index/backlinks.ts
+function removeNoteBacklinks(ctx2, relPath) {
+  const oldDoc = ctx2.notes.get(relPath);
+  if (oldDoc === void 0) return;
+  for (const link of extractLinksWithLines(oldDoc.raw)) {
+    const resolved = resolveLink(link.target, ctx2.notes);
+    if (resolved === void 0) continue;
+    const arr = ctx2.backlinks.get(resolved);
+    if (arr === void 0) continue;
+    const filtered = arr.filter((r) => r.path !== relPath);
+    ctx2.backlinks.set(resolved, filtered);
+  }
+}
+function addNoteBacklinks(ctx2, relPath, raw) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const link of extractLinksWithLines(raw)) {
+    const resolved = resolveLink(link.target, ctx2.notes);
+    if (resolved === void 0) continue;
+    const dedupeKey = `${relPath}\0${resolved}`;
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    let arr = ctx2.backlinks.get(resolved);
+    if (arr === void 0) {
+      arr = [];
+      ctx2.backlinks.set(resolved, arr);
+    }
+    const ref = { path: relPath, line: link.line, linkType: link.linkType };
+    arr.push(ref);
+    arr.sort((a, b) => a.path.localeCompare(b.path));
+  }
+}
+
+// src/tools/rewrite_links.ts
+import { posix } from "path";
+var WIKI_RE = /(!?)\[\[([^\]|#\n]{1,512})(#[^\]|\n]{1,512})?(\|[^\]\n]{1,512})?\]\]/g;
+var MD_RE = /(!?)\[([^\]\n]*)\]\(([^)\n]+)\)/g;
+var FENCE_RE = /^\s*(```|~~~)/;
+function wikiTargetFor(newPath, postNotes) {
+  const noExt = newPath.replace(/\.md$/i, "");
+  const base = noExt.split("/").pop() ?? noExt;
+  const baseLower = base.toLowerCase();
+  let matches2 = 0;
+  for (const p of postNotes.keys()) {
+    const pBase = (p.replace(/\.md$/i, "").split("/").pop() ?? "").toLowerCase();
+    if (pBase === baseLower && ++matches2 > 1) return noExt;
+  }
+  return base;
+}
+function mdTargetToVaultPath(rawTarget, sourceDir) {
+  let t = rawTarget.trim();
+  if (t.startsWith("<") && t.endsWith(">")) t = t.slice(1, -1);
+  if (/^[a-z][a-z0-9+.-]*:/i.test(t)) return void 0;
+  if (t.startsWith("#") || t === "") return void 0;
+  const hashIdx = t.indexOf("#");
+  if (hashIdx !== -1) t = t.slice(0, hashIdx);
+  try {
+    t = decodeURIComponent(t);
+  } catch {
+  }
+  const joined = posix.normalize(posix.join(sourceDir, t));
+  if (joined.startsWith("..")) return void 0;
+  return joined;
+}
+function rewriteNoteLinks(raw, sourcePath, oldPath, newPath, preNotes, postNotes) {
+  const sourceDir = posix.dirname(sourcePath);
+  const oldNoExt = oldPath.replace(/\.md$/i, "");
+  let count = 0;
+  const rewriteWikiLine = (line) => line.replace(WIKI_RE, (full, bang, target, frag, alias) => {
+    const t = target.trim();
+    if (resolveLink(t, postNotes) === newPath) return full;
+    if (resolveLink(t, preNotes) !== oldPath) return full;
+    count++;
+    const next = wikiTargetFor(newPath, postNotes);
+    return `${bang}[[${next}${frag ?? ""}${alias ?? ""}]]`;
+  });
+  const rewriteMdLine = (line) => line.replace(MD_RE, (full, bang, text, rawTarget) => {
+    const asRelative = mdTargetToVaultPath(rawTarget, sourceDir);
+    const asAbsolute = mdTargetToVaultPath(rawTarget, ".");
+    let vaultAbsoluteStyle;
+    if (asRelative === oldPath || asRelative === oldNoExt) vaultAbsoluteStyle = false;
+    else if (asAbsolute === oldPath || asAbsolute === oldNoExt) vaultAbsoluteStyle = true;
+    else return full;
+    count++;
+    const trimmed = rawTarget.trim();
+    const wrapped = trimmed.startsWith("<") && trimmed.endsWith(">");
+    const inner = wrapped ? trimmed.slice(1, -1) : trimmed;
+    const hashIdx = inner.indexOf("#");
+    const fragment = hashIdx === -1 ? "" : inner.slice(hashIdx);
+    const hadExt = /\.md(#|$)/i.test(inner);
+    let next = vaultAbsoluteStyle ? newPath : posix.relative(sourceDir, newPath);
+    if (!hadExt) next = next.replace(/\.md$/i, "");
+    if (inner.includes("%20")) next = next.replaceAll(" ", "%20");
+    const needsWrap = wrapped || next.includes(" ");
+    const target = needsWrap ? `<${next}${fragment}>` : `${next}${fragment}`;
+    return `${bang}[${text}](${target})`;
+  });
+  let inFence = false;
+  const lines = raw.split("\n").map((line) => {
+    if (FENCE_RE.test(line)) {
+      inFence = !inFence;
+      return line;
+    }
+    if (inFence) return line;
+    return rewriteMdLine(rewriteWikiLine(line));
+  });
+  return { content: lines.join("\n"), count };
+}
+function hasMarkdownLinkTo(raw, sourcePath, targetPath) {
+  if (!raw.includes("](")) return false;
+  const sourceDir = posix.dirname(sourcePath);
+  const noExt = targetPath.replace(/\.md$/i, "");
+  for (const m of raw.matchAll(MD_RE)) {
+    const rawTarget = m[3] ?? "";
+    const asRelative = mdTargetToVaultPath(rawTarget, sourceDir);
+    const asAbsolute = mdTargetToVaultPath(rawTarget, ".");
+    if (asRelative === targetPath || asRelative === noExt || asAbsolute === targetPath || asAbsolute === noExt) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/tools/move_note.ts
 var MoveNoteInput = z8.object({
   from: z8.string().describe("Vault-relative path of the note to move."),
   to: z8.string().describe("Vault-relative destination path."),
-  overwrite: z8.boolean().default(false).describe("Overwrite the destination if it exists. Defaults to false.")
+  overwrite: z8.boolean().default(false).describe("Overwrite the destination if it exists. Defaults to false."),
+  rewriteLinks: z8.boolean().default(true).describe(
+    "Rewrite wikilinks and markdown links in other notes that point at the moved note, so nothing breaks. Defaults to true; pass false to move the file only."
+  )
 });
-async function moveNote(ctx2, input) {
+async function moveNote(ctx2, rawInput) {
+  const input = MoveNoteInput.parse(rawInput);
   const absFrom = join6(ctx2.vaultRoot, input.from);
   const absTo = join6(ctx2.vaultRoot, input.to);
   if (!absFrom.startsWith(ctx2.vaultRoot)) throw new Error(`Path outside vault: ${input.from}`);
   if (!absTo.startsWith(ctx2.vaultRoot)) throw new Error(`Path outside vault: ${input.to}`);
+  assertWritable(ctx2.policy, input.from);
+  assertWritable(ctx2.policy, input.to);
   try {
     await access2(absFrom);
   } catch {
@@ -450,15 +639,59 @@ async function moveNote(ctx2, input) {
       if (err.code !== "ENOENT") throw err;
     }
   }
+  const preNotes = new Map(ctx2.notes);
+  const candidates = /* @__PURE__ */ new Set();
+  if (input.rewriteLinks) {
+    for (const ref of ctx2.backlinks.get(input.from) ?? []) candidates.add(ref.path);
+    for (const [path2, doc] of preNotes) {
+      if (path2 === input.from || candidates.has(path2)) continue;
+      if (hasMarkdownLinkTo(doc.raw, path2, input.from)) candidates.add(path2);
+    }
+    candidates.delete(input.from);
+  }
   await mkdir2(dirname2(absTo), { recursive: true });
   await rename(absFrom, absTo);
   const raw = ctx2.notes.get(input.from)?.raw ?? "";
+  removeNoteBacklinks(ctx2, input.from);
   if (ctx2.notes.has(input.from)) {
     ctx2.index.discard(input.from);
     ctx2.notes.delete(input.from);
   }
   upsertDoc(ctx2, buildDoc(input.to, raw));
-  return { from: input.from, to: input.to };
+  addNoteBacklinks(ctx2, input.to, raw);
+  let notesRewritten = 0;
+  let linksRewritten = 0;
+  const skipped = [];
+  for (const path2 of [...candidates].sort()) {
+    const doc = ctx2.notes.get(path2);
+    if (doc === void 0) continue;
+    if (!isWritable(ctx2.policy, path2)) {
+      skipped.push(path2);
+      continue;
+    }
+    const { content, count } = rewriteNoteLinks(
+      doc.raw,
+      path2,
+      input.from,
+      input.to,
+      preNotes,
+      ctx2.notes
+    );
+    removeNoteBacklinks(ctx2, path2);
+    if (count > 0) {
+      await writeFile3(join6(ctx2.vaultRoot, path2), content, "utf8");
+      upsertDoc(ctx2, buildDoc(path2, content));
+      notesRewritten++;
+      linksRewritten += count;
+      addNoteBacklinks(ctx2, path2, content);
+    } else {
+      addNoteBacklinks(ctx2, path2, doc.raw);
+    }
+  }
+  ctx2.backlinks.delete(input.from);
+  const result = { from: input.from, to: input.to, notesRewritten, linksRewritten };
+  if (skipped.length > 0) result.skipped = skipped;
+  return result;
 }
 
 // src/tools/outline_note.ts
@@ -532,7 +765,7 @@ async function outlineNote(ctx2, input) {
 }
 
 // src/tools/patch_frontmatter.ts
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
 import { join as join8 } from "path";
 import { parseDocument } from "yaml";
 import { z as z10 } from "zod";
@@ -547,6 +780,7 @@ async function patchFrontmatter(ctx2, input) {
   if (!absPath.startsWith(ctx2.vaultRoot)) {
     throw new Error(`Path outside vault: ${input.path}`);
   }
+  assertWritable(ctx2.policy, input.path);
   const original = await readFile3(absPath, "utf8");
   const fm = parseFrontmatter(original);
   const keysChanged = [];
@@ -589,7 +823,7 @@ ${original}`;
     const tail = opensWithCRLF ? "---\r\n" : "---\n";
     newContent = `${head}${doc.toString()}${tail}${fm.body}`;
   }
-  await writeFile3(absPath, newContent, "utf8");
+  await writeFile4(absPath, newContent, "utf8");
   const cached = ctx2.notes.get(input.path);
   if (cached) {
     const updated = parseFrontmatter(newContent);
@@ -600,7 +834,7 @@ ${original}`;
 }
 
 // src/tools/patch_note.ts
-import { readFile as readFile4, rename as rename2, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile4, rename as rename2, writeFile as writeFile5 } from "fs/promises";
 import { join as join9 } from "path";
 import { z as z11 } from "zod";
 var PatchNoteInput = z11.object({
@@ -628,7 +862,7 @@ function lineStart(raw, offset) {
 }
 async function atomicWrite(absPath, content) {
   const tmpPath = `${absPath}.seekstone-patch-tmp`;
-  await writeFile4(tmpPath, content, "utf8");
+  await writeFile5(tmpPath, content, "utf8");
   await rename2(tmpPath, absPath);
 }
 async function patchNote(ctx2, input) {
@@ -636,6 +870,7 @@ async function patchNote(ctx2, input) {
   if (!absPath.startsWith(ctx2.vaultRoot)) {
     throw new Error(`Path outside vault: ${input.path}`);
   }
+  assertWritable(ctx2.policy, input.path);
   const raw = await readFile4(absPath, "utf8");
   const fm = parseFrontmatter(raw);
   const originalFmRegion = raw.slice(0, fm.bodyStart);
@@ -748,7 +983,7 @@ function updateCache(ctx2, path2, newContent, bodyStart) {
 }
 
 // src/tools/periodic_note.ts
-import { access as access3, mkdir as mkdir3, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { access as access3, mkdir as mkdir3, readFile as readFile5, writeFile as writeFile6 } from "fs/promises";
 import { dirname as dirname3, join as join10 } from "path";
 import { z as z12 } from "zod";
 var PERIOD = z12.enum(["daily", "weekly", "monthly", "quarterly", "yearly"]);
@@ -840,6 +1075,7 @@ async function getPeriodicNote(ctx2, rawInput) {
   }
   if (existed) return { path: path2, existed: true, created: false };
   if (!input.createIfMissing) return { path: path2, existed: false, created: false };
+  assertWritable(ctx2.policy, path2);
   let body = "";
   if (cfg.template) {
     const templateAbs = join10(
@@ -854,7 +1090,7 @@ async function getPeriodicNote(ctx2, rawInput) {
     }
   }
   await mkdir3(dirname3(abs), { recursive: true });
-  await writeFile5(abs, body, "utf8");
+  await writeFile6(abs, body, "utf8");
   upsertDoc(ctx2, buildDoc(path2, body));
   return { path: path2, existed: false, created: true };
 }
@@ -871,6 +1107,7 @@ async function appendPeriodicNote(ctx2, rawInput) {
   const path2 = resolveNotePath(cfg, date);
   const abs = join10(ctx2.vaultRoot, path2);
   if (!abs.startsWith(ctx2.vaultRoot)) throw new Error(`Path outside vault: ${path2}`);
+  assertWritable(ctx2.policy, path2);
   let original = "";
   try {
     original = await readFile5(abs, "utf8");
@@ -878,7 +1115,7 @@ async function appendPeriodicNote(ctx2, rawInput) {
     if (err.code !== "ENOENT") throw err;
     if (!input.createIfMissing) throw new Error(`Periodic note not found: ${path2}`);
     await mkdir3(dirname3(abs), { recursive: true });
-    await writeFile5(abs, input.content, "utf8");
+    await writeFile6(abs, input.content, "utf8");
     upsertDoc(ctx2, buildDoc(path2, input.content));
     return { path: path2, bytesWritten: Buffer.byteLength(input.content, "utf8") };
   }
@@ -889,7 +1126,7 @@ async function appendPeriodicNote(ctx2, rawInput) {
   const newBody = `${body}${separator}${input.content}`;
   const header = original.slice(0, fm.bodyStart);
   const newRaw = `${header}${newBody}`;
-  await writeFile5(abs, newRaw, "utf8");
+  await writeFile6(abs, newRaw, "utf8");
   const cached = ctx2.notes.get(path2);
   if (cached) {
     cached.body = newBody;
@@ -1206,7 +1443,7 @@ async function readNote(ctx2, input) {
 }
 
 // src/tools/replace_in_note.ts
-import { readFile as readFile7, rename as rename3, writeFile as writeFile6 } from "fs/promises";
+import { readFile as readFile7, rename as rename3, writeFile as writeFile7 } from "fs/promises";
 import { join as join12 } from "path";
 import { z as z16 } from "zod";
 var ReplaceInNoteInput = z16.object({
@@ -1230,7 +1467,7 @@ function buildRegex(find, opts) {
 }
 async function atomicWrite2(absPath, content) {
   const tmpPath = `${absPath}.seekstone-replace-tmp`;
-  await writeFile6(tmpPath, content, "utf8");
+  await writeFile7(tmpPath, content, "utf8");
   await rename3(tmpPath, absPath);
 }
 async function replaceInNote(ctx2, input) {
@@ -1238,6 +1475,7 @@ async function replaceInNote(ctx2, input) {
   if (!absPath.startsWith(ctx2.vaultRoot)) {
     throw new Error(`Path outside vault: ${input.path}`);
   }
+  assertWritable(ctx2.policy, input.path);
   let re;
   try {
     re = buildRegex(input.find, {
@@ -1299,6 +1537,16 @@ async function replaceInNote(ctx2, input) {
 }
 
 // src/dispatch.ts
+var WRITE_TOOLS = /* @__PURE__ */ new Set([
+  "create_note",
+  "delete_note",
+  "move_note",
+  "append_note",
+  "patch_frontmatter",
+  "patch_note",
+  "replace_in_note",
+  "append_periodic_note"
+]);
 var META_KEYS = [
   "path",
   "from",
@@ -1339,6 +1587,23 @@ async function dispatch(ctx2, name, args, log2) {
   const start = performance.now();
   const meta = safeMeta(args);
   log2.debug("tool start", { tool: name, args });
+  if (ctx2.policy.readOnly && WRITE_TOOLS.has(name)) {
+    log2.info("tool rejected (read-only)", { tool: name, ...meta });
+    return {
+      content: [
+        {
+          type: "text",
+          text: "Error: Server is read-only (SEEKSTONE_READ_ONLY=1); write tools are disabled."
+        }
+      ],
+      isError: true
+    };
+  }
+  if (ctx2.policy.readOnly && name === "get_periodic_note") {
+    if (typeof args === "object" && args !== null) {
+      args = { ...args, createIfMissing: false };
+    }
+  }
   try {
     const result = await run(ctx2, name, args);
     const durationMs = Math.round((performance.now() - start) * 100) / 100;
@@ -1399,7 +1664,11 @@ async function run(ctx2, name, args) {
     case "move_note": {
       const input = MoveNoteInput.parse(args);
       const result = await moveNote(ctx2, input);
-      return { content: [{ type: "text", text: `Moved ${result.from} \u2192 ${result.to}.` }] };
+      let text = `Moved ${result.from} \u2192 ${result.to}. Rewrote ${result.linksRewritten} link${result.linksRewritten === 1 ? "" : "s"} in ${result.notesRewritten} note${result.notesRewritten === 1 ? "" : "s"}.`;
+      if (result.skipped?.length) {
+        text += ` Skipped (outside SEEKSTONE_WRITE_PATHS): ${result.skipped.join(", ")}.`;
+      }
+      return { content: [{ type: "text", text }] };
     }
     case "append_note": {
       const input = AppendNoteInput.parse(args);
@@ -1598,7 +1867,7 @@ function buildBacklinks(notes2) {
 
 // src/init.ts
 import { execFileSync } from "child_process";
-import { access as access4, copyFile, mkdir as mkdir4, readdir, readFile as readFile9, stat as stat2, writeFile as writeFile7 } from "fs/promises";
+import { access as access4, copyFile, mkdir as mkdir4, readdir, readFile as readFile9, stat as stat2, writeFile as writeFile8 } from "fs/promises";
 import path, { dirname as dirname4, join as join14 } from "path";
 function parseInitArgs(argv) {
   const opts = { write: false, client: "desktop" };
@@ -1609,6 +1878,7 @@ function parseInitArgs(argv) {
     else if (a === "--client") {
       const v = argv[++i];
       if (v === "desktop" || v === "code" || v === "cursor" || v === "vscode") opts.client = v;
+      else opts.invalidClient = v ?? "(missing)";
     }
   }
   return opts;
@@ -1732,6 +2002,15 @@ async function countMarkdown(root) {
   return count;
 }
 async function runInit(opts, deps) {
+  if (opts.invalidClient !== void 0) {
+    return {
+      ok: false,
+      exitCode: 1,
+      output: [
+        `\u2717 Unknown --client: ${opts.invalidClient}. Known clients: desktop, code, cursor, vscode.`
+      ]
+    };
+  }
   const rf = deps.readFile ?? readFile9;
   let vaultPath = opts.vault ?? deps.env.SEEKSTONE_VAULT;
   if (!vaultPath) {
@@ -1868,7 +2147,7 @@ async function runInit(opts, deps) {
     backupPath = `${configPath}.backup-${deps.timestamp}`;
     await copyFile(configPath, backupPath);
   }
-  await writeFile7(configPath, `${JSON.stringify(merged, null, 2)}
+  await writeFile8(configPath, `${JSON.stringify(merged, null, 2)}
 `, "utf8");
   out.push(
     `\u2713 Patched ${configPath}`,
@@ -1939,7 +2218,7 @@ function createLogger(opts = {}) {
       );
     }
   }
-  function writeFile8(record) {
+  function writeFile9(record) {
     if (!fileOk || filePath === void 0) return;
     const line = `${JSON.stringify(record)}
 `;
@@ -1961,7 +2240,7 @@ function createLogger(opts = {}) {
     const f = fields ?? {};
     stderr(`${lvl.toUpperCase().padEnd(5)} ${ts} ${msg}${fmtFields(f)}
 `);
-    writeFile8({ t: ts, level: lvl, msg, ...f });
+    writeFile9({ t: ts, level: lvl, msg, ...f });
   }
   return {
     level,
@@ -1992,41 +2271,407 @@ function installProcessGuards(log2) {
   };
 }
 
+// src/tool-list.ts
+var ALL_TOOLS = [
+  {
+    name: "search",
+    description: "Full-text search across the vault. Returns ranked excerpts (~200 chars) \u2014 not full notes \u2014 to minimise context usage. Supports fuzzy matching and prefix search.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query." },
+        limit: { type: "number", description: "Max results (1\u201350, default 10)." },
+        folder: { type: "string", description: "Restrict to a vault-relative folder prefix." },
+        tag: { type: "string", description: "Restrict to notes with this tag." }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "query_notes",
+    description: "Structured metadata query \u2014 filter notes by frontmatter key/value predicates, tag, folder, modified time, and size. Returns compact rows (path + title by default; opt into more via select), not note content. Use this instead of search when filtering by properties rather than text.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        where: {
+          type: "array",
+          description: "Frontmatter predicates \u2014 all must match (AND).",
+          items: {
+            type: "object",
+            properties: {
+              key: { type: "string", description: "Frontmatter key to test." },
+              op: {
+                type: "string",
+                enum: ["eq", "ne", "contains", "exists", "missing", "gt", "gte", "lt", "lte"],
+                description: "eq/ne compare scalars; contains matches array membership or substring; exists/missing test key presence; gt/gte/lt/lte compare numbers or strings (ISO dates sort correctly)."
+              },
+              value: {
+                description: "Comparison value. Required for every op except exists/missing."
+              }
+            },
+            required: ["key", "op"]
+          }
+        },
+        folder: { type: "string", description: "Restrict to a vault-relative folder prefix." },
+        tag: { type: "string", description: "Restrict to notes with this tag (# optional)." },
+        modifiedAfter: {
+          type: "string",
+          description: "Only notes modified at or after this ISO 8601 date/time."
+        },
+        modifiedBefore: {
+          type: "string",
+          description: "Only notes modified before this ISO 8601 date/time."
+        },
+        minSizeBytes: { type: "number", description: "Only notes at least this many bytes." },
+        maxSizeBytes: { type: "number", description: "Only notes at most this many bytes." },
+        select: {
+          type: "array",
+          items: { type: "string" },
+          description: 'Extra fields per hit: frontmatter keys, or "mtime", "size", "tags". Default returns only path + title.'
+        },
+        sort: {
+          type: "string",
+          enum: ["path", "title", "mtime", "size"],
+          description: "Sort field (default path)."
+        },
+        order: {
+          type: "string",
+          enum: ["asc", "desc"],
+          description: "Sort order (default asc)."
+        },
+        limit: { type: "number", description: "Max results (1\u2013500, default 100)." }
+      },
+      required: []
+    }
+  },
+  {
+    name: "read_note",
+    description: "Read a note or a span of it \u2014 by heading section, block reference, or line range. Returns structured JSON with the content, bytes returned, and total note size so payload savings are measurable. Use search or outline_note first to find the right path and section names.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: 'Vault-relative path, e.g. "Daily Notes/2026-05-29.md".'
+        },
+        section: {
+          type: "string",
+          description: "Return only this heading section (heading text, # prefix optional). First match wins."
+        },
+        block: {
+          type: "string",
+          description: "Return only the line anchored by this block id (^ prefix optional)."
+        },
+        lines: {
+          type: "object",
+          description: "Return only this line range (1-indexed, inclusive).",
+          properties: {
+            from: { type: "number", description: "First line (1-indexed)." },
+            to: {
+              type: "number",
+              description: "Last line (1-indexed, inclusive). Defaults to EOF."
+            }
+          },
+          required: ["from"]
+        },
+        includeFrontmatter: {
+          type: "boolean",
+          description: "Prepend frontmatter to section/block span results. Default false for spans."
+        }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "list_notes",
+    description: "List notes, optionally filtered by folder prefix or tag.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        folder: { type: "string", description: "Vault-relative folder prefix." },
+        tag: { type: "string", description: "Filter by tag (# prefix optional)." },
+        limit: { type: "number", description: "Max results (1\u2013500, default 100)." }
+      },
+      required: []
+    }
+  },
+  {
+    name: "list_tags",
+    description: "List all tags in the vault with usage counts. Supports substring filtering, minimum count threshold, and sort order. Nested tags (e.g. area/work) include a parent field.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pattern: {
+          type: "string",
+          description: 'Substring filter on tag name. Example: "work" matches "work" and "area/work".'
+        },
+        minCount: {
+          type: "number",
+          description: "Only return tags used in at least this many notes."
+        },
+        sort: {
+          type: "string",
+          enum: ["count", "name"],
+          description: "Sort by usage count descending (default) or alphabetically."
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "create_note",
+    description: "Create a new note at a vault-relative path. Optionally sets frontmatter and body content. Parent directories are created automatically. Fails if the note already exists unless overwrite is true.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: 'Vault-relative path, e.g. "Daily Notes/2026-06-01.md".'
+        },
+        content: { type: "string", description: "Body content for the note." },
+        frontmatter: {
+          type: "object",
+          description: "Frontmatter key-value pairs.",
+          additionalProperties: true
+        },
+        overwrite: {
+          type: "boolean",
+          description: "Overwrite an existing note. Defaults to false."
+        }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "delete_note",
+    description: "Permanently delete a note from the vault. This cannot be undone.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Vault-relative path of the note to delete." }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "move_note",
+    description: "Move or rename a note to a new vault-relative path, rewriting wikilinks and markdown links in other notes that point at it so nothing breaks (links inside fenced code blocks are left alone). Parent directories at the destination are created automatically. Fails if the destination already exists unless overwrite is true.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        from: { type: "string", description: "Vault-relative source path." },
+        to: { type: "string", description: "Vault-relative destination path." },
+        overwrite: {
+          type: "boolean",
+          description: "Overwrite destination if it exists. Defaults to false."
+        },
+        rewriteLinks: {
+          type: "boolean",
+          description: "Rewrite references in other notes to follow the move. Defaults to true; pass false to move the file only."
+        }
+      },
+      required: ["from", "to"]
+    }
+  },
+  {
+    name: "append_note",
+    description: "Append text to a note body without touching the frontmatter. Safe for meeting notes, daily logs, and append-only workflows.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Vault-relative path to the note." },
+        content: { type: "string", description: "Text to append." }
+      },
+      required: ["path", "content"]
+    }
+  },
+  {
+    name: "patch_frontmatter",
+    description: "Set, update, or delete frontmatter keys without reordering existing keys or changing quote style. Pass null as a value to delete a key.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Vault-relative path to the note." },
+        patch: {
+          type: "object",
+          description: "Key-value pairs to set. Null value removes the key.",
+          additionalProperties: true
+        }
+      },
+      required: ["path", "patch"]
+    }
+  },
+  {
+    name: "outline_note",
+    description: "Return a note's structure \u2014 heading tree with offsets, block-reference anchors, and frontmatter key list \u2014 without returning any prose. Use this before section reads or patches to discover what sections exist at a fraction of the cost of reading the full note.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Vault-relative path to the note." },
+        includeBlocks: {
+          type: "boolean",
+          description: "Include block-reference anchors (^id). Default true."
+        },
+        includeSizes: {
+          type: "boolean",
+          description: "Include per-section character length in each heading entry. Default false."
+        }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "patch_note",
+    description: "Surgically edit a section of a note \u2014 targeted by heading or block reference \u2014 without rewriting the whole file. Operations: append (add after section), prepend (add after heading line), replace (swap section content). Frontmatter is never touched.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Vault-relative path to the note." },
+        target: {
+          type: "object",
+          description: 'Exactly one of: { heading: "Section Title" } or { block: "block-id" } (without the ^ prefix).'
+        },
+        operation: {
+          type: "string",
+          enum: ["append", "prepend", "replace"],
+          description: "append: insert after section content. prepend: insert after heading line. replace: swap section content."
+        },
+        content: { type: "string", description: "Content to insert or replace with." },
+        createIfMissing: {
+          type: "boolean",
+          description: "If the heading target is not found, append a new heading (level 2) + content. Only valid for heading targets. Default false."
+        }
+      },
+      required: ["path", "target", "operation", "content"]
+    }
+  },
+  {
+    name: "get_backlinks",
+    description: "Return every note that links to the target note, with the source line and an optional excerpt. Results come from the pre-built reverse-link index so this is a fast, pure index lookup. Sort order: source path ascending.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Vault-relative path to the target note." },
+        includeContext: {
+          type: "boolean",
+          description: "Include a short excerpt (~200 chars) from the linking line. Default true."
+        },
+        limit: {
+          type: "number",
+          description: "Max backlinks to return (1\u2013500). Default 50."
+        }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "get_links",
+    description: "Return all outgoing wikilinks and embeds from a note. Each link is marked resolved (with target path) or unresolved. Duplicate targets are de-duplicated; results sorted by line number.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Vault-relative path to the note." }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "replace_in_note",
+    description: "Find and replace text within a note body. Supports literal and regex search, case sensitivity, whole-word matching, and a replacement limit. Frontmatter is never touched. Use dryRun to preview matches before writing.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Vault-relative path to the note." },
+        find: { type: "string", description: "Text or pattern to find." },
+        replace: {
+          type: "string",
+          description: "Replacement text. Supports $1, $2, \u2026 backreferences in regex mode."
+        },
+        regex: {
+          type: "boolean",
+          description: "Treat find as a regular expression. Default false."
+        },
+        caseSensitive: {
+          type: "boolean",
+          description: "Case-sensitive matching. Default false."
+        },
+        wholeWord: {
+          type: "boolean",
+          description: "Match whole words only (\\b boundary). Default false."
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of replacements. Omit to replace all."
+        },
+        dryRun: {
+          type: "boolean",
+          description: "If true, report matches without writing. Default false."
+        }
+      },
+      required: ["path", "find", "replace"]
+    }
+  },
+  {
+    name: "get_periodic_note",
+    description: "Get the path and existence status of a periodic note (daily, weekly, monthly, quarterly, or yearly) for a given date. Reads folder/format config from .obsidian/daily-notes.json (daily) or the periodic-notes plugin data.json. Optionally creates the note from the configured template if it is missing.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        period: {
+          type: "string",
+          enum: ["daily", "weekly", "monthly", "quarterly", "yearly"],
+          description: "Period type. Default: daily."
+        },
+        date: {
+          type: "string",
+          description: "ISO date string (YYYY-MM-DD). Defaults to today when omitted."
+        },
+        createIfMissing: {
+          type: "boolean",
+          description: "Create the note from the configured template if it does not exist. Default false."
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "append_periodic_note",
+    description: "Append text to a periodic note (daily, weekly, monthly, quarterly, or yearly). Preserves existing frontmatter exactly. Creates the note first (from template if configured) when createIfMissing is true (default).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        period: {
+          type: "string",
+          enum: ["daily", "weekly", "monthly", "quarterly", "yearly"],
+          description: "Period type. Default: daily."
+        },
+        date: {
+          type: "string",
+          description: "ISO date string (YYYY-MM-DD). Defaults to today when omitted."
+        },
+        content: {
+          type: "string",
+          description: "Text to append to the note body."
+        },
+        createIfMissing: {
+          type: "boolean",
+          description: "Create the note if it does not exist before appending. Default true."
+        }
+      },
+      required: ["content"]
+    }
+  }
+];
+function visibleTools(policy2) {
+  if (!policy2.readOnly) return ALL_TOOLS;
+  return ALL_TOOLS.filter((t) => !WRITE_TOOLS.has(t.name));
+}
+
 // src/watcher.ts
 import { realpathSync } from "fs";
 import { readFile as readFile10 } from "fs/promises";
 import { join as join15, relative as relative2, sep as sep2 } from "path";
 import chokidar from "chokidar";
-function removeNoteBacklinks(ctx2, relPath) {
-  const oldDoc = ctx2.notes.get(relPath);
-  if (oldDoc === void 0) return;
-  for (const link of extractLinksWithLines(oldDoc.raw)) {
-    const resolved = resolveLink(link.target, ctx2.notes);
-    if (resolved === void 0) continue;
-    const arr = ctx2.backlinks.get(resolved);
-    if (arr === void 0) continue;
-    const filtered = arr.filter((r) => r.path !== relPath);
-    ctx2.backlinks.set(resolved, filtered);
-  }
-}
-function addNoteBacklinks(ctx2, relPath, raw) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const link of extractLinksWithLines(raw)) {
-    const resolved = resolveLink(link.target, ctx2.notes);
-    if (resolved === void 0) continue;
-    const dedupeKey = `${relPath}\0${resolved}`;
-    if (seen.has(dedupeKey)) continue;
-    seen.add(dedupeKey);
-    let arr = ctx2.backlinks.get(resolved);
-    if (arr === void 0) {
-      arr = [];
-      ctx2.backlinks.set(resolved, arr);
-    }
-    const ref = { path: relPath, line: link.line, linkType: link.linkType };
-    arr.push(ref);
-    arr.sort((a, b) => a.path.localeCompare(b.path));
-  }
-}
 function startWatcher(ctx2, log2, opts) {
   const usePolling = opts?.usePolling ?? process.env.SEEKSTONE_WATCH_POLL === "1";
   let vaultRoot2 = ctx2.vaultRoot;
@@ -2083,13 +2728,13 @@ function startWatcher(ctx2, log2, opts) {
     });
   });
   return {
-    stop: () => void watcher2.close(),
+    stop: () => watcher2.close(),
     ready
   };
 }
 
 // src/index.ts
-var VERSION = true ? "0.9.0" : "0.0.0-dev";
+var VERSION = true ? "0.10.0" : "0.0.0-dev";
 var intent = parseCliIntent(process.argv.slice(2));
 if (intent === "version") {
   process.stdout.write(`${VERSION}
@@ -2101,6 +2746,11 @@ if (intent === "help") {
 `);
   process.exit(0);
 }
+if (intent === "init-help") {
+  process.stdout.write(`${initHelpText(VERSION)}
+`);
+  process.exit(0);
+}
 if (intent === "init") {
   const result = await runInit(parseInitArgs(process.argv.slice(3)), {
     env: process.env,
@@ -2119,400 +2769,18 @@ if (!vaultRoot) {
   log.error("SEEKSTONE_VAULT env var is required");
   process.exit(1);
 }
+var policy = parseWritePolicy(process.env);
+if (policy.readOnly) log.info("read-only mode", { env: "SEEKSTONE_READ_ONLY" });
+if (policy.writeGlobs) log.info("write paths scoped", { globs: policy.writeGlobs });
 log.info("building index", { vault: vaultRoot });
 var { index, notes, backlinks, buildMs } = await buildIndex(vaultRoot);
 log.info("index ready", { notes: notes.size, buildMs });
-var ctx = { vaultRoot, index, notes, backlinks };
+var ctx = { vaultRoot, index, notes, backlinks, policy };
 var watcher = startWatcher(ctx, log);
-process.on("exit", watcher.stop);
+process.on("exit", () => void watcher.stop());
 var server = new Server({ name: "seekstone", version: VERSION }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [
-    {
-      name: "search",
-      description: "Full-text search across the vault. Returns ranked excerpts (~200 chars) \u2014 not full notes \u2014 to minimise context usage. Supports fuzzy matching and prefix search.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          query: { type: "string", description: "Search query." },
-          limit: { type: "number", description: "Max results (1\u201350, default 10)." },
-          folder: { type: "string", description: "Restrict to a vault-relative folder prefix." },
-          tag: { type: "string", description: "Restrict to notes with this tag." }
-        },
-        required: ["query"]
-      }
-    },
-    {
-      name: "query_notes",
-      description: "Structured metadata query \u2014 filter notes by frontmatter key/value predicates, tag, folder, modified time, and size. Returns compact rows (path + title by default; opt into more via select), not note content. Use this instead of search when filtering by properties rather than text.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          where: {
-            type: "array",
-            description: "Frontmatter predicates \u2014 all must match (AND).",
-            items: {
-              type: "object",
-              properties: {
-                key: { type: "string", description: "Frontmatter key to test." },
-                op: {
-                  type: "string",
-                  enum: ["eq", "ne", "contains", "exists", "missing", "gt", "gte", "lt", "lte"],
-                  description: "eq/ne compare scalars; contains matches array membership or substring; exists/missing test key presence; gt/gte/lt/lte compare numbers or strings (ISO dates sort correctly)."
-                },
-                value: {
-                  description: "Comparison value. Required for every op except exists/missing."
-                }
-              },
-              required: ["key", "op"]
-            }
-          },
-          folder: { type: "string", description: "Restrict to a vault-relative folder prefix." },
-          tag: { type: "string", description: "Restrict to notes with this tag (# optional)." },
-          modifiedAfter: {
-            type: "string",
-            description: "Only notes modified at or after this ISO 8601 date/time."
-          },
-          modifiedBefore: {
-            type: "string",
-            description: "Only notes modified before this ISO 8601 date/time."
-          },
-          minSizeBytes: { type: "number", description: "Only notes at least this many bytes." },
-          maxSizeBytes: { type: "number", description: "Only notes at most this many bytes." },
-          select: {
-            type: "array",
-            items: { type: "string" },
-            description: 'Extra fields per hit: frontmatter keys, or "mtime", "size", "tags". Default returns only path + title.'
-          },
-          sort: {
-            type: "string",
-            enum: ["path", "title", "mtime", "size"],
-            description: "Sort field (default path)."
-          },
-          order: {
-            type: "string",
-            enum: ["asc", "desc"],
-            description: "Sort order (default asc)."
-          },
-          limit: { type: "number", description: "Max results (1\u2013500, default 100)." }
-        },
-        required: []
-      }
-    },
-    {
-      name: "read_note",
-      description: "Read a note or a span of it \u2014 by heading section, block reference, or line range. Returns structured JSON with the content, bytes returned, and total note size so payload savings are measurable. Use search or outline_note first to find the right path and section names.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: 'Vault-relative path, e.g. "Daily Notes/2026-05-29.md".'
-          },
-          section: {
-            type: "string",
-            description: "Return only this heading section (heading text, # prefix optional). First match wins."
-          },
-          block: {
-            type: "string",
-            description: "Return only the line anchored by this block id (^ prefix optional)."
-          },
-          lines: {
-            type: "object",
-            description: "Return only this line range (1-indexed, inclusive).",
-            properties: {
-              from: { type: "number", description: "First line (1-indexed)." },
-              to: {
-                type: "number",
-                description: "Last line (1-indexed, inclusive). Defaults to EOF."
-              }
-            },
-            required: ["from"]
-          },
-          includeFrontmatter: {
-            type: "boolean",
-            description: "Prepend frontmatter to section/block span results. Default false for spans."
-          }
-        },
-        required: ["path"]
-      }
-    },
-    {
-      name: "list_notes",
-      description: "List notes, optionally filtered by folder prefix or tag.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          folder: { type: "string", description: "Vault-relative folder prefix." },
-          tag: { type: "string", description: "Filter by tag (# prefix optional)." },
-          limit: { type: "number", description: "Max results (1\u2013500, default 100)." }
-        },
-        required: []
-      }
-    },
-    {
-      name: "list_tags",
-      description: "List all tags in the vault with usage counts. Supports substring filtering, minimum count threshold, and sort order. Nested tags (e.g. area/work) include a parent field.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          pattern: {
-            type: "string",
-            description: 'Substring filter on tag name. Example: "work" matches "work" and "area/work".'
-          },
-          minCount: {
-            type: "number",
-            description: "Only return tags used in at least this many notes."
-          },
-          sort: {
-            type: "string",
-            enum: ["count", "name"],
-            description: "Sort by usage count descending (default) or alphabetically."
-          }
-        },
-        required: []
-      }
-    },
-    {
-      name: "create_note",
-      description: "Create a new note at a vault-relative path. Optionally sets frontmatter and body content. Parent directories are created automatically. Fails if the note already exists unless overwrite is true.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: 'Vault-relative path, e.g. "Daily Notes/2026-06-01.md".'
-          },
-          content: { type: "string", description: "Body content for the note." },
-          frontmatter: {
-            type: "object",
-            description: "Frontmatter key-value pairs.",
-            additionalProperties: true
-          },
-          overwrite: {
-            type: "boolean",
-            description: "Overwrite an existing note. Defaults to false."
-          }
-        },
-        required: ["path"]
-      }
-    },
-    {
-      name: "delete_note",
-      description: "Permanently delete a note from the vault. This cannot be undone.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Vault-relative path of the note to delete." }
-        },
-        required: ["path"]
-      }
-    },
-    {
-      name: "move_note",
-      description: "Move or rename a note to a new vault-relative path. Parent directories at the destination are created automatically. Fails if the destination already exists unless overwrite is true.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          from: { type: "string", description: "Vault-relative source path." },
-          to: { type: "string", description: "Vault-relative destination path." },
-          overwrite: {
-            type: "boolean",
-            description: "Overwrite destination if it exists. Defaults to false."
-          }
-        },
-        required: ["from", "to"]
-      }
-    },
-    {
-      name: "append_note",
-      description: "Append text to a note body without touching the frontmatter. Safe for meeting notes, daily logs, and append-only workflows.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Vault-relative path to the note." },
-          content: { type: "string", description: "Text to append." }
-        },
-        required: ["path", "content"]
-      }
-    },
-    {
-      name: "patch_frontmatter",
-      description: "Set, update, or delete frontmatter keys without reordering existing keys or changing quote style. Pass null as a value to delete a key.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Vault-relative path to the note." },
-          patch: {
-            type: "object",
-            description: "Key-value pairs to set. Null value removes the key.",
-            additionalProperties: true
-          }
-        },
-        required: ["path", "patch"]
-      }
-    },
-    {
-      name: "outline_note",
-      description: "Return a note's structure \u2014 heading tree with offsets, block-reference anchors, and frontmatter key list \u2014 without returning any prose. Use this before section reads or patches to discover what sections exist at a fraction of the cost of reading the full note.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Vault-relative path to the note." },
-          includeBlocks: {
-            type: "boolean",
-            description: "Include block-reference anchors (^id). Default true."
-          },
-          includeSizes: {
-            type: "boolean",
-            description: "Include per-section character length in each heading entry. Default false."
-          }
-        },
-        required: ["path"]
-      }
-    },
-    {
-      name: "patch_note",
-      description: "Surgically edit a section of a note \u2014 targeted by heading or block reference \u2014 without rewriting the whole file. Operations: append (add after section), prepend (add after heading line), replace (swap section content). Frontmatter is never touched.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Vault-relative path to the note." },
-          target: {
-            type: "object",
-            description: 'Exactly one of: { heading: "Section Title" } or { block: "block-id" } (without the ^ prefix).'
-          },
-          operation: {
-            type: "string",
-            enum: ["append", "prepend", "replace"],
-            description: "append: insert after section content. prepend: insert after heading line. replace: swap section content."
-          },
-          content: { type: "string", description: "Content to insert or replace with." },
-          createIfMissing: {
-            type: "boolean",
-            description: "If the heading target is not found, append a new heading (level 2) + content. Only valid for heading targets. Default false."
-          }
-        },
-        required: ["path", "target", "operation", "content"]
-      }
-    },
-    {
-      name: "get_backlinks",
-      description: "Return every note that links to the target note, with the source line and an optional excerpt. Results come from the pre-built reverse-link index so this is a fast, pure index lookup. Sort order: source path ascending.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Vault-relative path to the target note." },
-          includeContext: {
-            type: "boolean",
-            description: "Include a short excerpt (~200 chars) from the linking line. Default true."
-          },
-          limit: {
-            type: "number",
-            description: "Max backlinks to return (1\u2013500). Default 50."
-          }
-        },
-        required: ["path"]
-      }
-    },
-    {
-      name: "get_links",
-      description: "Return all outgoing wikilinks and embeds from a note. Each link is marked resolved (with target path) or unresolved. Duplicate targets are de-duplicated; results sorted by line number.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Vault-relative path to the note." }
-        },
-        required: ["path"]
-      }
-    },
-    {
-      name: "replace_in_note",
-      description: "Find and replace text within a note body. Supports literal and regex search, case sensitivity, whole-word matching, and a replacement limit. Frontmatter is never touched. Use dryRun to preview matches before writing.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Vault-relative path to the note." },
-          find: { type: "string", description: "Text or pattern to find." },
-          replace: {
-            type: "string",
-            description: "Replacement text. Supports $1, $2, \u2026 backreferences in regex mode."
-          },
-          regex: {
-            type: "boolean",
-            description: "Treat find as a regular expression. Default false."
-          },
-          caseSensitive: {
-            type: "boolean",
-            description: "Case-sensitive matching. Default false."
-          },
-          wholeWord: {
-            type: "boolean",
-            description: "Match whole words only (\\b boundary). Default false."
-          },
-          limit: {
-            type: "number",
-            description: "Maximum number of replacements. Omit to replace all."
-          },
-          dryRun: {
-            type: "boolean",
-            description: "If true, report matches without writing. Default false."
-          }
-        },
-        required: ["path", "find", "replace"]
-      }
-    },
-    {
-      name: "get_periodic_note",
-      description: "Get the path and existence status of a periodic note (daily, weekly, monthly, quarterly, or yearly) for a given date. Reads folder/format config from .obsidian/daily-notes.json (daily) or the periodic-notes plugin data.json. Optionally creates the note from the configured template if it is missing.",
-      inputSchema: {
-        type: "object",
-        properties: {
-          period: {
-            type: "string",
-            enum: ["daily", "weekly", "monthly", "quarterly", "yearly"],
-            description: "Period type. Default: daily."
-          },
-          date: {
-            type: "string",
-            description: "ISO date string (YYYY-MM-DD). Defaults to today when omitted."
-          },
-          createIfMissing: {
-            type: "boolean",
-            description: "Create the note from the configured template if it does not exist. Default false."
-          }
-        },
-        required: []
-      }
-    },
-    {
-      name: "append_periodic_note",
-      description: "Append text to a periodic note (daily, weekly, monthly, quarterly, or yearly). Preserves existing frontmatter exactly. Creates the note first (from template if configured) when createIfMissing is true (default).",
-      inputSchema: {
-        type: "object",
-        properties: {
-          period: {
-            type: "string",
-            enum: ["daily", "weekly", "monthly", "quarterly", "yearly"],
-            description: "Period type. Default: daily."
-          },
-          date: {
-            type: "string",
-            description: "ISO date string (YYYY-MM-DD). Defaults to today when omitted."
-          },
-          content: {
-            type: "string",
-            description: "Text to append to the note body."
-          },
-          createIfMissing: {
-            type: "boolean",
-            description: "Create the note if it does not exist before appending. Default true."
-          }
-        },
-        required: ["content"]
-      }
-    }
-  ]
+  tools: visibleTools(ctx.policy)
 }));
 server.setRequestHandler(CallToolRequestSchema, async (req) => {
   const { name, arguments: args } = req.params;
@@ -2520,7 +2788,7 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
 });
 var transport = new StdioServerTransport();
 await server.connect(transport);
-log.info("ready", { tools: 17, transport: "stdio" });
+log.info("ready", { tools: visibleTools(ctx.policy).length, transport: "stdio" });
 process.stderr.write(
   `seekstone: add to Claude Desktop:
 ${JSON.stringify(