seekstone 0.5.0 → 0.6.1

package/dist/index.js

@@ -155,12 +155,12 @@ import { z as z2 } from "zod";
 import { basename, extname } from "path";
 
 // ../core/src/extract.ts
-var LINK_WITH_LINES_RE_SRC = /(!?\[\[)([^\]|#\n]+)(#[^\]|\n]+)?(\|[^\]\n]+)?(\]\])/.source;
+var LINK_WITH_LINES_RE = /(!?\[\[)([^\]|#\n]{1,512})(#[^\]|\n]{1,512})?(\|[^\]\n]{1,512})?(\]\])/g;
 function extractLinksWithLines(raw) {
   const out = [];
   const lines = raw.split("\n");
   for (const [lineIdx, lineText] of lines.entries()) {
-    for (const m of lineText.matchAll(new RegExp(LINK_WITH_LINES_RE_SRC, "g"))) {
+    for (const m of lineText.matchAll(LINK_WITH_LINES_RE)) {
       const prefix = m[1] ?? "";
       out.push({
         raw: m[0] ?? "",
@@ -746,30 +746,181 @@ function updateCache(ctx2, path2, newContent, bodyStart) {
   }
 }
 
-// src/tools/read_note.ts
-import { readFile as readFile5 } from "fs/promises";
-import { join as join10 } from "path";
+// src/tools/periodic_note.ts
+import { access as access3, mkdir as mkdir3, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname3, join as join10 } from "path";
 import { z as z12 } from "zod";
-var ReadNoteInput = z12.object({
-  path: z12.string().describe('Vault-relative path to the note, e.g. "Daily Notes/2026-05-29.md".'),
-  section: z12.string().optional().describe("Return only this heading section (heading text, # prefix optional)."),
-  block: z12.string().optional().describe("Return only the block anchored by this id (^ prefix optional)."),
-  lines: z12.object({
-    from: z12.number().int().min(1).describe("First line (1-indexed, inclusive)."),
-    to: z12.number().int().min(1).optional().describe("Last line (1-indexed, inclusive). Defaults to end of file.")
+var PERIOD = z12.enum(["daily", "weekly", "monthly", "quarterly", "yearly"]);
+var DEFAULTS = {
+  daily: { folder: "", format: "YYYY-MM-DD", template: "" },
+  weekly: { folder: "", format: "gggg-[W]ww", template: "" },
+  monthly: { folder: "", format: "YYYY-MM", template: "" },
+  quarterly: { folder: "", format: "YYYY-[Q]Q", template: "" },
+  yearly: { folder: "", format: "YYYY", template: "" }
+};
+async function readJson(absPath) {
+  try {
+    return JSON.parse(await readFile5(absPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function resolveConfig(vaultRoot2, period) {
+  const defaults = DEFAULTS[period];
+  if (period === "daily") {
+    const cfg2 = await readJson(join10(vaultRoot2, ".obsidian", "daily-notes.json"));
+    return {
+      folder: cfg2?.folder ?? defaults.folder,
+      format: cfg2?.format ?? defaults.format,
+      template: cfg2?.template ?? defaults.template
+    };
+  }
+  const cfg = await readJson(
+    join10(vaultRoot2, ".obsidian", "plugins", "periodic-notes", "data.json")
+  );
+  const entry = cfg?.[period];
+  return {
+    folder: entry?.folder ?? defaults.folder,
+    format: entry?.format ?? defaults.format,
+    template: entry?.template ?? defaults.template
+  };
+}
+function isoWeekAndYear(date) {
+  const d = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+  const day = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - day);
+  const jan1 = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  const week = Math.ceil(((d.getTime() - jan1.getTime()) / 864e5 + 1) / 7);
+  return { week, year: d.getUTCFullYear() };
+}
+function formatMomentDate(date, format) {
+  const year = date.getUTCFullYear();
+  const month = date.getUTCMonth() + 1;
+  const day = date.getUTCDate();
+  const quarter = Math.ceil(month / 3);
+  const { week: isoWeek, year: isoYear } = isoWeekAndYear(date);
+  const PLACEHOLDER = "\0";
+  const literals = [];
+  let s = format.replace(/\[([^\]]*)\]/g, (_, lit) => {
+    literals.push(lit);
+    return `${PLACEHOLDER}${literals.length - 1}${PLACEHOLDER}`;
+  });
+  s = s.replace(/gggg/g, String(isoYear).padStart(4, "0")).replace(/YYYY/g, String(year).padStart(4, "0")).replace(/YY/g, String(year).slice(-2)).replace(/MM/g, String(month).padStart(2, "0")).replace(/M/g, String(month)).replace(/DD/g, String(day).padStart(2, "0")).replace(/D/g, String(day)).replace(/ww/g, String(isoWeek).padStart(2, "0")).replace(/W/g, String(isoWeek)).replace(/Q/g, String(quarter));
+  return s.replace(
+    new RegExp(`${PLACEHOLDER}(\\d+)${PLACEHOLDER}`, "g"),
+    (_, i) => literals[+i] ?? ""
+  );
+}
+function resolveNotePath(cfg, date) {
+  const filename = `${formatMomentDate(date, cfg.format)}.md`;
+  return cfg.folder ? `${cfg.folder}/${filename}` : filename;
+}
+var GetPeriodicNoteInput = z12.object({
+  period: PERIOD.default("daily").describe(
+    "Period type: daily (default), weekly, monthly, quarterly, or yearly."
+  ),
+  date: z12.string().optional().describe("ISO date string (YYYY-MM-DD). Defaults to today when omitted."),
+  createIfMissing: z12.boolean().default(false).describe(
+    "Create the note from the configured template if it does not exist. Default false \u2014 reports missing without creating."
+  )
+});
+async function getPeriodicNote(ctx2, rawInput) {
+  const input = GetPeriodicNoteInput.parse(rawInput);
+  const date = input.date ? new Date(input.date) : /* @__PURE__ */ new Date();
+  const cfg = await resolveConfig(ctx2.vaultRoot, input.period);
+  const path2 = resolveNotePath(cfg, date);
+  const abs = join10(ctx2.vaultRoot, path2);
+  if (!abs.startsWith(ctx2.vaultRoot)) throw new Error(`Path outside vault: ${path2}`);
+  let existed = false;
+  try {
+    await access3(abs);
+    existed = true;
+  } catch {
+  }
+  if (existed) return { path: path2, existed: true, created: false };
+  if (!input.createIfMissing) return { path: path2, existed: false, created: false };
+  let body = "";
+  if (cfg.template) {
+    const templateAbs = join10(
+      ctx2.vaultRoot,
+      cfg.template.endsWith(".md") ? cfg.template : `${cfg.template}.md`
+    );
+    if (templateAbs.startsWith(ctx2.vaultRoot)) {
+      try {
+        body = await readFile5(templateAbs, "utf8");
+      } catch {
+      }
+    }
+  }
+  await mkdir3(dirname3(abs), { recursive: true });
+  await writeFile5(abs, body, "utf8");
+  upsertDoc(ctx2, buildDoc(path2, body));
+  return { path: path2, existed: false, created: true };
+}
+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.")
+});
+async function appendPeriodicNote(ctx2, rawInput) {
+  const input = AppendPeriodicNoteInput.parse(rawInput);
+  const date = input.date ? new Date(input.date) : /* @__PURE__ */ new Date();
+  const cfg = await resolveConfig(ctx2.vaultRoot, input.period);
+  const path2 = resolveNotePath(cfg, date);
+  const abs = join10(ctx2.vaultRoot, path2);
+  if (!abs.startsWith(ctx2.vaultRoot)) throw new Error(`Path outside vault: ${path2}`);
+  let original = "";
+  try {
+    original = await readFile5(abs, "utf8");
+  } catch (err) {
+    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");
+    upsertDoc(ctx2, buildDoc(path2, input.content));
+    return { path: path2, bytesWritten: Buffer.byteLength(input.content, "utf8") };
+  }
+  const fm = parseFrontmatter(original);
+  const body = fm.body.endsWith("\n") ? fm.body : `${fm.body}
+`;
+  const separator = body.endsWith("\n\n") ? "" : "\n";
+  const newBody = `${body}${separator}${input.content}`;
+  const header = original.slice(0, fm.bodyStart);
+  const newRaw = `${header}${newBody}`;
+  await writeFile5(abs, newRaw, "utf8");
+  const cached = ctx2.notes.get(path2);
+  if (cached) {
+    cached.body = newBody;
+    cached.raw = newRaw;
+  }
+  return { path: path2, bytesWritten: Buffer.byteLength(newRaw, "utf8") };
+}
+
+// src/tools/read_note.ts
+import { readFile as readFile6 } from "fs/promises";
+import { join as join11 } from "path";
+import { z as z13 } from "zod";
+var ReadNoteInput = z13.object({
+  path: z13.string().describe('Vault-relative path to the note, e.g. "Daily Notes/2026-05-29.md".'),
+  section: z13.string().optional().describe("Return only this heading section (heading text, # prefix optional)."),
+  block: z13.string().optional().describe("Return only the block anchored by this id (^ prefix optional)."),
+  lines: z13.object({
+    from: z13.number().int().min(1).describe("First line (1-indexed, inclusive)."),
+    to: z13.number().int().min(1).optional().describe("Last line (1-indexed, inclusive). Defaults to end of file.")
   }).optional().describe("Return only this line range (1-indexed, inclusive)."),
-  includeFrontmatter: z12.boolean().optional().describe(
+  includeFrontmatter: z13.boolean().optional().describe(
     "Include frontmatter in span results. Default false for section/block spans. No effect on lines or whole-note reads."
   )
 }).refine((v) => [v.section, v.block, v.lines].filter((x) => x !== void 0).length <= 1, {
   message: "At most one of section, block, or lines may be specified."
 });
 async function readNote(ctx2, input) {
-  const absPath = join10(ctx2.vaultRoot, input.path);
+  const absPath = join11(ctx2.vaultRoot, input.path);
   if (!absPath.startsWith(ctx2.vaultRoot)) {
     throw new Error(`Path outside vault: ${input.path}`);
   }
-  const raw = await readFile5(absPath, "utf8");
+  const raw = await readFile6(absPath, "utf8");
   const noteBytes = Buffer.byteLength(raw, "utf8");
   if (input.section === void 0 && input.block === void 0 && input.lines === void 0) {
     return { path: input.path, content: raw, bytesReturned: noteBytes, noteBytes };
@@ -849,18 +1000,18 @@ async function readNote(ctx2, input) {
 }
 
 // src/tools/replace_in_note.ts
-import { readFile as readFile6, rename as rename3, writeFile as writeFile5 } from "fs/promises";
-import { join as join11 } from "path";
-import { z as z13 } from "zod";
-var ReplaceInNoteInput = z13.object({
-  path: z13.string().describe("Vault-relative path to the note."),
-  find: z13.string().min(1).describe("Text or pattern to find."),
-  replace: z13.string().describe("Replacement text. Supports $1, $2, \u2026 backreferences in regex mode."),
-  regex: z13.boolean().default(false).describe("Treat find as a regular expression."),
-  caseSensitive: z13.boolean().default(false).describe("Case-sensitive matching."),
-  wholeWord: z13.boolean().default(false).describe("Match whole words only (\\b word-boundary)."),
-  limit: z13.number().int().min(1).optional().describe("Maximum number of replacements. Omit to replace all."),
-  dryRun: z13.boolean().default(false).describe("If true, report matches without writing anything.")
+import { readFile as readFile7, rename as rename3, writeFile as writeFile6 } from "fs/promises";
+import { join as join12 } from "path";
+import { z as z14 } from "zod";
+var ReplaceInNoteInput = z14.object({
+  path: z14.string().describe("Vault-relative path to the note."),
+  find: z14.string().min(1).max(1e3).describe("Text or pattern to find (max 1000 chars; bounds regex-mode pattern size)."),
+  replace: z14.string().describe("Replacement text. Supports $1, $2, \u2026 backreferences in regex mode."),
+  regex: z14.boolean().default(false).describe("Treat find as a regular expression."),
+  caseSensitive: z14.boolean().default(false).describe("Case-sensitive matching."),
+  wholeWord: z14.boolean().default(false).describe("Match whole words only (\\b word-boundary)."),
+  limit: z14.number().int().min(1).optional().describe("Maximum number of replacements. Omit to replace all."),
+  dryRun: z14.boolean().default(false).describe("If true, report matches without writing anything.")
 });
 function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -873,11 +1024,11 @@ function buildRegex(find, opts) {
 }
 async function atomicWrite2(absPath, content) {
   const tmpPath = `${absPath}.seekstone-replace-tmp`;
-  await writeFile5(tmpPath, content, "utf8");
+  await writeFile6(tmpPath, content, "utf8");
   await rename3(tmpPath, absPath);
 }
 async function replaceInNote(ctx2, input) {
-  const absPath = join11(ctx2.vaultRoot, input.path);
+  const absPath = join12(ctx2.vaultRoot, input.path);
   if (!absPath.startsWith(ctx2.vaultRoot)) {
     throw new Error(`Path outside vault: ${input.path}`);
   }
@@ -891,7 +1042,7 @@ async function replaceInNote(ctx2, input) {
   } catch (err) {
     throw new Error(`Invalid regex: ${err instanceof Error ? err.message : String(err)}`);
   }
-  const raw = await readFile6(absPath, "utf8");
+  const raw = await readFile7(absPath, "utf8");
   const fm = parseFrontmatter(raw);
   const originalFmRegion = raw.slice(0, fm.bodyStart);
   const body = raw.slice(fm.bodyStart);
@@ -922,7 +1073,7 @@ async function replaceInNote(ctx2, input) {
   newBody += body.slice(lastIndex);
   const newContent = `${originalFmRegion}${newBody}`;
   await atomicWrite2(absPath, newContent);
-  const written = await readFile6(absPath, "utf8");
+  const written = await readFile7(absPath, "utf8");
   if (written.slice(0, originalFmRegion.length) !== originalFmRegion) {
     throw new Error("Write-safety violation: frontmatter region changed unexpectedly");
   }
@@ -942,7 +1093,7 @@ async function replaceInNote(ctx2, input) {
 }
 
 // src/tools/search.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // src/index/excerpt.ts
 function extractExcerpt(text, terms, maxLen = 200) {
@@ -969,11 +1120,11 @@ function truncate(s, max) {
 }
 
 // src/tools/search.ts
-var SearchInput = z14.object({
-  query: z14.string().min(1).describe("Search query. Supports fuzzy matching and prefix search."),
-  limit: z14.number().int().min(1).max(50).default(10).describe("Maximum number of results to return."),
-  folder: z14.string().optional().describe("Restrict results to notes under this vault-relative folder prefix."),
-  tag: z14.string().optional().describe("Restrict results to notes containing this tag.")
+var SearchInput = z15.object({
+  query: z15.string().min(1).describe("Search query. Supports fuzzy matching and prefix search."),
+  limit: z15.number().int().min(1).max(50).default(10).describe("Maximum number of results to return."),
+  folder: z15.string().optional().describe("Restrict results to notes under this vault-relative folder prefix."),
+  tag: z15.string().optional().describe("Restrict results to notes containing this tag.")
 });
 function search(ctx2, input) {
   const results = ctx2.index.search(input.query, {
@@ -1017,7 +1168,9 @@ var META_KEYS = [
   "overwrite",
   "pattern",
   "minCount",
-  "sort"
+  "sort",
+  "period",
+  "date"
 ];
 function safeMeta(args) {
   if (typeof args !== "object" || args === null) return {};
@@ -1134,18 +1287,35 @@ async function run(ctx2, name, args) {
       const result = await replaceInNote(ctx2, input);
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
+    case "get_periodic_note": {
+      const input = GetPeriodicNoteInput.parse(args);
+      const result = await getPeriodicNote(ctx2, input);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    case "append_periodic_note": {
+      const input = AppendPeriodicNoteInput.parse(args);
+      const result = await appendPeriodicNote(ctx2, input);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Appended ${result.bytesWritten} bytes to ${result.path}.`
+          }
+        ]
+      };
+    }
     default:
       throw new Error(`Unknown tool: ${name}`);
   }
 }
 
 // src/index/build.ts
-import { readFile as readFile7 } from "fs/promises";
+import { readFile as readFile8 } from "fs/promises";
 import { basename as basename2, extname as extname3 } from "path";
 
 // ../core/src/walk.ts
 import { stat } from "fs/promises";
-import { extname as extname2, join as join12, relative, sep } from "path";
+import { extname as extname2, 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"]);
@@ -1222,7 +1392,7 @@ async function buildIndex(vaultRoot2) {
   await Promise.all(
     noteEntries.map(async (entry) => {
       try {
-        const raw = await readFile7(entry.absPath, "utf8");
+        const raw = await readFile8(entry.absPath, "utf8");
         const fm = parseFrontmatter(raw);
         const inlineTags = extractInlineTags(fm.body);
         const fmTags = frontmatterTags(fm.data);
@@ -1274,8 +1444,8 @@ function buildBacklinks(notes2) {
 
 // src/init.ts
 import { execFileSync } from "child_process";
-import { access as access3, copyFile, mkdir as mkdir3, readFile as readFile8, readdir, stat as stat2, writeFile as writeFile6 } from "fs/promises";
-import path, { dirname as dirname3, join as join13 } from "path";
+import { access as access4, copyFile, mkdir as mkdir4, readdir, readFile as readFile9, stat as stat2, writeFile as writeFile7 } from "fs/promises";
+import path, { dirname as dirname4, join as join14 } from "path";
 function parseInitArgs(argv) {
   const opts = { write: false, client: "desktop" };
   for (let i = 0; i < argv.length; i++) {
@@ -1363,7 +1533,7 @@ async function validateVault(vaultPath) {
     return { ok: false, error: `Path does not exist: ${vaultPath}` };
   }
   try {
-    await access3(join13(vaultPath, ".obsidian"));
+    await access4(join14(vaultPath, ".obsidian"));
   } catch {
     return {
       ok: false,
@@ -1383,7 +1553,7 @@ async function countMarkdown(root) {
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = join13(dir, e.name);
+      const full = join14(dir, e.name);
       if (e.isDirectory()) await walk(full);
       else if (e.name.endsWith(".md")) count++;
     }
@@ -1392,7 +1562,7 @@ async function countMarkdown(root) {
   return count;
 }
 async function runInit(opts, deps) {
-  const rf = deps.readFile ?? readFile8;
+  const rf = deps.readFile ?? readFile9;
   let vaultPath = opts.vault ?? deps.env.SEEKSTONE_VAULT;
   if (!vaultPath) {
     const registryPath = obsidianRegistryPath(deps.platform, {
@@ -1521,12 +1691,12 @@ async function runInit(opts, deps) {
   }
   const merged = mergeSeekstoneConfig(existing, vaultPath);
   let backupPath;
-  await mkdir3(dirname3(configPath), { recursive: true });
+  await mkdir4(dirname4(configPath), { recursive: true });
   if (existingRaw !== null) {
     backupPath = `${configPath}.backup-${deps.timestamp}`;
     await copyFile(configPath, backupPath);
   }
-  await writeFile6(configPath, `${JSON.stringify(merged, null, 2)}
+  await writeFile7(configPath, `${JSON.stringify(merged, null, 2)}
 `, "utf8");
   out.push(
     `\u2713 Patched ${configPath}`,
@@ -1571,11 +1741,10 @@ function createLogger(opts = {}) {
   const env = opts.env ?? process.env;
   const stderr = opts.stderr ?? ((line) => void process.stderr.write(line));
   const now = opts.now ?? (() => /* @__PURE__ */ new Date());
-  const level = parseLevel(
-    env.SEEKSTONE_LOG_LEVEL,
-    (m) => stderr(`WARN  ${now().toISOString()} ${m}
-`)
-  );
+  const level = parseLevel(env.SEEKSTONE_LOG_LEVEL, (m) => {
+    stderr(`WARN  ${now().toISOString()} ${m}
+`);
+  });
   const threshold = ORDER.indexOf(level);
   const filePath = env.SEEKSTONE_LOG_FILE;
   const maxSize = parseSize(env.SEEKSTONE_LOG_MAX_SIZE);
@@ -1598,7 +1767,7 @@ function createLogger(opts = {}) {
       );
     }
   }
-  function writeFile7(record) {
+  function writeFile8(record) {
     if (!fileOk || filePath === void 0) return;
     const line = `${JSON.stringify(record)}
 `;
@@ -1620,20 +1789,41 @@ function createLogger(opts = {}) {
     const f = fields ?? {};
     stderr(`${lvl.toUpperCase().padEnd(5)} ${ts} ${msg}${fmtFields(f)}
 `);
-    writeFile7({ t: ts, level: lvl, msg, ...f });
+    writeFile8({ t: ts, level: lvl, msg, ...f });
   }
   return {
     level,
-    error: (m, f) => emit("error", m, f),
-    warn: (m, f) => emit("warn", m, f),
-    info: (m, f) => emit("info", m, f),
-    debug: (m, f) => emit("debug", m, f)
+    error: (m, f) => {
+      emit("error", m, f);
+    },
+    warn: (m, f) => {
+      emit("warn", m, f);
+    },
+    info: (m, f) => {
+      emit("info", m, f);
+    },
+    debug: (m, f) => {
+      emit("debug", m, f);
+    }
+  };
+}
+
+// src/process-guards.ts
+function installProcessGuards(log2) {
+  const onUnhandledRejection = (reason) => {
+    const error = reason instanceof Error ? reason.message : String(reason);
+    log2.error("unhandled promise rejection (server kept alive)", { error });
+  };
+  process.on("unhandledRejection", onUnhandledRejection);
+  return () => {
+    process.off("unhandledRejection", onUnhandledRejection);
   };
 }
 
 // src/watcher.ts
-import { readFile as readFile9 } from "fs/promises";
-import { join as join14, relative as relative2, sep as sep2 } from "path";
+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);
@@ -1667,10 +1857,15 @@ function addNoteBacklinks(ctx2, relPath, raw) {
 }
 function startWatcher(ctx2, log2, opts) {
   const usePolling = opts?.usePolling ?? process.env.SEEKSTONE_WATCH_POLL === "1";
-  const toRel = (abs) => relative2(ctx2.vaultRoot, abs).split(sep2).join("/");
+  let vaultRoot2 = ctx2.vaultRoot;
+  try {
+    vaultRoot2 = realpathSync(ctx2.vaultRoot);
+  } catch {
+  }
+  const toRel = (abs) => relative2(vaultRoot2, abs).split(sep2).join("/");
   async function upsert(relPath, op) {
     try {
-      const raw = await readFile9(join14(ctx2.vaultRoot, relPath), "utf8");
+      const raw = await readFile10(join15(vaultRoot2, relPath), "utf8");
       removeNoteBacklinks(ctx2, relPath);
       upsertDoc(ctx2, buildDoc(relPath, raw));
       addNoteBacklinks(ctx2, relPath, raw);
@@ -1688,9 +1883,10 @@ function startWatcher(ctx2, log2, opts) {
   }
   const onUpsert = (op) => (abs) => {
     const relPath = toRel(abs);
+    opts?.onRawEvent?.(op, abs, relPath);
     if (relPath.endsWith(".md")) void upsert(relPath, op);
   };
-  const watcher2 = chokidar.watch(ctx2.vaultRoot, {
+  const watcher2 = chokidar.watch(vaultRoot2, {
     // The startup index build already covers existing files.
     ignoreInitial: true,
     usePolling,
@@ -1699,17 +1895,20 @@ function startWatcher(ctx2, log2, opts) {
     // Skip dot-dirs (.obsidian, .git, .trash, …) regardless of where the vault
     // lives — matched on the path relative to the vault root.
     ignored: (p) => {
-      const rel = relative2(ctx2.vaultRoot, p);
+      const rel = relative2(vaultRoot2, p);
       if (!rel || rel === ".") return false;
-      return rel.split(sep2).filter(Boolean).some((seg) => seg.startsWith("."));
+      return rel.split(sep2).filter(Boolean).some((seg) => seg.startsWith(".") && seg !== "..");
     }
   });
   watcher2.on("add", onUpsert("add")).on("change", onUpsert("change")).on("unlink", (abs) => {
     const relPath = toRel(abs);
+    opts?.onRawEvent?.("unlink", abs, relPath);
     if (relPath.endsWith(".md")) remove(relPath);
   });
   const ready = new Promise((resolve) => {
-    watcher2.once("ready", () => resolve());
+    watcher2.once("ready", () => {
+      resolve();
+    });
   });
   return {
     stop: () => void watcher2.close(),
@@ -1718,7 +1917,7 @@ function startWatcher(ctx2, log2, opts) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.5.0" : "0.0.0-dev";
+var VERSION = true ? "0.6.1" : "0.0.0-dev";
 var intent = parseCliIntent(process.argv.slice(2));
 if (intent === "version") {
   process.stdout.write(`${VERSION}
@@ -1741,6 +1940,7 @@ if (intent === "init") {
   process.exit(result.exitCode);
 }
 var log = createLogger();
+installProcessGuards(log);
 var vaultRoot = process.env.SEEKSTONE_VAULT;
 if (!vaultRoot) {
   log.error("SEEKSTONE_VAULT env var is required");
@@ -2031,6 +2231,56 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         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"]
+      }
     }
   ]
 }));
@@ -2040,7 +2290,7 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
 });
 var transport = new StdioServerTransport();
 await server.connect(transport);
-log.info("ready", { tools: 14, transport: "stdio" });
+log.info("ready", { tools: 16, transport: "stdio" });
 process.stderr.write(
   `seekstone: add to Claude Desktop:
 ${JSON.stringify(