seekstone 0.9.1 → 0.11.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,11 +51,30 @@ 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`;
 }
 
 // src/tools/append_note.ts
-import { readFile, writeFile } from "fs/promises";
+import { readFile } from "fs/promises";
 import { join } from "path";
 
 // ../core/src/frontmatter.ts
@@ -117,10 +142,72 @@ function parseFrontmatter(text) {
 
 // src/tools/append_note.ts
 import { z } from "zod";
+
+// src/atomic-write.ts
+import { rename, writeFile } from "fs/promises";
+async function atomicWrite(absPath, content) {
+  const tmpPath = `${absPath}.seekstone-tmp`;
+  await writeFile(tmpPath, content, "utf8");
+  await rename(tmpPath, absPath);
+}
+
+// src/content-hash.ts
+import { createHash } from "crypto";
+function contentHash(raw) {
+  return createHash("sha256").update(raw).digest("hex");
+}
+function assertHashMatch(raw, prevHash, path2) {
+  const actual = contentHash(raw);
+  if (actual !== prevHash) {
+    throw new Error(
+      JSON.stringify({
+        error: "hash_conflict",
+        path: path2,
+        expected: prevHash,
+        actual,
+        hint: "Note changed on disk since it was read. Re-read it and retry with the new contentHash."
+      })
+    );
+  }
+}
+
+// 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(
     "Text to append to the note body. Will be separated from existing content by a blank line."
+  ),
+  prevHash: z.string().optional().describe(
+    "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
   )
 });
 async function appendNote(ctx2, input) {
@@ -128,7 +215,9 @@ 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");
+  if (input.prevHash !== void 0) assertHashMatch(original, input.prevHash, input.path);
   const fm = parseFrontmatter(original);
   const body = fm.body.endsWith("\n") ? fm.body : `${fm.body}
 `;
@@ -136,17 +225,21 @@ async function appendNote(ctx2, input) {
   const newBody = `${body}${separator}${input.content}`;
   const header = original.slice(0, fm.bodyStart);
   const newContent = `${header}${newBody}`;
-  await writeFile(absPath, newContent, "utf8");
+  await atomicWrite(absPath, newContent);
   const cached = ctx2.notes.get(input.path);
   if (cached) {
     cached.body = newBody;
     cached.raw = newContent;
   }
-  return { path: input.path, bytesWritten: Buffer.byteLength(newContent, "utf8") };
+  return {
+    path: input.path,
+    bytesWritten: Buffer.byteLength(newContent, "utf8"),
+    contentHash: contentHash(newContent)
+  };
 }
 
 // src/tools/create_note.ts
-import { access, mkdir, writeFile as writeFile2 } from "fs/promises";
+import { access, mkdir, readFile as readFile2 } from "fs/promises";
 import { dirname, join as join2 } from "path";
 import { stringify as stringifyYaml } from "yaml";
 import { z as z2 } from "zod";
@@ -225,13 +318,22 @@ var CreateNoteInput = z2.object({
   ),
   content: z2.string().default("").describe("Body content for the note."),
   frontmatter: z2.record(z2.string(), z2.unknown()).optional().describe("Frontmatter key-value pairs to write as a YAML block at the top of the note."),
-  overwrite: z2.boolean().default(false).describe("Overwrite an existing note. Defaults to false \u2014 throws if the note already exists.")
+  overwrite: z2.boolean().default(false).describe(
+    "Overwrite an existing note. Defaults to false \u2014 throws if the note already exists."
+  ),
+  prevHash: z2.string().optional().describe(
+    "Optional compare-and-swap guard for overwrite: true \u2014 the contentHash of the note being replaced. Fails with hash_conflict if it changed since it was read."
+  )
+}).refine((v) => v.prevHash === void 0 || v.overwrite === true, {
+  message: "prevHash only makes sense with overwrite: true (a fresh create has no prior version)."
 });
-async function createNote(ctx2, input) {
+async function createNote(ctx2, rawInput) {
+  const input = CreateNoteInput.parse(rawInput);
   const absPath = join2(ctx2.vaultRoot, input.path);
   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);
@@ -239,6 +341,22 @@ async function createNote(ctx2, input) {
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
+  } else if (input.prevHash !== void 0) {
+    let existing;
+    try {
+      existing = await readFile2(absPath, "utf8");
+    } catch {
+      throw new Error(
+        JSON.stringify({
+          error: "hash_conflict",
+          path: input.path,
+          expected: input.prevHash,
+          actual: null,
+          hint: "The note no longer exists on disk. Re-check before overwriting."
+        })
+      );
+    }
+    assertHashMatch(existing, input.prevHash, input.path);
   }
   let raw = "";
   if (input.frontmatter && Object.keys(input.frontmatter).length > 0) {
@@ -248,29 +366,112 @@ ${stringifyYaml(input.frontmatter)}---
   }
   raw += input.content ?? "";
   await mkdir(dirname(absPath), { recursive: true });
-  await writeFile2(absPath, raw, "utf8");
+  await atomicWrite(absPath, raw);
   upsertDoc(ctx2, buildDoc(input.path, raw));
-  return { path: input.path, bytesWritten: Buffer.byteLength(raw, "utf8") };
+  return {
+    path: input.path,
+    bytesWritten: Buffer.byteLength(raw, "utf8"),
+    contentHash: contentHash(raw)
+  };
 }
 
 // src/tools/delete_note.ts
-import { rm } from "fs/promises";
-import { join as join3 } from "path";
+import { access as access2, mkdir as mkdir2, rename as rename2, rm } from "fs/promises";
+import { basename as basename2, extname as extname2, join as join3 } from "path";
 import { z as z3 } from "zod";
+
+// src/index/resolve.ts
+function resolveLink(target, notes2) {
+  if (notes2.has(target)) return target;
+  const withMd = `${target}.md`;
+  if (notes2.has(withMd)) return withMd;
+  const targetLower = target.toLowerCase();
+  const targetBase = (target.split("/").pop() ?? target).toLowerCase();
+  for (const path2 of notes2.keys()) {
+    const pathNoExt = path2.replace(/\.md$/i, "");
+    if (pathNoExt.toLowerCase() === targetLower) return path2;
+    const pathBase = (pathNoExt.split("/").pop() ?? pathNoExt).toLowerCase();
+    if (pathBase === targetBase) return path2;
+  }
+  return void 0;
+}
+
+// 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/delete_note.ts
 var DeleteNoteInput = z3.object({
-  path: z3.string().describe("Vault-relative path of the note to delete.")
+  path: z3.string().describe("Vault-relative path of the note to delete."),
+  permanent: z3.boolean().default(false).describe(
+    "Permanently remove the note instead of moving it to the vault .trash/ folder. Defaults to false \u2014 deletes are recoverable."
+  )
 });
-async function deleteNote(ctx2, input) {
+async function freeTrashPath(vaultRoot2, noteBase) {
+  const ext = extname2(noteBase);
+  const stem = noteBase.slice(0, noteBase.length - ext.length);
+  let candidate = `.trash/${noteBase}`;
+  for (; ; ) {
+    try {
+      await access2(join3(vaultRoot2, candidate));
+    } catch {
+      return candidate;
+    }
+    candidate = `.trash/${stem}.${Date.now()}${ext}`;
+  }
+}
+async function deleteNote(ctx2, rawInput) {
+  const input = DeleteNoteInput.parse(rawInput);
   const absPath = join3(ctx2.vaultRoot, input.path);
   if (!absPath.startsWith(ctx2.vaultRoot)) {
     throw new Error(`Path outside vault: ${input.path}`);
   }
-  await rm(absPath);
+  assertWritable(ctx2.policy, input.path);
+  let trashedTo;
+  if (input.permanent) {
+    await rm(absPath);
+  } else {
+    await access2(absPath);
+    await mkdir2(join3(ctx2.vaultRoot, ".trash"), { recursive: true });
+    trashedTo = await freeTrashPath(ctx2.vaultRoot, basename2(input.path));
+    await rename2(absPath, join3(ctx2.vaultRoot, trashedTo));
+  }
+  removeNoteBacklinks(ctx2, input.path);
   if (ctx2.notes.has(input.path)) {
     ctx2.index.discard(input.path);
     ctx2.notes.delete(input.path);
   }
-  return { path: input.path };
+  const result = { path: input.path, permanent: input.permanent };
+  if (trashedTo !== void 0) result.trashedTo = trashedTo;
+  return result;
 }
 
 // src/tools/get_backlinks.ts
@@ -313,24 +514,6 @@ function getBacklinks(ctx2, input) {
 // src/tools/get_links.ts
 import { join as join5 } from "path";
 import { z as z5 } from "zod";
-
-// src/index/resolve.ts
-function resolveLink(target, notes2) {
-  if (notes2.has(target)) return target;
-  const withMd = `${target}.md`;
-  if (notes2.has(withMd)) return withMd;
-  const targetLower = target.toLowerCase();
-  const targetBase = (target.split("/").pop() ?? target).toLowerCase();
-  for (const path2 of notes2.keys()) {
-    const pathNoExt = path2.replace(/\.md$/i, "");
-    if (pathNoExt.toLowerCase() === targetLower) return path2;
-    const pathBase = (pathNoExt.split("/").pop() ?? pathNoExt).toLowerCase();
-    if (pathBase === targetBase) return path2;
-  }
-  return void 0;
-}
-
-// src/tools/get_links.ts
 var GetLinksInput = z5.object({
   path: z5.string().describe("Vault-relative path to the note.")
 });
@@ -422,27 +605,125 @@ function listTags(ctx2, input) {
 }
 
 // src/tools/move_note.ts
-import { access as access2, mkdir as mkdir2, rename } from "fs/promises";
+import { access as access3, mkdir as mkdir3, rename as rename3 } from "fs/promises";
 import { dirname as dirname2, join as join6 } from "path";
 import { z as z8 } from "zod";
+
+// 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);
+    await access3(absFrom);
   } catch {
     throw new Error(`Note not found: ${input.from}`);
   }
   if (!input.overwrite) {
     try {
-      await access2(absTo);
+      await access3(absTo);
       throw new Error(
         `Destination already exists: ${input.to}. Pass overwrite: true to replace it.`
       );
@@ -450,19 +731,63 @@ async function moveNote(ctx2, input) {
       if (err.code !== "ENOENT") throw err;
     }
   }
-  await mkdir2(dirname2(absTo), { recursive: true });
-  await rename(absFrom, absTo);
+  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 mkdir3(dirname2(absTo), { recursive: true });
+  await rename3(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 atomicWrite(join6(ctx2.vaultRoot, path2), content);
+      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
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 import { join as join7 } from "path";
 
 // ../core/src/outline.ts
@@ -524,7 +849,7 @@ async function outlineNote(ctx2, input) {
   if (!absPath.startsWith(ctx2.vaultRoot)) {
     throw new Error(`Path outside vault: ${input.path}`);
   }
-  const raw = await readFile2(absPath, "utf8");
+  const raw = await readFile3(absPath, "utf8");
   return buildOutline(raw, {
     includeBlocks: input.includeBlocks,
     includeSizes: input.includeSizes
@@ -532,7 +857,7 @@ async function outlineNote(ctx2, input) {
 }
 
 // src/tools/patch_frontmatter.ts
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 import { join as join8 } from "path";
 import { parseDocument } from "yaml";
 import { z as z10 } from "zod";
@@ -540,6 +865,9 @@ var PatchFrontmatterInput = z10.object({
   path: z10.string().describe("Vault-relative path to the note."),
   patch: z10.record(z10.string(), z10.unknown()).describe(
     "Key-value pairs to set in the frontmatter. Existing keys not in the patch are unchanged. Pass null as a value to remove a key."
+  ),
+  prevHash: z10.string().optional().describe(
+    "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
   )
 });
 async function patchFrontmatter(ctx2, input) {
@@ -547,7 +875,9 @@ async function patchFrontmatter(ctx2, input) {
   if (!absPath.startsWith(ctx2.vaultRoot)) {
     throw new Error(`Path outside vault: ${input.path}`);
   }
-  const original = await readFile3(absPath, "utf8");
+  assertWritable(ctx2.policy, input.path);
+  const original = await readFile4(absPath, "utf8");
+  if (input.prevHash !== void 0) assertHashMatch(original, input.prevHash, input.path);
   const fm = parseFrontmatter(original);
   const keysChanged = [];
   const keysAdded = [];
@@ -589,18 +919,24 @@ ${original}`;
     const tail = opensWithCRLF ? "---\r\n" : "---\n";
     newContent = `${head}${doc.toString()}${tail}${fm.body}`;
   }
-  await writeFile3(absPath, newContent, "utf8");
+  await atomicWrite(absPath, newContent);
   const cached = ctx2.notes.get(input.path);
   if (cached) {
     const updated = parseFrontmatter(newContent);
     cached.raw = newContent;
     cached.fmKeys = updated.keys.join(" ");
   }
-  return { path: input.path, keysChanged, keysAdded, keysRemoved };
+  return {
+    path: input.path,
+    keysChanged,
+    keysAdded,
+    keysRemoved,
+    contentHash: contentHash(newContent)
+  };
 }
 
 // src/tools/patch_note.ts
-import { readFile as readFile4, rename as rename2, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 import { join as join9 } from "path";
 import { z as z11 } from "zod";
 var PatchNoteInput = z11.object({
@@ -615,6 +951,9 @@ var PatchNoteInput = z11.object({
   content: z11.string().min(1).describe("Content to insert or replace with."),
   createIfMissing: z11.boolean().default(false).describe(
     "If the heading target is not found, append a new heading (level 2) + content. Only valid for heading targets."
+  ),
+  prevHash: z11.string().optional().describe(
+    "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
   )
 });
 function lineEnd(raw, offset) {
@@ -626,17 +965,14 @@ function lineStart(raw, offset) {
   const prev = raw.lastIndexOf("\n", offset - 1);
   return prev === -1 ? 0 : prev + 1;
 }
-async function atomicWrite(absPath, content) {
-  const tmpPath = `${absPath}.seekstone-patch-tmp`;
-  await writeFile4(tmpPath, content, "utf8");
-  await rename2(tmpPath, absPath);
-}
 async function patchNote(ctx2, input) {
   const absPath = join9(ctx2.vaultRoot, input.path);
   if (!absPath.startsWith(ctx2.vaultRoot)) {
     throw new Error(`Path outside vault: ${input.path}`);
   }
-  const raw = await readFile4(absPath, "utf8");
+  assertWritable(ctx2.policy, input.path);
+  const raw = await readFile5(absPath, "utf8");
+  if (input.prevHash !== void 0) assertHashMatch(raw, input.prevHash, input.path);
   const fm = parseFrontmatter(raw);
   const originalFmRegion = raw.slice(0, fm.bodyStart);
   const outline = buildOutline(raw, { includeBlocks: true });
@@ -664,7 +1000,8 @@ ${input.content}${contentNl}`;
             line: newContent2.slice(0, headingOffset).split("\n").length,
             byteOffset: headingOffset
           },
-          frontmatterUnchanged: true
+          frontmatterUnchanged: true,
+          contentHash: contentHash(newContent2)
         };
       }
       throw new Error(
@@ -729,11 +1066,12 @@ ${input.content}${contentNl}`;
     path: input.path,
     bytesWritten: Buffer.byteLength(newContent, "utf8"),
     targetResolvedAt: resolvedAt,
-    frontmatterUnchanged: true
+    frontmatterUnchanged: true,
+    contentHash: contentHash(newContent)
   };
 }
 async function verifyFrontmatter(absPath, originalFmRegion) {
-  const written = await readFile4(absPath, "utf8");
+  const written = await readFile5(absPath, "utf8");
   if (written.slice(0, originalFmRegion.length) !== originalFmRegion) {
     throw new Error("Write-safety violation: frontmatter region changed unexpectedly");
   }
@@ -748,7 +1086,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 access4, mkdir as mkdir4, readFile as readFile6 } 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"]);
@@ -761,7 +1099,7 @@ var DEFAULTS = {
 };
 async function readJson(absPath) {
   try {
-    return JSON.parse(await readFile5(absPath, "utf8"));
+    return JSON.parse(await readFile6(absPath, "utf8"));
   } catch {
     return null;
   }
@@ -834,12 +1172,13 @@ async function getPeriodicNote(ctx2, rawInput) {
   if (!abs.startsWith(ctx2.vaultRoot)) throw new Error(`Path outside vault: ${path2}`);
   let existed = false;
   try {
-    await access3(abs);
+    await access4(abs);
     existed = true;
   } catch {
   }
   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(
@@ -848,21 +1187,24 @@ async function getPeriodicNote(ctx2, rawInput) {
     );
     if (templateAbs.startsWith(ctx2.vaultRoot)) {
       try {
-        body = await readFile5(templateAbs, "utf8");
+        body = await readFile6(templateAbs, "utf8");
       } catch {
       }
     }
   }
-  await mkdir3(dirname3(abs), { recursive: true });
-  await writeFile5(abs, body, "utf8");
+  await mkdir4(dirname3(abs), { recursive: true });
+  await atomicWrite(abs, body);
   upsertDoc(ctx2, buildDoc(path2, body));
-  return { path: path2, existed: false, created: true };
+  return { path: path2, existed: false, created: true, contentHash: contentHash(body) };
 }
 var AppendPeriodicNoteInput = z12.object({
   period: PERIOD.default("daily").describe("Period type. Default: daily."),
   date: z12.string().optional().describe("ISO date string (YYYY-MM-DD). Defaults to today."),
   content: z12.string().min(1).describe("Text to append to the note body. Separated from existing content by a blank line."),
-  createIfMissing: z12.boolean().default(true).describe("Create the note if it does not exist before appending. Default true.")
+  createIfMissing: z12.boolean().default(true).describe("Create the note if it does not exist before appending. Default true."),
+  prevHash: z12.string().optional().describe(
+    "Optional compare-and-swap guard: the contentHash from a prior read of the resolved periodic note. Fails with hash_conflict if it changed since."
+  )
 });
 async function appendPeriodicNote(ctx2, rawInput) {
   const input = AppendPeriodicNoteInput.parse(rawInput);
@@ -871,16 +1213,33 @@ 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");
+    original = await readFile6(abs, "utf8");
+    if (input.prevHash !== void 0) assertHashMatch(original, input.prevHash, path2);
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
+    if (input.prevHash !== void 0) {
+      throw new Error(
+        JSON.stringify({
+          error: "hash_conflict",
+          path: path2,
+          expected: input.prevHash,
+          actual: null,
+          hint: "The periodic note no longer exists on disk. Re-read before retrying."
+        })
+      );
+    }
     if (!input.createIfMissing) throw new Error(`Periodic note not found: ${path2}`);
-    await mkdir3(dirname3(abs), { recursive: true });
-    await writeFile5(abs, input.content, "utf8");
+    await mkdir4(dirname3(abs), { recursive: true });
+    await atomicWrite(abs, input.content);
     upsertDoc(ctx2, buildDoc(path2, input.content));
-    return { path: path2, bytesWritten: Buffer.byteLength(input.content, "utf8") };
+    return {
+      path: path2,
+      bytesWritten: Buffer.byteLength(input.content, "utf8"),
+      contentHash: contentHash(input.content)
+    };
   }
   const fm = parseFrontmatter(original);
   const body = fm.body.endsWith("\n") ? fm.body : `${fm.body}
@@ -889,13 +1248,17 @@ 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 atomicWrite(abs, newRaw);
   const cached = ctx2.notes.get(path2);
   if (cached) {
     cached.body = newBody;
     cached.raw = newRaw;
   }
-  return { path: path2, bytesWritten: Buffer.byteLength(newRaw, "utf8") };
+  return {
+    path: path2,
+    bytesWritten: Buffer.byteLength(newRaw, "utf8"),
+    contentHash: contentHash(newRaw)
+  };
 }
 
 // src/tools/query_notes.ts
@@ -1104,7 +1467,7 @@ function queryNotes(ctx2, input) {
 }
 
 // src/tools/read_note.ts
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile7 } from "fs/promises";
 import { join as join11 } from "path";
 import { z as z15 } from "zod";
 var ReadNoteInput = z15.object({
@@ -1126,10 +1489,17 @@ async function readNote(ctx2, input) {
   if (!absPath.startsWith(ctx2.vaultRoot)) {
     throw new Error(`Path outside vault: ${input.path}`);
   }
-  const raw = await readFile6(absPath, "utf8");
+  const raw = await readFile7(absPath, "utf8");
   const noteBytes = Buffer.byteLength(raw, "utf8");
+  const hash = contentHash(raw);
   if (input.section === void 0 && input.block === void 0 && input.lines === void 0) {
-    return { path: input.path, content: raw, bytesReturned: noteBytes, noteBytes };
+    return {
+      path: input.path,
+      content: raw,
+      bytesReturned: noteBytes,
+      noteBytes,
+      contentHash: hash
+    };
   }
   const fm = parseFrontmatter(raw);
   const outline = buildOutline(raw, { includeBlocks: true });
@@ -1201,12 +1571,13 @@ async function readNote(ctx2, input) {
     content,
     bytesReturned: Buffer.byteLength(content, "utf8"),
     noteBytes,
+    contentHash: hash,
     span: { charStart, charEnd }
   };
 }
 
 // src/tools/replace_in_note.ts
-import { readFile as readFile7, rename as rename3, writeFile as writeFile6 } from "fs/promises";
+import { readFile as readFile8 } from "fs/promises";
 import { join as join12 } from "path";
 import { z as z16 } from "zod";
 var ReplaceInNoteInput = z16.object({
@@ -1217,7 +1588,10 @@ var ReplaceInNoteInput = z16.object({
   caseSensitive: z16.boolean().default(false).describe("Case-sensitive matching."),
   wholeWord: z16.boolean().default(false).describe("Match whole words only (\\b word-boundary)."),
   limit: z16.number().int().min(1).optional().describe("Maximum number of replacements. Omit to replace all."),
-  dryRun: z16.boolean().default(false).describe("If true, report matches without writing anything.")
+  dryRun: z16.boolean().default(false).describe("If true, report matches without writing anything."),
+  prevHash: z16.string().optional().describe(
+    "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
+  )
 });
 function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -1228,16 +1602,12 @@ function buildRegex(find, opts) {
   const flags = `g${opts.caseSensitive ? "" : "i"}`;
   return new RegExp(pattern, flags);
 }
-async function atomicWrite2(absPath, content) {
-  const tmpPath = `${absPath}.seekstone-replace-tmp`;
-  await writeFile6(tmpPath, content, "utf8");
-  await rename3(tmpPath, absPath);
-}
 async function replaceInNote(ctx2, input) {
   const absPath = join12(ctx2.vaultRoot, input.path);
   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, {
@@ -1248,7 +1618,8 @@ async function replaceInNote(ctx2, input) {
   } catch (err) {
     throw new Error(`Invalid regex: ${err instanceof Error ? err.message : String(err)}`);
   }
-  const raw = await readFile7(absPath, "utf8");
+  const raw = await readFile8(absPath, "utf8");
+  if (input.prevHash !== void 0) assertHashMatch(raw, input.prevHash, input.path);
   const fm = parseFrontmatter(raw);
   const originalFmRegion = raw.slice(0, fm.bodyStart);
   const body = raw.slice(fm.bodyStart);
@@ -1278,8 +1649,8 @@ async function replaceInNote(ctx2, input) {
   }
   newBody += body.slice(lastIndex);
   const newContent = `${originalFmRegion}${newBody}`;
-  await atomicWrite2(absPath, newContent);
-  const written = await readFile7(absPath, "utf8");
+  await atomicWrite(absPath, newContent);
+  const written = await readFile8(absPath, "utf8");
   if (written.slice(0, originalFmRegion.length) !== originalFmRegion) {
     throw new Error("Write-safety violation: frontmatter region changed unexpectedly");
   }
@@ -1294,11 +1665,22 @@ async function replaceInNote(ctx2, input) {
     replacements: toReplace.length,
     matches: matches2,
     bytesWritten: Buffer.byteLength(newContent, "utf8"),
-    frontmatterUnchanged: true
+    frontmatterUnchanged: true,
+    contentHash: contentHash(newContent)
   };
 }
 
 // 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",
@@ -1317,7 +1699,9 @@ var META_KEYS = [
   "minSizeBytes",
   "maxSizeBytes",
   "period",
-  "date"
+  "date",
+  "permanent",
+  "prevHash"
 ];
 function safeMeta(args) {
   if (typeof args !== "object" || args === null) return {};
@@ -1339,6 +1723,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;
@@ -1388,25 +1789,38 @@ async function run(ctx2, name, args) {
       const input = CreateNoteInput.parse(args);
       const result = await createNote(ctx2, input);
       return {
-        content: [{ type: "text", text: `Created ${result.path} (${result.bytesWritten} bytes).` }]
+        content: [
+          {
+            type: "text",
+            text: `Created ${result.path} (${result.bytesWritten} bytes). contentHash: ${result.contentHash}`
+          }
+        ]
       };
     }
     case "delete_note": {
       const input = DeleteNoteInput.parse(args);
-      await deleteNote(ctx2, input);
-      return { content: [{ type: "text", text: `Deleted ${input.path}.` }] };
+      const result = await deleteNote(ctx2, input);
+      const text = result.trashedTo ? `Moved ${result.path} to ${result.trashedTo} (recoverable \u2014 restore by moving it back).` : `Permanently deleted ${result.path}.`;
+      return { content: [{ type: "text", text }] };
     }
     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);
       const result = await appendNote(ctx2, input);
       return {
         content: [
-          { type: "text", text: `Appended ${result.bytesWritten} bytes to ${result.path}.` }
+          {
+            type: "text",
+            text: `Appended ${result.bytesWritten} bytes to ${result.path}. contentHash: ${result.contentHash}`
+          }
         ]
       };
     }
@@ -1452,7 +1866,7 @@ async function run(ctx2, name, args) {
         content: [
           {
             type: "text",
-            text: `Appended ${result.bytesWritten} bytes to ${result.path}.`
+            text: `Appended ${result.bytesWritten} bytes to ${result.path}. contentHash: ${result.contentHash}`
           }
         ]
       };
@@ -1463,12 +1877,12 @@ async function run(ctx2, name, args) {
 }
 
 // src/index/build.ts
-import { readFile as readFile8 } from "fs/promises";
-import { basename as basename2, extname as extname3 } from "path";
+import { readFile as readFile9 } from "fs/promises";
+import { basename as basename3, extname as extname4 } from "path";
 
 // ../core/src/walk.ts
 import { stat } from "fs/promises";
-import { extname as extname2, join as join13, relative, sep } from "path";
+import { extname as extname3, join as join13, relative, sep } from "path";
 import fg from "fast-glob";
 var IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".bmp", ".heic"]);
 var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".webm", ".mkv", ".avi"]);
@@ -1483,7 +1897,7 @@ var IGNORE_GLOBS = [
 function classify(relPath) {
   if (relPath.endsWith(".excalidraw.md")) return "note";
   if (relPath.endsWith(".excalidraw")) return "excalidraw";
-  const ext = extname2(relPath).toLowerCase();
+  const ext = extname3(relPath).toLowerCase();
   if (ext === ".md") return "note";
   if (ext === ".canvas") return "canvas";
   if (ext === ".pdf") return "pdf";
@@ -1515,7 +1929,7 @@ async function walkVault(vaultRoot2) {
       absPath,
       relPath,
       topDir,
-      ext: extname2(relPath).toLowerCase(),
+      ext: extname3(relPath).toLowerCase(),
       kind: classify(relPath),
       sizeBytes: stats.size,
       mtimeMs: stats.mtimeMs
@@ -1545,12 +1959,12 @@ async function buildIndex(vaultRoot2) {
   await Promise.all(
     noteEntries.map(async (entry) => {
       try {
-        const raw = await readFile8(entry.absPath, "utf8");
+        const raw = await readFile9(entry.absPath, "utf8");
         const fm = parseFrontmatter(raw);
         const inlineTags = extractInlineTags(fm.body);
         const fmTags = frontmatterTags(fm.data);
         const allTags = [.../* @__PURE__ */ new Set([...inlineTags, ...fmTags])];
-        const title = typeof fm.data?.title === "string" && fm.data.title ? fm.data.title : basename2(entry.relPath, extname3(entry.relPath));
+        const title = typeof fm.data?.title === "string" && fm.data.title ? fm.data.title : basename3(entry.relPath, extname4(entry.relPath));
         const doc = {
           id: entry.relPath,
           title,
@@ -1598,7 +2012,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 access5, copyFile, mkdir as mkdir5, readdir, readFile as readFile10, stat as stat2, writeFile as writeFile2 } from "fs/promises";
 import path, { dirname as dirname4, join as join14 } from "path";
 function parseInitArgs(argv) {
   const opts = { write: false, client: "desktop" };
@@ -1609,6 +2023,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;
@@ -1703,7 +2118,7 @@ async function validateVault(vaultPath) {
     return { ok: false, error: `Path does not exist: ${vaultPath}` };
   }
   try {
-    await access4(join14(vaultPath, ".obsidian"));
+    await access5(join14(vaultPath, ".obsidian"));
   } catch {
     return {
       ok: false,
@@ -1732,7 +2147,16 @@ async function countMarkdown(root) {
   return count;
 }
 async function runInit(opts, deps) {
-  const rf = deps.readFile ?? readFile9;
+  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 ?? readFile10;
   let vaultPath = opts.vault ?? deps.env.SEEKSTONE_VAULT;
   if (!vaultPath) {
     const registryPath = obsidianRegistryPath(deps.platform, {
@@ -1863,12 +2287,12 @@ async function runInit(opts, deps) {
   }
   const merged = opts.client === "vscode" ? mergeSeekstoneConfigVsCode(existing, vaultPath) : mergeSeekstoneConfig(existing, vaultPath);
   let backupPath;
-  await mkdir4(dirname4(configPath), { recursive: true });
+  await mkdir5(dirname4(configPath), { recursive: true });
   if (existingRaw !== null) {
     backupPath = `${configPath}.backup-${deps.timestamp}`;
     await copyFile(configPath, backupPath);
   }
-  await writeFile7(configPath, `${JSON.stringify(merged, null, 2)}
+  await writeFile2(configPath, `${JSON.stringify(merged, null, 2)}
 `, "utf8");
   out.push(
     `\u2713 Patched ${configPath}`,
@@ -1939,7 +2363,7 @@ function createLogger(opts = {}) {
       );
     }
   }
-  function writeFile8(record) {
+  function writeFile3(record) {
     if (!fileOk || filePath === void 0) return;
     const line = `${JSON.stringify(record)}
 `;
@@ -1961,7 +2385,7 @@ function createLogger(opts = {}) {
     const f = fields ?? {};
     stderr(`${lvl.toUpperCase().padEnd(5)} ${ts} ${msg}${fmtFields(f)}
 `);
-    writeFile8({ t: ts, level: lvl, msg, ...f });
+    writeFile3({ t: ts, level: lvl, msg, ...f });
   }
   return {
     level,
@@ -1992,41 +2416,435 @@ 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, total note size, and a contentHash to pass as prevHash to edit tools for compare-and-swap. 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 (prevHash may guard the overwrite).",
+    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."
+        },
+        prevHash: {
+          type: "string",
+          description: "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
+        }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "delete_note",
+    description: "Delete a note. By default it is moved to the vault .trash/ folder (recoverable by moving it back); pass permanent: true to remove it outright.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Vault-relative path of the note to delete." },
+        permanent: {
+          type: "boolean",
+          description: "Permanently remove instead of moving to .trash/. Defaults to false."
+        }
+      },
+      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." },
+        prevHash: {
+          type: "string",
+          description: "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
+        }
+      },
+      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
+        },
+        prevHash: {
+          type: "string",
+          description: "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
+        }
+      },
+      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."
+        },
+        prevHash: {
+          type: "string",
+          description: "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
+        }
+      },
+      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."
+        },
+        prevHash: {
+          type: "string",
+          description: "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
+        }
+      },
+      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."
+        },
+        prevHash: {
+          type: "string",
+          description: "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
+        }
+      },
+      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 { readFile as readFile11 } 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;
@@ -2037,7 +2855,7 @@ function startWatcher(ctx2, log2, opts) {
   const toRel = (abs) => relative2(vaultRoot2, abs).split(sep2).join("/");
   async function upsert(relPath, op) {
     try {
-      const raw = await readFile10(join15(vaultRoot2, relPath), "utf8");
+      const raw = await readFile11(join15(vaultRoot2, relPath), "utf8");
       removeNoteBacklinks(ctx2, relPath);
       upsertDoc(ctx2, buildDoc(relPath, raw));
       addNoteBacklinks(ctx2, relPath, raw);
@@ -2089,7 +2907,7 @@ function startWatcher(ctx2, log2, opts) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.9.1" : "0.0.0-dev";
+var VERSION = true ? "0.11.0" : "0.0.0-dev";
 var intent = parseCliIntent(process.argv.slice(2));
 if (intent === "version") {
   process.stdout.write(`${VERSION}
@@ -2101,6 +2919,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 +2942,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", () => 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 +2961,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(