seekstone 0.20.3 → 0.22.0

package/dist/index.js

@@ -116,7 +116,7 @@ __export(fetch_model_exports, {
 });
 import { createHash as createHash4 } from "crypto";
 import { existsSync as existsSync2 } from "fs";
-import { mkdir as mkdir10, readFile as readFile20, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir10, readFile as readFile21, writeFile as writeFile5 } from "fs/promises";
 import { join as join13 } from "path";
 function selectManifest(argv, env) {
   let requested;
@@ -154,7 +154,7 @@ async function runFetchModel(deps) {
     let skipped = 0;
     for (const file of manifest.files) {
       const dest = join13(destDir, file.name);
-      if (existsSync2(dest) && sha2562(await readFile20(dest)) === file.sha256) {
+      if (existsSync2(dest) && sha2562(await readFile21(dest)) === file.sha256) {
         skipped++;
         continue;
       }
@@ -533,6 +533,57 @@ function parseFrontmatter(text) {
   };
 }
 
+// ../core/src/tasks.ts
+var TASK_RE = /^([ \t]*)([-*+]) \[(.)\](?: (.*))?$/;
+var HEADING_RE = /^(#{1,6})\s+(.+)/;
+var FENCE_RE = /^[ \t]*(`{3,}|~{3,})[ \t]*([^`]*)$/;
+function extractTasks(raw) {
+  const fm = parseFrontmatter(raw);
+  const tasks = [];
+  let charOffset = 0;
+  let heading;
+  let fence = null;
+  for (const [i, rawLine] of raw.split("\n").entries()) {
+    const lineCharOffset = charOffset;
+    charOffset += rawLine.length + 1;
+    if (lineCharOffset < fm.bodyStart) continue;
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    if (fence) {
+      const close = FENCE_RE.exec(line);
+      const closeMarker = close?.[1] ?? "";
+      const closeTrailer = close?.[2] ?? "";
+      if (closeMarker.startsWith(fence.char) && closeMarker.length >= fence.len && closeTrailer === "") {
+        fence = null;
+      }
+      continue;
+    }
+    const open2 = /^[ \t]*(`{3,}|~{3,})/.exec(line);
+    if (open2) {
+      const marker = open2[1] ?? "";
+      fence = { char: marker[0] ?? "`", len: marker.length };
+      continue;
+    }
+    const hm = HEADING_RE.exec(line);
+    if (hm) {
+      heading = (hm[2] ?? "").trim();
+      continue;
+    }
+    const tm = TASK_RE.exec(line);
+    if (tm) {
+      const indent = tm[1] ?? "";
+      tasks.push({
+        line: i + 1,
+        state: tm[3] ?? "",
+        text: (tm[4] ?? "").trim(),
+        ...heading !== void 0 ? { heading } : {},
+        col: indent.length + 3
+        // bullet + space + '[' precede the marker
+      });
+    }
+  }
+  return tasks;
+}
+
 // src/tools/append_note.ts
 import { z } from "zod";
 
@@ -896,6 +947,7 @@ async function appendNote(ctx2, input) {
   if (cached) {
     cached.body = newBody;
     cached.raw = newContent;
+    cached.tasks = extractTasks(newContent);
   }
   return {
     path: input.path,
@@ -983,6 +1035,13 @@ function frontmatterTags(fm) {
   }
   return [];
 }
+function frontmatterAliases(fm) {
+  if (!fm) return [];
+  const raw = fm.aliases ?? fm.alias;
+  if (raw == null) return [];
+  const values = Array.isArray(raw) ? raw : typeof raw === "string" ? raw.split(",") : [];
+  return values.filter((a) => typeof a === "string").map((a) => a.trim()).filter(Boolean);
+}
 
 // src/tools/context_pack.ts
 import { z as z3 } from "zod";
@@ -1015,15 +1074,26 @@ function truncate(s, max) {
 function buildResolveMaps(notes2) {
   const byBasename = /* @__PURE__ */ new Map();
   const byPathNoExt = /* @__PURE__ */ new Map();
-  for (const path2 of notes2.keys()) {
+  const byAlias = /* @__PURE__ */ new Map();
+  for (const [path2, note] of notes2) {
     const pathNoExt = path2.replace(/\.md$/i, "").toLowerCase();
     const base = pathNoExt.split("/").pop() ?? pathNoExt;
-    const prevBase = byBasename.get(base);
-    if (prevBase === void 0 || path2 < prevBase) byBasename.set(base, path2);
-    const prevPath = byPathNoExt.get(pathNoExt);
-    if (prevPath === void 0 || path2 < prevPath) byPathNoExt.set(pathNoExt, path2);
+    push(byBasename, base, path2);
+    push(byPathNoExt, pathNoExt, path2);
+    const fm = note?.fm ?? null;
+    for (const alias of frontmatterAliases(fm)) {
+      push(byAlias, alias.toLowerCase(), { path: path2, alias });
+    }
   }
-  return { byBasename, byPathNoExt };
+  for (const list of byBasename.values()) list.sort();
+  for (const list of byPathNoExt.values()) list.sort();
+  for (const list of byAlias.values()) list.sort((a, b) => a.path < b.path ? -1 : 1);
+  return { byBasename, byPathNoExt, byAlias };
+}
+function push(map, key, value) {
+  const list = map.get(key);
+  if (list) list.push(value);
+  else map.set(key, [value]);
 }
 function resolveLink(target, notes2, maps) {
   if (notes2.has(target)) return target;
@@ -1032,7 +1102,27 @@ function resolveLink(target, notes2, maps) {
   const m = maps ?? buildResolveMaps(notes2);
   const targetLower = target.toLowerCase();
   const targetBase = targetLower.split("/").pop() ?? targetLower;
-  return m.byBasename.get(targetBase) ?? m.byPathNoExt.get(targetLower);
+  return m.byBasename.get(targetBase)?.[0] ?? m.byPathNoExt.get(targetLower)?.[0] ?? m.byAlias.get(targetLower)?.[0]?.path;
+}
+function resolveCandidates(target, notes2, maps) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (candidate) => {
+    if (seen.has(candidate.path)) return;
+    seen.add(candidate.path);
+    out.push(candidate);
+  };
+  if (notes2.has(target)) add({ path: target, via: "path" });
+  const withMd = `${target}.md`;
+  if (notes2.has(withMd)) add({ path: withMd, via: "path" });
+  const m = maps ?? buildResolveMaps(notes2);
+  const targetLower = target.toLowerCase();
+  const targetBase = targetLower.split("/").pop() ?? targetLower;
+  for (const path2 of m.byBasename.get(targetBase) ?? []) add({ path: path2, via: "basename" });
+  for (const path2 of m.byPathNoExt.get(targetLower) ?? []) add({ path: path2, via: "relpath" });
+  for (const { path: path2, alias } of m.byAlias.get(targetLower) ?? [])
+    add({ path: path2, via: "alias", alias });
+  return out;
 }
 
 // src/tools/search.ts
@@ -1478,6 +1568,7 @@ function buildDoc(relPath, raw) {
     fmKeys: fm.keys.join(" "),
     fm: fm.data,
     raw,
+    tasks: extractTasks(raw),
     sizeBytes: Buffer.byteLength(raw, "utf8"),
     mtimeMs: Date.now()
   };
@@ -1772,11 +1863,77 @@ function listTags(ctx2, input) {
   return { tags, total: tags.length };
 }
 
-// src/tools/list_writes.ts
+// src/tools/list_tasks.ts
 import { z as z10 } from "zod";
-var ListWritesInput = z10.object({
-  limit: z10.number().int().min(1).max(200).default(20).describe("Max entries to return, newest first (1\u2013200, default 20)."),
-  path: z10.string().optional().describe("Only entries that touched this vault-relative path.")
+var ISO_DATE = z10.string().refine((s) => !Number.isNaN(Date.parse(s)), { message: "not a parseable date" });
+var ListTasksInput = z10.object({
+  path: z10.string().optional().describe("Vault-relative path to a single note. Omit to search the whole vault."),
+  folder: z10.string().optional().describe("Restrict to notes under this vault-relative folder prefix."),
+  tag: z10.string().optional().describe(
+    'Restrict to notes with this tag. # optional, case-insensitive, and nested child tags match (e.g. "project" matches #project/alpha).'
+  ),
+  state: z10.union([z10.enum(["open", "done", "any"]), z10.string().length(1)]).default("open").describe(
+    'Which tasks to return: "open" (`- [ ]`, the default), "done" (`- [x]` or `- [X]`), "any", or a single custom marker character such as "/" or "-".'
+  ),
+  modifiedAfter: ISO_DATE.optional().describe(
+    "Only tasks in notes modified at or after this ISO 8601 date/time."
+  ),
+  limit: z10.number().int().min(1).max(500).default(100).describe("Maximum number of tasks.")
+});
+function stateMatches(marker, wanted) {
+  if (wanted === "any") return true;
+  if (wanted === "open") return marker === " ";
+  if (wanted === "done") return marker === "x" || marker === "X";
+  return marker === wanted;
+}
+function listTasks(ctx2, input) {
+  const tag = input.tag === void 0 ? void 0 : normalizeTag(input.tag);
+  const after = input.modifiedAfter ? Date.parse(input.modifiedAfter) : void 0;
+  let sources;
+  if (input.path !== void 0) {
+    const note = ctx2.notes.get(input.path);
+    if (!note) {
+      throw new Error(
+        JSON.stringify({
+          error: "note_not_found",
+          path: input.path,
+          hint: "No indexed note at this path. Use resolve_note or list_notes to find the right path."
+        })
+      );
+    }
+    sources = [[input.path, note]];
+  } else {
+    sources = ctx2.notes;
+  }
+  const rows = [];
+  for (const [path2, note] of sources) {
+    if (input.folder && !path2.startsWith(input.folder)) continue;
+    if (tag && !noteHasTag(note.tags, tag)) continue;
+    if (after !== void 0 && note.mtimeMs < after) continue;
+    if (note.tasks.length === 0) continue;
+    for (const task of note.tasks) {
+      if (!stateMatches(task.state, input.state)) continue;
+      rows.push({
+        path: path2,
+        line: task.line,
+        state: task.state,
+        text: task.text,
+        ...task.heading !== void 0 ? { heading: task.heading } : {}
+      });
+    }
+  }
+  if (rows.length === 0 && input.tag) assertTagExists(ctx2.notes, input.tag);
+  rows.sort((a, b) => a.path.localeCompare(b.path) || a.line - b.line);
+  const total = rows.length;
+  const tasks = rows.slice(0, input.limit);
+  return { tasks, total, truncated: total > input.limit };
+}
+
+// src/tools/list_writes.ts
+import { z as z11 } from "zod";
+var ListWritesInput = z11.object({
+  limit: z11.number().int().min(1).max(200).default(20).describe("Max entries to return, newest first (1\u2013200, default 20)."),
+  path: z11.string().optional().describe("Only entries that touched this vault-relative path.")
 });
 function listWrites(ctx2, rawInput) {
   const input = ListWritesInput.parse(rawInput);
@@ -1789,17 +1946,17 @@ function listWrites(ctx2, rawInput) {
 // src/tools/move_note.ts
 import { mkdir as mkdir4, readFile as readFile5, rename as rename4 } from "fs/promises";
 import { dirname as dirname2, join as join3 } from "path";
-import { z as z11 } from "zod";
+import { z as z12 } 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*(```|~~~)/;
+var FENCE_RE2 = /^\s*(```|~~~)/;
 function mapUnfencedLines(raw, fn) {
   let inFence = false;
   return raw.split("\n").map((line) => {
-    if (FENCE_RE.test(line)) {
+    if (FENCE_RE2.test(line)) {
       inFence = !inFence;
       return line;
     }
@@ -1838,8 +1995,9 @@ function rewriteNoteLinks(raw, sourcePath, oldPath, newPath, preNotes, postNotes
   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;
+    if (resolveCandidates(t, postNotes)[0]?.path === newPath) return full;
+    const pre = resolveCandidates(t, preNotes)[0];
+    if (pre?.path !== oldPath || pre.via === "alias") return full;
     count++;
     const next = wikiTargetFor(newPath, postNotes);
     return `${bang}[[${next}${frag ?? ""}${alias ?? ""}]]`;
@@ -1884,14 +2042,14 @@ function hasMarkdownLinkTo(raw, sourcePath, targetPath) {
 }
 
 // src/tools/move_note.ts
-var MoveNoteInput = z11.object({
-  from: z11.string().describe("Vault-relative path of the note to move."),
-  to: z11.string().describe("Vault-relative destination path."),
-  overwrite: z11.boolean().default(false).describe("Overwrite the destination if it exists. Defaults to false."),
-  rewriteLinks: z11.boolean().default(true).describe(
+var MoveNoteInput = z12.object({
+  from: z12.string().describe("Vault-relative path of the note to move."),
+  to: z12.string().describe("Vault-relative destination path."),
+  overwrite: z12.boolean().default(false).describe("Overwrite the destination if it exists. Defaults to false."),
+  rewriteLinks: z12.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."
   ),
-  prevHash: z11.string().optional().describe(
+  prevHash: z12.string().optional().describe(
     "Optional compare-and-swap guard on the source note: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
   )
 });
@@ -1997,7 +2155,7 @@ async function moveNote(ctx2, rawInput) {
 import { readFile as readFile6 } from "fs/promises";
 
 // ../core/src/outline.ts
-var HEADING_RE = /^(#{1,6})\s+(.+)/;
+var HEADING_RE2 = /^(#{1,6})\s+(.+)/;
 var BLOCK_REF_RE = /\^([a-zA-Z0-9-]+)$/;
 function buildOutline(raw, options = {}) {
   const { includeBlocks = true, includeSizes = false } = options;
@@ -2010,7 +2168,7 @@ function buildOutline(raw, options = {}) {
     const lineCharOffset = charOffset;
     const lineNum = i + 1;
     if (charOffset >= fm.bodyStart) {
-      const hm = HEADING_RE.exec(line);
+      const hm = HEADING_RE2.exec(line);
       if (hm) {
         headings.push({
           text: (hm[2] ?? "").trim(),
@@ -2044,11 +2202,11 @@ function buildOutline(raw, options = {}) {
 }
 
 // src/tools/outline_note.ts
-import { z as z12 } from "zod";
-var OutlineNoteInput = z12.object({
-  path: z12.string().describe("Vault-relative path to the note."),
-  includeBlocks: z12.boolean().default(true).describe("Include block-reference anchors (^id). Default true."),
-  includeSizes: z12.boolean().default(false).describe("Include per-section character length in each heading entry. Default false.")
+import { z as z13 } from "zod";
+var OutlineNoteInput = z13.object({
+  path: z13.string().describe("Vault-relative path to the note."),
+  includeBlocks: z13.boolean().default(true).describe("Include block-reference anchors (^id). Default true."),
+  includeSizes: z13.boolean().default(false).describe("Include per-section character length in each heading entry. Default false.")
 });
 async function outlineNote(ctx2, input) {
   const absPath = resolveVaultPath(ctx2.vaultRoot, input.path);
@@ -2062,13 +2220,13 @@ async function outlineNote(ctx2, input) {
 // src/tools/patch_frontmatter.ts
 import { readFile as readFile7 } from "fs/promises";
 import { parseDocument as parseDocument2 } from "yaml";
-import { z as z13 } from "zod";
-var PatchFrontmatterInput = z13.object({
-  path: z13.string().describe("Vault-relative path to the note."),
-  patch: z13.record(z13.string(), z13.unknown()).describe(
+import { z as z14 } from "zod";
+var PatchFrontmatterInput = z14.object({
+  path: z14.string().describe("Vault-relative path to the note."),
+  patch: z14.record(z14.string(), z14.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: z13.string().optional().describe(
+  prevHash: z14.string().optional().describe(
     "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
   )
 });
@@ -2125,6 +2283,7 @@ ${original}`;
     const updated = parseFrontmatter(newContent);
     cached.raw = newContent;
     cached.fmKeys = updated.keys.join(" ");
+    cached.tasks = extractTasks(newContent);
   }
   return {
     path: input.path,
@@ -2137,21 +2296,21 @@ ${original}`;
 
 // src/tools/patch_note.ts
 import { readFile as readFile8 } from "fs/promises";
-import { z as z14 } from "zod";
-var PatchNoteInput = z14.object({
-  path: z14.string().describe("Vault-relative path to the note."),
-  target: z14.union([
-    z14.object({ heading: z14.string().describe("Heading text (without # markers).") }),
-    z14.object({ block: z14.string().describe("Block reference ID (without the ^ prefix).") })
+import { z as z15 } from "zod";
+var PatchNoteInput = z15.object({
+  path: z15.string().describe("Vault-relative path to the note."),
+  target: z15.union([
+    z15.object({ heading: z15.string().describe("Heading text (without # markers).") }),
+    z15.object({ block: z15.string().describe("Block reference ID (without the ^ prefix).") })
   ]).describe("Target section. Provide exactly one of heading or block."),
-  operation: z14.enum(["append", "prepend", "replace"]).describe(
+  operation: z15.enum(["append", "prepend", "replace"]).describe(
     "append: insert after section content. prepend: insert after heading line. replace: swap section content."
   ),
-  content: z14.string().min(1).describe("Content to insert or replace with."),
-  createIfMissing: z14.boolean().default(false).describe(
+  content: z15.string().min(1).describe("Content to insert or replace with."),
+  createIfMissing: z15.boolean().default(false).describe(
     "If the heading target is not found, append a new heading (level 2) + content. Only valid for heading targets."
   ),
-  prevHash: z14.string().optional().describe(
+  prevHash: z15.string().optional().describe(
     "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
   )
 });
@@ -2279,6 +2438,7 @@ function updateCache(ctx2, path2, newContent, bodyStart) {
   if (cached) {
     cached.body = newContent.slice(bodyStart);
     cached.raw = newContent;
+    cached.tasks = extractTasks(newContent);
     cached.sizeBytes = Buffer.byteLength(newContent, "utf8");
   }
 }
@@ -2286,8 +2446,8 @@ function updateCache(ctx2, path2, newContent, bodyStart) {
 // src/tools/periodic_note.ts
 import { access as access3, mkdir as mkdir5, readFile as readFile9 } from "fs/promises";
 import { dirname as dirname3, join as join4 } from "path";
-import { z as z15 } from "zod";
-var PERIOD = z15.enum(["daily", "weekly", "monthly", "quarterly", "yearly"]);
+import { z as z16 } from "zod";
+var PERIOD = z16.enum(["daily", "weekly", "monthly", "quarterly", "yearly"]);
 var DEFAULTS = {
   daily: { folder: "", format: "YYYY-MM-DD", template: "" },
   weekly: { folder: "", format: "gggg-[W]ww", template: "" },
@@ -2352,12 +2512,12 @@ function resolveNotePath(cfg, date) {
   const filename = `${formatMomentDate(date, cfg.format)}.md`;
   return cfg.folder ? `${cfg.folder}/${filename}` : filename;
 }
-var GetPeriodicNoteInput = z15.object({
+var GetPeriodicNoteInput = z16.object({
   period: PERIOD.default("daily").describe(
     "Period type: daily (default), weekly, monthly, quarterly, or yearly."
   ),
-  date: z15.string().optional().describe("ISO date string (YYYY-MM-DD). Defaults to today when omitted."),
-  createIfMissing: z15.boolean().default(false).describe(
+  date: z16.string().optional().describe("ISO date string (YYYY-MM-DD). Defaults to today when omitted."),
+  createIfMissing: z16.boolean().default(false).describe(
     "Create the note from the configured template if it does not exist. Default false \u2014 reports missing without creating."
   )
 });
@@ -2393,12 +2553,12 @@ async function getPeriodicNote(ctx2, rawInput) {
   upsertDoc(ctx2, buildDoc(path2, body));
   return { path: path2, existed: false, created: true, contentHash: contentHash(body) };
 }
-var AppendPeriodicNoteInput = z15.object({
+var AppendPeriodicNoteInput = z16.object({
   period: PERIOD.default("daily").describe("Period type. Default: daily."),
-  date: z15.string().optional().describe("ISO date string (YYYY-MM-DD). Defaults to today."),
-  content: z15.string().min(1).describe("Text to append to the note body. Separated from existing content by a blank line."),
-  createIfMissing: z15.boolean().default(true).describe("Create the note if it does not exist before appending. Default true."),
-  prevHash: z15.string().optional().describe(
+  date: z16.string().optional().describe("ISO date string (YYYY-MM-DD). Defaults to today."),
+  content: z16.string().min(1).describe("Text to append to the note body. Separated from existing content by a blank line."),
+  createIfMissing: z16.boolean().default(true).describe("Create the note if it does not exist before appending. Default true."),
+  prevHash: z16.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."
   )
 });
@@ -2450,6 +2610,7 @@ async function appendPeriodicNote(ctx2, rawInput) {
   if (cached) {
     cached.body = newBody;
     cached.raw = newRaw;
+    cached.tasks = extractTasks(newRaw);
   }
   return {
     path: path2,
@@ -2459,38 +2620,38 @@ async function appendPeriodicNote(ctx2, rawInput) {
 }
 
 // src/tools/query_notes.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var OPS_WITHOUT_VALUE = /* @__PURE__ */ new Set(["exists", "missing"]);
-var Predicate = z16.object({
-  key: z16.string().min(1).describe("Frontmatter key to test (top-level)."),
-  op: z16.enum(["eq", "ne", "contains", "exists", "missing", "gt", "gte", "lt", "lte"]).describe(
+var Predicate = z17.object({
+  key: z17.string().min(1).describe("Frontmatter key to test (top-level)."),
+  op: z17.enum(["eq", "ne", "contains", "exists", "missing", "gt", "gte", "lt", "lte"]).describe(
     "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: z16.union([z16.string(), z16.number(), z16.boolean()]).optional().describe("Comparison value. Required for every op except exists/missing.")
+  value: z17.union([z17.string(), z17.number(), z17.boolean()]).optional().describe("Comparison value. Required for every op except exists/missing.")
 }).refine((p) => OPS_WITHOUT_VALUE.has(p.op) || p.value !== void 0, {
   message: "value is required for this op"
 });
-var ISO_DATE = z16.string().refine((s) => !Number.isNaN(Date.parse(s)), { message: "not a parseable date" });
-var QueryNotesInput = z16.object({
-  where: z16.array(Predicate).max(20).default([]).describe("Frontmatter predicates. All must match (AND)."),
-  folder: z16.string().optional().describe("Restrict to notes under this vault-relative folder prefix."),
-  tag: z16.string().optional().describe(
+var ISO_DATE2 = z17.string().refine((s) => !Number.isNaN(Date.parse(s)), { message: "not a parseable date" });
+var QueryNotesInput = z17.object({
+  where: z17.array(Predicate).max(20).default([]).describe("Frontmatter predicates. All must match (AND)."),
+  folder: z17.string().optional().describe("Restrict to notes under this vault-relative folder prefix."),
+  tag: z17.string().optional().describe(
     'Restrict to notes with this tag. # optional, case-insensitive, and nested child tags match (e.g. "project" matches #project/alpha).'
   ),
-  modifiedAfter: ISO_DATE.optional().describe(
+  modifiedAfter: ISO_DATE2.optional().describe(
     "Only notes modified at or after this ISO 8601 date/time."
   ),
-  modifiedBefore: ISO_DATE.optional().describe(
+  modifiedBefore: ISO_DATE2.optional().describe(
     "Only notes modified before this ISO 8601 date/time."
   ),
-  minSizeBytes: z16.number().int().min(0).optional().describe("Only notes at least this many bytes."),
-  maxSizeBytes: z16.number().int().min(0).optional().describe("Only notes at most this many bytes."),
-  select: z16.array(z16.string()).max(20).default([]).describe(
+  minSizeBytes: z17.number().int().min(0).optional().describe("Only notes at least this many bytes."),
+  maxSizeBytes: z17.number().int().min(0).optional().describe("Only notes at most this many bytes."),
+  select: z17.array(z17.string()).max(20).default([]).describe(
     'Extra fields to return per hit: frontmatter keys, or the specials "mtime", "size", "tags". Default returns only path + title, keeping the payload minimal.'
   ),
-  sort: z16.enum(["path", "title", "mtime", "size"]).default("path").describe("Sort field."),
-  order: z16.enum(["asc", "desc"]).default("asc").describe("Sort order."),
-  limit: z16.number().int().min(1).max(500).default(100).describe("Maximum number of results.")
+  sort: z17.enum(["path", "title", "mtime", "size"]).default("path").describe("Sort field."),
+  order: z17.enum(["asc", "desc"]).default("asc").describe("Sort order."),
+  limit: z17.number().int().min(1).max(500).default(100).describe("Maximum number of results.")
 });
 function scalarEq(a, b) {
   if (a === b) return true;
@@ -2590,16 +2751,16 @@ function queryNotes(ctx2, input) {
 
 // src/tools/read_note.ts
 import { readFile as readFile10 } from "fs/promises";
-import { z as z17 } from "zod";
-var ReadNoteInput = z17.object({
-  path: z17.string().describe('Vault-relative path to the note, e.g. "Daily Notes/2026-05-29.md".'),
-  section: z17.string().optional().describe("Return only this heading section (heading text, # prefix optional)."),
-  block: z17.string().optional().describe("Return only the block anchored by this id (^ prefix optional)."),
-  lines: z17.object({
-    from: z17.number().int().min(1).describe("First line (1-indexed, inclusive)."),
-    to: z17.number().int().min(1).optional().describe("Last line (1-indexed, inclusive). Defaults to end of file.")
+import { z as z18 } from "zod";
+var ReadNoteInput = z18.object({
+  path: z18.string().describe('Vault-relative path to the note, e.g. "Daily Notes/2026-05-29.md".'),
+  section: z18.string().optional().describe("Return only this heading section (heading text, # prefix optional)."),
+  block: z18.string().optional().describe("Return only the block anchored by this id (^ prefix optional)."),
+  lines: z18.object({
+    from: z18.number().int().min(1).describe("First line (1-indexed, inclusive)."),
+    to: z18.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: z17.boolean().optional().describe(
+  includeFrontmatter: z18.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, {
@@ -2694,19 +2855,77 @@ async function readNote(ctx2, input) {
   };
 }
 
+// src/tools/read_notes.ts
+import { z as z19 } from "zod";
+var DEFAULT_BUDGET_BYTES = 16384;
+var ReadNotesInput = z19.object({
+  items: z19.array(ReadNoteInput).min(1).max(20).describe(
+    "Notes to read, 1\u201320, each with the same options as read_note (path plus at most one of section, block, or lines)."
+  ),
+  budgetBytes: z19.number().int().min(256).max(65536).default(DEFAULT_BUDGET_BYTES).describe(
+    "Cap on the total note text returned across all items (UTF-8 bytes). When exceeded, each item is truncated to a fair share."
+  )
+});
+async function readNotes(ctx2, input) {
+  const budget = input.budgetBytes;
+  const results = await Promise.all(
+    input.items.map((item) => readNote(ctx2, item).catch((err) => toItemError(item.path, err)))
+  );
+  const entries = results.filter((r) => !("error" in r)).map((r) => ({ r, size: r.bytesReturned, alloc: 0 }));
+  allocate(entries, budget);
+  const cut = new Map(
+    entries.map((e) => [e.r, truncateItem(e.r, e.alloc)])
+  );
+  const notes2 = results.map((r) => cut.get(r) ?? r);
+  const bytesUsed = [...cut.values()].reduce((sum, r) => sum + r.bytesReturned, 0);
+  return { notes: notes2, budgetBytes: budget, bytesUsed };
+}
+function toItemError(path2, err) {
+  const { message, code } = err;
+  if (message.startsWith("{")) return { path: path2, ...JSON.parse(message) };
+  if (message.startsWith("Path outside vault")) return { path: path2, error: "outside_vault" };
+  if (code === "ENOENT") return { path: path2, error: "not_found" };
+  return { path: path2, error: "read_failed", message };
+}
+function allocate(entries, budget) {
+  let pending = entries.filter((e) => e.size > 0);
+  let remaining = budget;
+  for (const e of entries) e.alloc = e.size;
+  if (entries.reduce((sum, e) => sum + e.size, 0) <= budget) return;
+  while (pending.length > 0) {
+    const share = Math.floor(remaining / pending.length);
+    const fits = pending.filter((e) => e.size <= share);
+    if (fits.length === 0) {
+      const extra = remaining - share * pending.length;
+      for (const [k, e] of pending.entries()) e.alloc = share + (k < extra ? 1 : 0);
+      return;
+    }
+    for (const e of fits) remaining -= e.size;
+    pending = pending.filter((e) => e.size > share);
+  }
+}
+function truncateItem(r, maxBytes) {
+  if (r.bytesReturned <= maxBytes) return r;
+  const buf = Buffer.from(r.content, "utf8");
+  let end = maxBytes;
+  while (end > 0 && (buf.readUInt8(end) & 192) === 128) end--;
+  const content = buf.toString("utf8", 0, end);
+  return { ...r, content, bytesReturned: end, truncated: true };
+}
+
 // src/tools/rename_heading.ts
 import { readFile as readFile11 } from "fs/promises";
 import { join as join5 } from "path";
-import { z as z18 } from "zod";
-var RenameHeadingInput = z18.object({
-  path: z18.string().describe("Vault-relative path of the note containing the heading."),
-  oldHeading: z18.string().min(1).describe(
+import { z as z20 } from "zod";
+var RenameHeadingInput = z20.object({
+  path: z20.string().describe("Vault-relative path of the note containing the heading."),
+  oldHeading: z20.string().min(1).describe(
     "Current heading text, without # markers. Matched case-insensitively; if the note has duplicate headings the first one wins, mirroring Obsidian link resolution."
   ),
-  newHeading: z18.string().min(1).refine((s) => !/[\n[\]|#]/.test(s), {
+  newHeading: z20.string().min(1).refine((s) => !/[\n[\]|#]/.test(s), {
     message: 'newHeading must not contain newlines, "[", "]", "|", or "#" \u2014 those break [[note#heading]] link syntax.'
   }).describe("New heading text, without # markers."),
-  prevHash: z18.string().optional().describe(
+  prevHash: z20.string().optional().describe(
     "Optional compare-and-swap guard: the contentHash from a prior read of this note. Fails with hash_conflict if the note changed since."
   )
 });
@@ -2829,17 +3048,17 @@ async function renameHeading(ctx2, rawInput) {
 
 // src/tools/replace_in_note.ts
 import { readFile as readFile12 } from "fs/promises";
-import { z as z19 } from "zod";
-var ReplaceInNoteInput = z19.object({
-  path: z19.string().describe("Vault-relative path to the note."),
-  find: z19.string().min(1).max(1e3).describe("Text or pattern to find (max 1000 chars; bounds regex-mode pattern size)."),
-  replace: z19.string().describe("Replacement text. Supports $1, $2, \u2026 backreferences in regex mode."),
-  regex: z19.boolean().default(false).describe("Treat find as a regular expression."),
-  caseSensitive: z19.boolean().default(false).describe("Case-sensitive matching."),
-  wholeWord: z19.boolean().default(false).describe("Match whole words only (\\b word-boundary)."),
-  limit: z19.number().int().min(1).optional().describe("Maximum number of replacements. Omit to replace all."),
-  dryRun: z19.boolean().default(false).describe("If true, report matches without writing anything."),
-  prevHash: z19.string().optional().describe(
+import { z as z21 } from "zod";
+var ReplaceInNoteInput = z21.object({
+  path: z21.string().describe("Vault-relative path to the note."),
+  find: z21.string().min(1).max(1e3).describe("Text or pattern to find (max 1000 chars; bounds regex-mode pattern size)."),
+  replace: z21.string().describe("Replacement text. Supports $1, $2, \u2026 backreferences in regex mode."),
+  regex: z21.boolean().default(false).describe("Treat find as a regular expression."),
+  caseSensitive: z21.boolean().default(false).describe("Case-sensitive matching."),
+  wholeWord: z21.boolean().default(false).describe("Match whole words only (\\b word-boundary)."),
+  limit: z21.number().int().min(1).optional().describe("Maximum number of replacements. Omit to replace all."),
+  dryRun: z21.boolean().default(false).describe("If true, report matches without writing anything."),
+  prevHash: z21.string().optional().describe(
     "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
   )
 });
@@ -2909,6 +3128,7 @@ async function replaceInNote(ctx2, input) {
   if (cached) {
     cached.body = newBody;
     cached.raw = newContent;
+    cached.tasks = extractTasks(newContent);
     cached.sizeBytes = Buffer.byteLength(newContent, "utf8");
   }
   return {
@@ -2921,15 +3141,56 @@ async function replaceInNote(ctx2, input) {
   };
 }
 
+// src/tools/resolve_note.ts
+import { z as z22 } from "zod";
+var ResolveNoteInput = z22.object({
+  reference: z22.string().min(1).describe(
+    'Reference to resolve: a vault-relative path ("Projects/Core.md"), a path without extension, a bare note name ("Core"), or a frontmatter alias.'
+  )
+});
+var MAX_SUGGESTIONS2 = 3;
+function suggestReferences(ctx2, reference) {
+  const wanted = reference.toLowerCase();
+  const counts = /* @__PURE__ */ new Map();
+  for (const [path2, note] of ctx2.notes) {
+    const base = path2.replace(/\.md$/i, "").split("/").pop();
+    const names = base ? [base, ...frontmatterAliases(note.fm)] : frontmatterAliases(note.fm);
+    for (const name of new Set(names)) {
+      counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+  }
+  const budget = Math.max(2, Math.ceil(wanted.length / 3));
+  const scored = [];
+  for (const [name, count] of counts) {
+    const dist = editDistance(wanted, name.toLowerCase());
+    if (dist <= budget) scored.push({ name, dist, count });
+  }
+  scored.sort((a, b) => a.dist - b.dist || b.count - a.count || a.name.localeCompare(b.name));
+  return scored.slice(0, MAX_SUGGESTIONS2).map((s) => s.name);
+}
+function resolveNote(ctx2, input) {
+  const matches2 = resolveCandidates(input.reference, ctx2.notes);
+  const result = {
+    reference: input.reference,
+    matches: matches2,
+    ambiguous: matches2.length > 1
+  };
+  if (matches2.length === 0) {
+    const didYouMean = suggestReferences(ctx2, input.reference);
+    if (didYouMean.length > 0) result.didYouMean = didYouMean;
+  }
+  return result;
+}
+
 // src/tools/undo_write.ts
 import { mkdir as mkdir6, readFile as readFile13, rm as rm3 } from "fs/promises";
 import { dirname as dirname4 } from "path";
-import { z as z20 } from "zod";
-var UndoWriteInput = z20.object({
-  seq: z20.number().int().min(1).optional().describe(
+import { z as z23 } from "zod";
+var UndoWriteInput = z23.object({
+  seq: z23.number().int().min(1).optional().describe(
     "Journal entry to revert (from list_writes). Defaults to the most recent undoable write."
   ),
-  force: z20.boolean().default(false).describe(
+  force: z23.boolean().default(false).describe(
     "Restore even if a file changed after the journaled write. The clobbered state is journaled first, so nothing is lost. Defaults to false \u2014 conflicts are refused."
   )
 });
@@ -3038,6 +3299,104 @@ async function postBytes(journal, hash) {
   }
 }
 
+// src/tools/update_task.ts
+import { readFile as readFile14 } from "fs/promises";
+import { z as z24 } from "zod";
+var UpdateTaskInput = z24.object({
+  path: z24.string().describe("Vault-relative path to the note."),
+  line: z24.number().int().min(1).describe("1-based line number of the task, as returned by list_tasks."),
+  expectText: z24.string().optional().describe(
+    "Optional guard: the task text list_tasks returned. Fails with task_text_mismatch if the line\u2019s text changed since."
+  ),
+  state: z24.string().length(1).refine((s) => !/[\]\r\n]/.test(s), {
+    message: 'state must be a single character other than "]" or a line break'
+  }).describe('New marker character: "x" (done), " " (open), or a custom marker like "/".'),
+  prevHash: z24.string().optional().describe(
+    "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
+  )
+});
+function lineStartOffset(raw, line) {
+  let offset = 0;
+  for (let n = 1; n < line; n++) {
+    offset = raw.indexOf("\n", offset) + 1;
+  }
+  return offset;
+}
+async function updateTask(ctx2, input) {
+  const absPath = resolveVaultPath(ctx2.vaultRoot, input.path);
+  assertWritable(ctx2.policy, input.path);
+  const original = await readFile14(absPath, "utf8");
+  if (input.prevHash !== void 0) assertHashMatch(original, input.prevHash, input.path);
+  const lineCount = original.split("\n").length;
+  if (input.line > lineCount) {
+    throw new Error(
+      JSON.stringify({
+        error: "line_out_of_range",
+        path: input.path,
+        line: input.line,
+        lineCount,
+        hint: "The note has fewer lines than the requested task line. Re-run list_tasks."
+      })
+    );
+  }
+  const task = extractTasks(original).find((t) => t.line === input.line);
+  if (!task) {
+    throw new Error(
+      JSON.stringify({
+        error: "not_a_task",
+        path: input.path,
+        line: input.line,
+        hint: "Line is not a Markdown checkbox (or is inside frontmatter or a code fence). Re-run list_tasks."
+      })
+    );
+  }
+  if (input.expectText !== void 0 && task.text !== input.expectText) {
+    throw new Error(
+      JSON.stringify({
+        error: "task_text_mismatch",
+        path: input.path,
+        line: input.line,
+        expected: input.expectText,
+        actual: task.text,
+        hint: "The task text changed since it was listed. Re-run list_tasks and retry."
+      })
+    );
+  }
+  if (task.state === input.state) {
+    return {
+      path: input.path,
+      line: input.line,
+      oldState: task.state,
+      newState: task.state,
+      contentHash: contentHash(original)
+    };
+  }
+  const markerOffset = lineStartOffset(original, input.line) + task.col;
+  const newContent = `${original.slice(0, markerOffset)}${input.state}${original.slice(markerOffset + 1)}`;
+  const fm = parseFrontmatter(original);
+  const originalFmRegion = original.slice(0, fm.bodyStart);
+  await journalWrite(ctx2, "update_task", input.path, original, newContent);
+  await atomicWrite(absPath, newContent);
+  const written = await readFile14(absPath, "utf8");
+  if (written.slice(0, originalFmRegion.length) !== originalFmRegion) {
+    throw new Error("Write-safety violation: frontmatter region changed unexpectedly");
+  }
+  const cached = ctx2.notes.get(input.path);
+  if (cached) {
+    cached.body = newContent.slice(fm.bodyStart);
+    cached.raw = newContent;
+    cached.tasks = extractTasks(newContent);
+    cached.sizeBytes = Buffer.byteLength(newContent, "utf8");
+  }
+  return {
+    path: input.path,
+    line: input.line,
+    oldState: task.state,
+    newState: input.state,
+    contentHash: contentHash(newContent)
+  };
+}
+
 // src/dispatch.ts
 var WRITE_TOOLS = /* @__PURE__ */ new Set([
   "create_note",
@@ -3049,6 +3408,7 @@ var WRITE_TOOLS = /* @__PURE__ */ new Set([
   "patch_note",
   "replace_in_note",
   "append_periodic_note",
+  "update_task",
   "undo_write"
 ]);
 var META_KEYS = [
@@ -3072,6 +3432,8 @@ var META_KEYS = [
   "period",
   "date",
   "permanent",
+  "line",
+  "state",
   "prevHash",
   "budgetBytes",
   "seq",
@@ -3086,6 +3448,7 @@ function safeMeta(args) {
   }
   if (typeof a.query === "string") out.queryLen = a.query.length;
   if (Array.isArray(a.where)) out.whereCount = a.where.length;
+  if (Array.isArray(a.items)) out.itemsCount = a.items.length;
   return out;
 }
 function resultBytes(r) {
@@ -3235,6 +3598,11 @@ async function run(ctx2, name, args) {
       const result = await readNote(ctx2, input);
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
+    case "read_notes": {
+      const input = ReadNotesInput.parse(args);
+      const result = await readNotes(ctx2, input);
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
     case "list_notes": {
       const input = ListNotesInput.parse(args);
       const entries = listNotes(ctx2, input);
@@ -3245,6 +3613,11 @@ async function run(ctx2, name, args) {
       const result = listTags(ctx2, input);
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
+    case "list_tasks": {
+      const input = ListTasksInput.parse(args);
+      const result = listTasks(ctx2, input);
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
     case "create_note": {
       const input = CreateNoteInput.parse(args);
       const result = await createNote(ctx2, input);
@@ -3374,6 +3747,11 @@ async function run(ctx2, name, args) {
       const result = getLinks(ctx2, input);
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
+    case "resolve_note": {
+      const input = ResolveNoteInput.parse(args);
+      const result = resolveNote(ctx2, input);
+      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    }
     case "replace_in_note": {
       const input = ReplaceInNoteInput.parse(args);
       const result = await replaceInNote(ctx2, input);
@@ -3415,6 +3793,20 @@ async function run(ctx2, name, args) {
         }
       };
     }
+    case "update_task": {
+      const input = UpdateTaskInput.parse(args);
+      const result = await updateTask(ctx2, input);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result) }],
+        audit: {
+          path: result.path,
+          line: result.line,
+          oldState: result.oldState,
+          newState: result.newState,
+          contentHash: result.contentHash
+        }
+      };
+    }
     case "list_writes": {
       const input = ListWritesInput.parse(args);
       const result = listWrites(ctx2, input);
@@ -3438,7 +3830,7 @@ async function run(ctx2, name, args) {
 }
 
 // src/index/build.ts
-import { readFile as readFile14 } from "fs/promises";
+import { readFile as readFile15 } from "fs/promises";
 import { basename as basename3, extname as extname4 } from "path";
 
 // ../core/src/walk.ts
@@ -3521,7 +3913,7 @@ async function buildIndex(vaultRoot2) {
   await Promise.all(
     noteEntries.map(async (entry) => {
       try {
-        const raw = await readFile14(entry.absPath, "utf8");
+        const raw = await readFile15(entry.absPath, "utf8");
         const fm = parseFrontmatter(raw);
         const inlineTags = extractInlineTags(fm.body);
         const fmTags = frontmatterTags(fm.data);
@@ -3535,6 +3927,7 @@ async function buildIndex(vaultRoot2) {
           fmKeys: fm.keys.join(" "),
           fm: fm.data,
           raw,
+          tasks: extractTasks(raw),
           sizeBytes: entry.sizeBytes,
           mtimeMs: entry.mtimeMs
         };
@@ -3575,7 +3968,7 @@ function buildBacklinks(notes2) {
 
 // src/init.ts
 import { execFileSync } from "child_process";
-import { access as access4, copyFile, mkdir as mkdir7, readdir as readdir2, readFile as readFile15, stat as stat3, writeFile as writeFile2 } from "fs/promises";
+import { access as access4, copyFile, mkdir as mkdir7, readdir as readdir2, readFile as readFile16, stat as stat3, writeFile as writeFile2 } from "fs/promises";
 import path, { dirname as dirname5, join as join7 } from "path";
 function parseInitArgs(argv) {
   const opts = { write: false, client: "desktop" };
@@ -3719,7 +4112,7 @@ async function runInit(opts, deps) {
       ]
     };
   }
-  const rf = deps.readFile ?? readFile15;
+  const rf = deps.readFile ?? readFile16;
   let vaultPath = opts.vault ?? deps.env.SEEKSTONE_VAULT;
   if (!vaultPath) {
     const registryPath = obsidianRegistryPath(deps.platform, {
@@ -3923,7 +4316,7 @@ function installProcessGuards(log2) {
 init_model_manifest();
 import { createHash as createHash2 } from "crypto";
 import { existsSync } from "fs";
-import { mkdir as mkdir8, readdir as readdir3, readFile as readFile16, rename as rename5, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir8, readdir as readdir3, readFile as readFile17, rename as rename5, writeFile as writeFile3 } from "fs/promises";
 import { join as join8 } from "path";
 async function materializeBundledModel(cfg, bundledDir, deps = {}) {
   if (!bundledDir) return;
@@ -3933,7 +4326,7 @@ async function materializeBundledModel(cfg, bundledDir, deps = {}) {
   }
   let bundledId;
   try {
-    const raw = await readFile16(join8(bundledDir, "manifest.json"), "utf8");
+    const raw = await readFile17(join8(bundledDir, "manifest.json"), "utf8");
     bundledId = String(JSON.parse(raw).id);
   } catch (err) {
     throw new Error(
@@ -3953,7 +4346,7 @@ async function materializeBundledModel(cfg, bundledDir, deps = {}) {
   let written = 0;
   for (const file of manifest.files) {
     const dest = join8(cfg.modelDir, file.name);
-    if (existsSync(dest) && sha256(await readFile16(dest)) === file.sha256) continue;
+    if (existsSync(dest) && sha256(await readFile17(dest)) === file.sha256) continue;
     const buf = await concatParts(bundledDir, file.name);
     const got = sha256(buf);
     if (got !== file.sha256) {
@@ -3988,7 +4381,7 @@ async function concatParts(bundledDir, name) {
     );
   }
   const buffers = [];
-  for (const part of parts) buffers.push(await readFile16(join8(bundledDir, part)));
+  for (const part of parts) buffers.push(await readFile17(join8(bundledDir, part)));
   return Buffer.concat(buffers);
 }
 function sha256(buf) {
@@ -4033,7 +4426,7 @@ ${window.map((p) => p.text).join("\n\n")}`,
 }
 function splitParagraphs(normalized) {
   const out = [];
-  const push = (rawStart, raw) => {
+  const push2 = (rawStart, raw) => {
     const text = raw.trim();
     if (text.length === 0) return;
     const start = rawStart + (raw.length - raw.trimStart().length);
@@ -4042,10 +4435,10 @@ function splitParagraphs(normalized) {
   const sep4 = /\n[ \t]*\n+/g;
   let prev = 0;
   for (const m of normalized.matchAll(sep4)) {
-    push(prev, normalized.slice(prev, m.index));
+    push2(prev, normalized.slice(prev, m.index));
     prev = m.index + m[0].length;
   }
-  push(prev, normalized.slice(prev));
+  push2(prev, normalized.slice(prev));
   return out;
 }
 function splitOversized(para) {
@@ -4146,7 +4539,7 @@ function candidateSetIdf(queryIds, docs) {
 }
 
 // ../core/src/embed/model2vec.ts
-import { readFile as readFile17 } from "fs/promises";
+import { readFile as readFile18 } from "fs/promises";
 import { basename as basename4, join as join10 } from "path";
 
 // ../core/src/embed/safetensors.ts
@@ -4328,9 +4721,9 @@ function isCjk(cp) {
 var TENSOR_NAME = "embeddings";
 async function loadModel2Vec(modelDir) {
   const [configRaw, tokenizerRaw, weights] = await Promise.all([
-    readFile17(join10(modelDir, "config.json"), "utf8"),
-    readFile17(join10(modelDir, "tokenizer.json"), "utf8"),
-    readFile17(join10(modelDir, "model.safetensors"))
+    readFile18(join10(modelDir, "config.json"), "utf8"),
+    readFile18(join10(modelDir, "tokenizer.json"), "utf8"),
+    readFile18(join10(modelDir, "model.safetensors"))
   ]);
   const config = JSON.parse(configRaw);
   const tokenizer = loadWordPieceTokenizer(JSON.parse(tokenizerRaw));
@@ -4489,7 +4882,7 @@ function isTokenEmbedder(e) {
 
 // src/semantic/cache.ts
 import { createHash as createHash3 } from "crypto";
-import { mkdir as mkdir9, readFile as readFile18, rename as rename6, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir9, readFile as readFile19, rename as rename6, writeFile as writeFile4 } from "fs/promises";
 import { join as join11 } from "path";
 var CACHE_VERSION = 3;
 function cachePathsFor(cacheDir, vaultRoot2, modelId) {
@@ -4499,11 +4892,11 @@ function cachePathsFor(cacheDir, vaultRoot2, modelId) {
 }
 async function loadCache(paths, modelId, dim) {
   try {
-    const manifest = JSON.parse(await readFile18(paths.manifest, "utf8"));
+    const manifest = JSON.parse(await readFile19(paths.manifest, "utf8"));
     if (manifest.version !== CACHE_VERSION || manifest.modelId !== modelId || manifest.dim !== dim) {
       return void 0;
     }
-    const buf = await readFile18(paths.bin);
+    const buf = await readFile19(paths.bin);
     const totalChunks = manifest.entries.reduce((a, e) => a + e.chunks, 0);
     const vectorBytes = totalChunks * dim * 4;
     const spanBytes = totalChunks * 2 * 4;
@@ -5121,6 +5514,59 @@ var ALL_TOOLS = [
       required: ["path"]
     }
   },
+  {
+    name: "read_notes",
+    annotations: READ_ONLY_ANNOTATIONS,
+    description: "Read up to 20 notes (or spans of them) in one call instead of repeated read_note calls, e.g. the top hits from search, query_notes, list_notes, or get_backlinks. Each item takes the same options as read_note and returns the same fields, in request order. budgetBytes (default 16384) caps the total note text: when the notes exceed it, each is cut to a fair share, marked truncated: true, and keeps noteBytes, so read the rest with read_note. A failing item (missing path, unknown section) returns its own error without failing the batch. contentHash is always the whole file's hash, usable as prevHash.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        items: {
+          type: "array",
+          description: "Notes to read, 1\u201320. Same options as read_note.",
+          items: {
+            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)."
+              },
+              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"]
+          }
+        },
+        budgetBytes: {
+          type: "number",
+          description: "Cap on total note text returned across all items, in UTF-8 bytes (256\u201365536, default 16384)."
+        }
+      },
+      required: ["items"]
+    }
+  },
   {
     name: "list_notes",
     annotations: READ_ONLY_ANNOTATIONS,
@@ -5162,6 +5608,45 @@ var ALL_TOOLS = [
       required: []
     }
   },
+  {
+    name: "list_tasks",
+    annotations: READ_ONLY_ANNOTATIONS,
+    description: 'List Markdown checkbox tasks as compact structured rows (path, line, state, text, nearest heading) \u2014 vault-wide or scoped by note, folder, tag, or modified time. Defaults to open tasks. Custom markers like "/" are single-char states. Rows feed straight into update_task; use this instead of searching for "- [ ]" or reading whole notes.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Vault-relative path to a single note. Omit to search the whole vault."
+        },
+        folder: { type: "string", description: "Restrict to a vault-relative folder prefix." },
+        tag: {
+          type: "string",
+          description: 'Restrict to notes with this tag. # optional, case-insensitive; nested child tags match ("project" matches project/alpha).'
+        },
+        state: {
+          anyOf: [
+            {
+              type: "string",
+              enum: ["open", "done", "any"],
+              description: 'open = "- [ ]" (default); done = "- [x]" or "- [X]"; any = every task.'
+            },
+            {
+              type: "string",
+              description: 'A single custom marker character, e.g. "/" or "-".'
+            }
+          ],
+          description: "Which tasks to return. Default: open."
+        },
+        modifiedAfter: {
+          type: "string",
+          description: "Only tasks in notes modified at or after this ISO 8601 date/time."
+        },
+        limit: { type: "number", description: "Max tasks (1\u2013500, default 100)." }
+      },
+      required: []
+    }
+  },
   {
     name: "create_note",
     annotations: DESTRUCTIVE_WRITE_ANNOTATIONS,
@@ -5401,6 +5886,22 @@ var ALL_TOOLS = [
       required: ["path"]
     }
   },
+  {
+    name: "resolve_note",
+    annotations: READ_ONLY_ANNOTATIONS,
+    description: "Resolve a note reference \u2014 a wikilink target, bare note name, path without extension, or frontmatter alias \u2014 to canonical vault-relative path(s). Each match carries provenance (path | basename | relpath | alias); matches[0] is exactly what a wikilink with that target resolves to, and ambiguous: true means more than one note matched. Empty matches means the reference resolves to nothing (didYouMean then lists close names). Returns paths only \u2014 resolve first, then read_notes. Pure index lookup.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        reference: {
+          type: "string",
+          minLength: 1,
+          description: 'Reference to resolve: a vault-relative path ("Projects/Core.md"), a path without extension, a bare note name ("Core"), or a frontmatter alias.'
+        }
+      },
+      required: ["reference"]
+    }
+  },
   {
     name: "replace_in_note",
     annotations: DESTRUCTIVE_WRITE_ANNOTATIONS,
@@ -5498,6 +5999,34 @@ var ALL_TOOLS = [
       required: ["content"]
     }
   },
+  {
+    name: "update_task",
+    annotations: IDEMPOTENT_DESTRUCTIVE_WRITE_ANNOTATIONS,
+    description: "Set the state of one Markdown checkbox identified by path + line (from list_tasks), rewriting exactly one character \u2014 the rest of the file, frontmatter included, stays byte-identical. Pass expectText to guard against the line having changed, and prevHash for full compare-and-swap. Setting the current state again is a success no-op.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Vault-relative path to the note." },
+        line: {
+          type: "number",
+          description: "1-based line number of the task, as returned by list_tasks."
+        },
+        expectText: {
+          type: "string",
+          description: "Optional guard: the task text list_tasks returned. Fails with task_text_mismatch if the line\u2019s text changed since."
+        },
+        state: {
+          type: "string",
+          description: 'New marker character: "x" (done), " " (open), or a custom marker like "/".'
+        },
+        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", "line", "state"]
+    }
+  },
   {
     name: "list_writes",
     annotations: READ_ONLY_ANNOTATIONS,
@@ -5542,7 +6071,7 @@ function visibleTools(policy2) {
 
 // src/watcher.ts
 import { realpathSync } from "fs";
-import { readFile as readFile19 } from "fs/promises";
+import { readFile as readFile20 } from "fs/promises";
 import { join as join12, relative as relative2, sep as sep3 } from "path";
 import chokidar from "chokidar";
 var DEFAULT_POLL_INTERVAL_MS = 1e4;
@@ -5574,7 +6103,7 @@ function startWatcher(ctx2, log2, opts) {
   const toRel = (abs) => relative2(vaultRoot2, abs).split(sep3).join("/");
   async function upsert(relPath, op) {
     try {
-      const raw = await readFile19(join12(vaultRoot2, relPath), "utf8");
+      const raw = await readFile20(join12(vaultRoot2, relPath), "utf8");
       removeNoteBacklinks(ctx2, relPath);
       upsertDoc(ctx2, buildDoc(relPath, raw));
       addNoteBacklinks(ctx2, relPath, raw);
@@ -5628,7 +6157,7 @@ function startWatcher(ctx2, log2, opts) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.20.3" : "0.0.0-dev";
+var VERSION = true ? "0.22.0" : "0.0.0-dev";
 var intent = parseCliIntent(process.argv.slice(2));
 if (intent === "version") {
   process.stdout.write(`${VERSION}