@velvetmonkey/flywheel-memory 2.0.8 → 2.0.10

package/dist/index.js

@@ -567,6 +567,7 @@ function injectMutationMetadata(frontmatter, scoping) {
     if (scoping.session_id) {
       frontmatter._session_id = scoping.session_id;
     }
+    frontmatter._source = "ai";
     if (scoping.agent_id && scoping.session_id) {
       frontmatter._last_modified_by = `${scoping.agent_id}:${scoping.session_id}`;
     } else if (scoping.agent_id) {
@@ -5022,6 +5023,82 @@ function getLinkPath(index, fromPath, toPath, maxDepth = 10) {
   }
   return { exists: false, path: [], length: -1 };
 }
+function getWeightedLinkPath(index, fromPath, toPath, maxDepth = 10) {
+  const from = index.notes.has(fromPath) ? fromPath : resolveTarget(index, fromPath);
+  const to = index.notes.has(toPath) ? toPath : resolveTarget(index, toPath);
+  if (!from || !to) {
+    return { exists: false, path: [], length: -1, total_weight: 0, weights: [] };
+  }
+  if (from === to) {
+    return { exists: true, path: [from], length: 0, total_weight: 0, weights: [] };
+  }
+  const hubNotes = findHubNotes(index, 0);
+  const connectionCounts = /* @__PURE__ */ new Map();
+  for (const hub of hubNotes) {
+    connectionCounts.set(hub.path, hub.total_connections);
+  }
+  const dist = /* @__PURE__ */ new Map();
+  const prev = /* @__PURE__ */ new Map();
+  const depthMap = /* @__PURE__ */ new Map();
+  dist.set(from, 0);
+  depthMap.set(from, 0);
+  const pq = [{ node: from, cost: 0 }];
+  const visited = /* @__PURE__ */ new Set();
+  while (pq.length > 0) {
+    const { node: current, cost: currentCost } = pq.shift();
+    if (current === to) break;
+    if (visited.has(current)) continue;
+    visited.add(current);
+    const currentDepth = depthMap.get(current) ?? 0;
+    if (currentDepth >= maxDepth) continue;
+    const note = index.notes.get(current);
+    if (!note) continue;
+    for (const link of note.outlinks) {
+      const targetPath = resolveTarget(index, link.target);
+      if (!targetPath || visited.has(targetPath)) continue;
+      const strength = getConnectionStrength(index, current, targetPath);
+      const baseWeight = 1 / (1 + strength.score);
+      const targetConnections = connectionCounts.get(targetPath) ?? 0;
+      const hubPenalty = targetConnections > 0 ? 1 + Math.log2(targetConnections) : 1;
+      const edgeWeight = baseWeight * hubPenalty;
+      const newDist = currentCost + edgeWeight;
+      const existingDist = dist.get(targetPath);
+      if (existingDist === void 0 || newDist < existingDist) {
+        dist.set(targetPath, newDist);
+        prev.set(targetPath, current);
+        depthMap.set(targetPath, currentDepth + 1);
+        const entry = { node: targetPath, cost: newDist };
+        const insertIdx = pq.findIndex((e) => e.cost > newDist);
+        if (insertIdx === -1) {
+          pq.push(entry);
+        } else {
+          pq.splice(insertIdx, 0, entry);
+        }
+      }
+    }
+  }
+  if (!dist.has(to)) {
+    return { exists: false, path: [], length: -1, total_weight: 0, weights: [] };
+  }
+  const resultPath = [];
+  let node = to;
+  while (node) {
+    resultPath.unshift(node);
+    node = prev.get(node);
+  }
+  const weights = [];
+  for (let i = 0; i < resultPath.length - 1; i++) {
+    const edgeDist = (dist.get(resultPath[i + 1]) ?? 0) - (dist.get(resultPath[i]) ?? 0);
+    weights.push(Math.round(edgeDist * 1e3) / 1e3);
+  }
+  return {
+    exists: true,
+    path: resultPath,
+    length: resultPath.length - 1,
+    total_weight: Math.round((dist.get(to) ?? 0) * 1e3) / 1e3,
+    weights
+  };
+}
 function getCommonNeighbors(index, noteAPath, noteBPath) {
   const noteA = index.notes.get(noteAPath);
   const noteB = index.notes.get(noteBPath);
@@ -6102,15 +6179,20 @@ function matchesFrontmatter(note, where) {
   }
   return true;
 }
-function hasTag(note, tag) {
+function hasTag(note, tag, includeChildren = false) {
   const normalizedTag = tag.replace(/^#/, "").toLowerCase();
-  return note.tags.some((t) => t.toLowerCase() === normalizedTag);
+  return note.tags.some((t) => {
+    const normalizedNoteTag = t.toLowerCase();
+    if (normalizedNoteTag === normalizedTag) return true;
+    if (includeChildren && normalizedNoteTag.startsWith(normalizedTag + "/")) return true;
+    return false;
+  });
 }
-function hasAnyTag(note, tags) {
-  return tags.some((tag) => hasTag(note, tag));
+function hasAnyTag(note, tags, includeChildren = false) {
+  return tags.some((tag) => hasTag(note, tag, includeChildren));
 }
-function hasAllTags(note, tags) {
-  return tags.every((tag) => hasTag(note, tag));
+function hasAllTags(note, tags, includeChildren = false) {
+  return tags.every((tag) => hasTag(note, tag, includeChildren));
 }
 function inFolder(note, folder) {
   const normalizedFolder = folder.endsWith("/") ? folder : folder + "/";
@@ -6140,7 +6222,7 @@ function sortNotes(notes, sortBy, order) {
 function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
   server2.tool(
     "search",
-    'Search the vault across metadata, content, and entities. Scope controls what to search: "metadata" for frontmatter/tags/folders, "content" for full-text search (FTS5), "entities" for people/projects/technologies, "all" (default) tries metadata then falls back to content search.',
+    'Search the vault across metadata, content, and entities. Scope controls what to search: "metadata" for frontmatter/tags/folders, "content" for full-text search (FTS5), "entities" for people/projects/technologies, "all" (default) tries metadata then falls back to content search.\n\nExample: search({ query: "quarterly review", scope: "content", limit: 5 })\nExample: search({ where: { type: "project", status: "active" }, scope: "metadata" })',
     {
       query: z4.string().optional().describe('Search query text. Required for scope "content", "entities", "all". For "metadata" scope, use filters instead.'),
       scope: z4.enum(["metadata", "content", "entities", "all"]).default("all").describe("What to search: metadata (frontmatter/tags/folders), content (FTS5 full-text), entities (people/projects), all (metadata then content)"),
@@ -6149,6 +6231,7 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
       has_tag: z4.string().optional().describe("Filter to notes with this tag"),
       has_any_tag: z4.array(z4.string()).optional().describe("Filter to notes with any of these tags"),
       has_all_tags: z4.array(z4.string()).optional().describe("Filter to notes with all of these tags"),
+      include_children: z4.boolean().default(false).describe('When true, tag filters also match child tags (e.g., has_tag: "project" also matches "project/active")'),
       folder: z4.string().optional().describe("Limit to notes in this folder"),
       title_contains: z4.string().optional().describe("Filter to notes whose title contains this text (case-insensitive)"),
       // Date filters (absorbs temporal tools)
@@ -6162,7 +6245,7 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
       // Pagination
       limit: z4.number().default(20).describe("Maximum number of results to return")
     },
-    async ({ query, scope, where, has_tag, has_any_tag, has_all_tags, folder, title_contains, modified_after, modified_before, sort_by, order, prefix, limit: requestedLimit }) => {
+    async ({ query, scope, where, has_tag, has_any_tag, has_all_tags, include_children, folder, title_contains, modified_after, modified_before, sort_by, order, prefix, limit: requestedLimit }) => {
       const limit = Math.min(requestedLimit ?? 20, MAX_LIMIT);
       const index = getIndex();
       const vaultPath2 = getVaultPath();
@@ -6188,13 +6271,13 @@ function registerQueryTools(server2, getIndex, getVaultPath, getStateDb) {
           matchingNotes = matchingNotes.filter((note) => matchesFrontmatter(note, where));
         }
         if (has_tag) {
-          matchingNotes = matchingNotes.filter((note) => hasTag(note, has_tag));
+          matchingNotes = matchingNotes.filter((note) => hasTag(note, has_tag, include_children));
         }
         if (has_any_tag && has_any_tag.length > 0) {
-          matchingNotes = matchingNotes.filter((note) => hasAnyTag(note, has_any_tag));
+          matchingNotes = matchingNotes.filter((note) => hasAnyTag(note, has_any_tag, include_children));
         }
         if (has_all_tags && has_all_tags.length > 0) {
-          matchingNotes = matchingNotes.filter((note) => hasAllTags(note, has_all_tags));
+          matchingNotes = matchingNotes.filter((note) => hasAllTags(note, has_all_tags, include_children));
         }
         if (folder) {
           matchingNotes = matchingNotes.filter((note) => inFolder(note, folder));
@@ -7135,16 +7218,17 @@ function registerPrimitiveTools(server2, getIndex, getVaultPath, getConfig = ()
     "get_link_path",
     {
       title: "Get Link Path",
-      description: "Find the shortest path of links between two notes.",
+      description: "Find the shortest path of links between two notes. Use weighted=true to penalize hub nodes for more meaningful paths.",
       inputSchema: {
         from: z6.string().describe("Starting note path"),
         to: z6.string().describe("Target note path"),
-        max_depth: z6.coerce.number().default(10).describe("Maximum path length to search")
+        max_depth: z6.coerce.number().default(10).describe("Maximum path length to search"),
+        weighted: z6.boolean().default(false).describe("Use weighted path-finding that penalizes hub nodes for more meaningful paths")
       }
     },
-    async ({ from, to, max_depth }) => {
+    async ({ from, to, max_depth, weighted }) => {
       const index = getIndex();
-      const result = getLinkPath(index, from, to, max_depth);
+      const result = weighted ? getWeightedLinkPath(index, from, to, max_depth) : getLinkPath(index, from, to, max_depth);
       return {
         content: [{ type: "text", text: JSON.stringify({
           from,
@@ -7411,7 +7495,7 @@ function registerGraphAnalysisTools(server2, getIndex, getVaultPath) {
     "graph_analysis",
     {
       title: "Graph Analysis",
-      description: 'Analyze vault link graph structure. Use analysis to pick the mode:\n- "orphans": Notes with no backlinks (disconnected content)\n- "dead_ends": Notes with backlinks but no outgoing links\n- "sources": Notes with outgoing links but no backlinks\n- "hubs": Highly connected notes (many links to/from)\n- "stale": Important notes (by backlink count) not recently modified',
+      description: 'Analyze vault link graph structure. Use analysis to pick the mode:\n- "orphans": Notes with no backlinks (disconnected content)\n- "dead_ends": Notes with backlinks but no outgoing links\n- "sources": Notes with outgoing links but no backlinks\n- "hubs": Highly connected notes (many links to/from)\n- "stale": Important notes (by backlink count) not recently modified\n\nExample: graph_analysis({ analysis: "hubs", limit: 10 })\nExample: graph_analysis({ analysis: "stale", days: 30, min_backlinks: 3 })',
       inputSchema: {
         analysis: z8.enum(["orphans", "dead_ends", "sources", "hubs", "stale"]).describe("Type of graph analysis to perform"),
         folder: z8.string().optional().describe("Limit to notes in this folder (orphans, dead_ends, sources)"),
@@ -7984,7 +8068,7 @@ function registerVaultSchemaTools(server2, getIndex, getVaultPath) {
     "vault_schema",
     {
       title: "Vault Schema",
-      description: 'Analyze and validate vault frontmatter schema. Use analysis to pick the mode:\n- "overview": Schema of all frontmatter fields across the vault\n- "field_values": All unique values for a specific field\n- "inconsistencies": Fields with multiple types across notes\n- "validate": Validate notes against a provided schema\n- "missing": Find notes missing expected fields by folder\n- "conventions": Auto-detect metadata conventions for a folder\n- "incomplete": Find notes missing expected fields (inferred)\n- "suggest_values": Suggest values for a field based on usage',
+      description: 'Analyze and validate vault frontmatter schema. Use analysis to pick the mode:\n- "overview": Schema of all frontmatter fields across the vault\n- "field_values": All unique values for a specific field\n- "inconsistencies": Fields with multiple types across notes\n- "validate": Validate notes against a provided schema\n- "missing": Find notes missing expected fields by folder\n- "conventions": Auto-detect metadata conventions for a folder\n- "incomplete": Find notes missing expected fields (inferred)\n- "suggest_values": Suggest values for a field based on usage\n\nExample: vault_schema({ analysis: "field_values", field: "status" })\nExample: vault_schema({ analysis: "conventions", folder: "projects" })',
       inputSchema: {
         analysis: z9.enum([
           "overview",
@@ -8554,7 +8638,7 @@ function registerNoteIntelligenceTools(server2, getIndex, getVaultPath) {
     "note_intelligence",
     {
       title: "Note Intelligence",
-      description: 'Analyze a note for patterns, suggestions, and consistency. Use analysis to pick the mode:\n- "prose_patterns": Find "Key: Value" or "Key: [[wikilink]]" patterns in prose\n- "suggest_frontmatter": Suggest YAML frontmatter from detected prose patterns\n- "suggest_wikilinks": Find frontmatter values that could be wikilinks\n- "cross_layer": Check consistency between frontmatter and prose references\n- "compute": Auto-compute derived fields (word_count, link_count, etc.)\n- "all": Run all analyses and return combined result',
+      description: 'Analyze a note for patterns, suggestions, and consistency. Use analysis to pick the mode:\n- "prose_patterns": Find "Key: Value" or "Key: [[wikilink]]" patterns in prose\n- "suggest_frontmatter": Suggest YAML frontmatter from detected prose patterns\n- "suggest_wikilinks": Find frontmatter values that could be wikilinks\n- "cross_layer": Check consistency between frontmatter and prose references\n- "compute": Auto-compute derived fields (word_count, link_count, etc.)\n- "all": Run all analyses and return combined result\n\nExample: note_intelligence({ path: "projects/alpha.md", analysis: "wikilinks" })\nExample: note_intelligence({ path: "projects/alpha.md", analysis: "compute", fields: ["word_count", "link_count"] })',
       inputSchema: {
         analysis: z10.enum([
           "prose_patterns",
@@ -9031,7 +9115,9 @@ async function createNoteFromTemplate(vaultPath2, notePath, config) {
 function registerMutationTools(server2, vaultPath2, getConfig = () => ({})) {
   server2.tool(
     "vault_add_to_section",
-    "Add content to a specific section in a markdown note. Set create_if_missing=true to auto-create the note from template if it doesn't exist (enables 1-call daily capture).",
+    `Add content to a specific section in a markdown note. Set create_if_missing=true to auto-create the note from template if it doesn't exist (enables 1-call daily capture).
+
+Example: vault_add_to_section({ path: "daily/2026-02-15.md", section: "Log", content: "Met with team about Q1", format: "timestamp-bullet", create_if_missing: true })`,
     {
       path: z11.string().describe('Vault-relative path to the note (e.g., "daily-notes/2026-01-28.md")'),
       section: z11.string().describe('Heading text to add to (e.g., "Log" or "## Log")'),
@@ -9295,7 +9381,7 @@ function toggleTask(content, lineNumber) {
 function registerTaskTools(server2, vaultPath2) {
   server2.tool(
     "vault_toggle_task",
-    "Toggle a task checkbox between checked and unchecked",
+    'Toggle a task checkbox between checked and unchecked.\n\nExample: vault_toggle_task({ path: "daily/2026-02-15.md", task: "review PR", section: "Tasks" })',
     {
       path: z12.string().describe("Vault-relative path to the note"),
       task: z12.string().describe("Task text to find (partial match supported)"),
@@ -9355,7 +9441,7 @@ function registerTaskTools(server2, vaultPath2) {
   );
   server2.tool(
     "vault_add_task",
-    "Add a new task to a section in a markdown note",
+    'Add a new task to a section in a markdown note.\n\nExample: vault_add_task({ path: "daily/2026-02-15.md", section: "Tasks", task: "Write unit tests for auth module" })',
     {
       path: z12.string().describe("Vault-relative path to the note"),
       section: z12.string().describe("Section to add the task to"),
@@ -9433,7 +9519,9 @@ import { z as z13 } from "zod";
 function registerFrontmatterTools(server2, vaultPath2) {
   server2.tool(
     "vault_update_frontmatter",
-    "Update frontmatter fields in a note (merge with existing). Set only_if_missing=true to only add fields that don't already exist (absorbed vault_add_frontmatter_field).",
+    `Update frontmatter fields in a note (merge with existing). Set only_if_missing=true to only add fields that don't already exist (absorbed vault_add_frontmatter_field).
+
+Example: vault_update_frontmatter({ path: "projects/alpha.md", frontmatter: { status: "active", priority: 1 }, only_if_missing: true })`,
     {
       path: z13.string().describe("Vault-relative path to the note"),
       frontmatter: z13.record(z13.any()).describe("Frontmatter fields to update (JSON object)"),
@@ -9494,10 +9582,11 @@ import path18 from "path";
 function registerNoteTools(server2, vaultPath2, getIndex) {
   server2.tool(
     "vault_create_note",
-    "Create a new note in the vault with optional frontmatter and content",
+    'Create a new note in the vault with optional frontmatter and content.\n\nExample: vault_create_note({ path: "people/Jane Smith.md", content: "# Jane Smith\\n\\nProduct manager at Acme.", frontmatter: { type: "person", company: "Acme" } })',
     {
       path: z14.string().describe('Vault-relative path for the new note (e.g., "daily-notes/2026-01-28.md")'),
       content: z14.string().default("").describe("Initial content for the note"),
+      template: z14.string().optional().describe('Vault-relative path to a template file (e.g., "templates/person.md"). Template variables {{date}} and {{title}} are substituted. Template frontmatter is merged with the frontmatter parameter (explicit values take precedence).'),
       frontmatter: z14.record(z14.any()).default({}).describe("Frontmatter fields (JSON object)"),
       overwrite: z14.boolean().default(false).describe("If true, overwrite existing file"),
       commit: z14.boolean().default(false).describe("If true, commit this change to git (creates undo point)"),
@@ -9507,7 +9596,7 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
       agent_id: z14.string().optional().describe("Agent identifier for multi-agent scoping"),
       session_id: z14.string().optional().describe("Session identifier for conversation scoping")
     },
-    async ({ path: notePath, content, frontmatter, overwrite, commit, skipWikilinks, suggestOutgoingLinks, maxSuggestions, agent_id, session_id }) => {
+    async ({ path: notePath, content, template, frontmatter, overwrite, commit, skipWikilinks, suggestOutgoingLinks, maxSuggestions, agent_id, session_id }) => {
       try {
         if (!validatePath(vaultPath2, notePath)) {
           return formatMcpResult(errorResult(notePath, "Invalid path: path traversal not allowed"));
@@ -9519,9 +9608,29 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
         }
         const dir = path18.dirname(fullPath);
         await fs18.mkdir(dir, { recursive: true });
+        let effectiveContent = content;
+        let effectiveFrontmatter = frontmatter;
+        if (template) {
+          const templatePath = path18.join(vaultPath2, template);
+          try {
+            const raw = await fs18.readFile(templatePath, "utf-8");
+            const matter8 = (await import("gray-matter")).default;
+            const parsed = matter8(raw);
+            const dateStr = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+            const title = path18.basename(notePath, ".md");
+            let templateContent = parsed.content.replace(/\{\{date\}\}/g, dateStr).replace(/\{\{title\}\}/g, title);
+            if (content) {
+              templateContent = templateContent.trimEnd() + "\n\n" + content;
+            }
+            effectiveContent = templateContent;
+            effectiveFrontmatter = { ...parsed.data || {}, ...frontmatter };
+          } catch {
+            return formatMcpResult(errorResult(notePath, `Template not found: ${template}`));
+          }
+        }
         const warnings = [];
         const noteName = path18.basename(notePath, ".md");
-        const existingAliases = Array.isArray(frontmatter?.aliases) ? frontmatter.aliases.filter((a) => typeof a === "string") : [];
+        const existingAliases = Array.isArray(effectiveFrontmatter?.aliases) ? effectiveFrontmatter.aliases.filter((a) => typeof a === "string") : [];
         const preflight = checkPreflightSimilarity(noteName);
         if (preflight.existingEntity) {
           warnings.push({
@@ -9545,7 +9654,7 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
             suggestion: `This may cause ambiguous wikilink resolution`
           });
         }
-        let { content: processedContent, wikilinkInfo } = maybeApplyWikilinks(content, skipWikilinks, notePath);
+        let { content: processedContent, wikilinkInfo } = maybeApplyWikilinks(effectiveContent, skipWikilinks, notePath);
         let suggestInfo;
         if (suggestOutgoingLinks && !skipWikilinks) {
           const result = suggestRelatedLinks(processedContent, { maxSuggestions, notePath });
@@ -9554,21 +9663,21 @@ function registerNoteTools(server2, vaultPath2, getIndex) {
             suggestInfo = `Suggested: ${result.suggestions.join(", ")}`;
           }
         }
-        let finalFrontmatter = frontmatter;
+        let finalFrontmatter = effectiveFrontmatter;
         if (agent_id || session_id) {
-          finalFrontmatter = injectMutationMetadata(frontmatter, { agent_id, session_id });
+          finalFrontmatter = injectMutationMetadata(effectiveFrontmatter, { agent_id, session_id });
         }
         await writeVaultFile(vaultPath2, notePath, processedContent, finalFrontmatter);
         const gitInfo = await handleGitCommit(vaultPath2, notePath, commit, "[Flywheel:Create]");
         const infoLines = [wikilinkInfo, suggestInfo].filter(Boolean);
         const previewLines = [
-          `Frontmatter fields: ${Object.keys(frontmatter).join(", ") || "none"}`,
+          `Frontmatter fields: ${Object.keys(effectiveFrontmatter).join(", ") || "none"}`,
           `Content length: ${processedContent.length} chars`
         ];
         if (infoLines.length > 0) {
           previewLines.push(`(${infoLines.join("; ")})`);
         }
-        const hasAliases = frontmatter && "aliases" in frontmatter;
+        const hasAliases = effectiveFrontmatter && "aliases" in effectiveFrontmatter;
         if (!hasAliases) {
           const aliasSuggestions = suggestAliases(noteName, existingAliases);
           if (aliasSuggestions.length > 0) {
@@ -11471,6 +11580,109 @@ function registerPolicyTools(server2, vaultPath2) {
   );
 }
 
+// src/resources/vault.ts
+function registerVaultResources(server2, getIndex) {
+  server2.registerResource(
+    "vault-stats",
+    "vault://stats",
+    {
+      title: "Vault Statistics",
+      description: "Overview of vault size, tags, links, and orphan count",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const index = getIndex();
+      if (!index) {
+        return {
+          contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify({ error: "Index not ready" }) }]
+        };
+      }
+      const noteCount = index.notes.size;
+      const tagCount = index.tags.size;
+      let totalLinks = 0;
+      for (const note of index.notes.values()) {
+        totalLinks += note.outlinks.length;
+      }
+      let orphanCount = 0;
+      for (const note of index.notes.values()) {
+        const normalizedTitle = note.title.toLowerCase();
+        const backlinks = index.backlinks.get(normalizedTitle);
+        if (!backlinks || backlinks.length === 0) {
+          orphanCount++;
+        }
+      }
+      const stats = {
+        note_count: noteCount,
+        tag_count: tagCount,
+        total_links: totalLinks,
+        orphan_count: orphanCount,
+        index_built_at: index.builtAt.toISOString()
+      };
+      return {
+        contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(stats, null, 2) }]
+      };
+    }
+  );
+  server2.registerResource(
+    "vault-schema",
+    "vault://schema",
+    {
+      title: "Vault Schema",
+      description: "Frontmatter field summary: field names, types, frequency",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const index = getIndex();
+      if (!index) {
+        return {
+          contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify({ error: "Index not ready" }) }]
+        };
+      }
+      const schema = getFrontmatterSchema(index);
+      const compact = {
+        total_notes: schema.total_notes,
+        notes_with_frontmatter: schema.notes_with_frontmatter,
+        field_count: schema.field_count,
+        fields: schema.fields.map((f) => ({
+          name: f.name,
+          types: f.types,
+          count: f.count,
+          examples: f.examples.slice(0, 3)
+        }))
+      };
+      return {
+        contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(compact, null, 2) }]
+      };
+    }
+  );
+  server2.registerResource(
+    "vault-recent",
+    "vault://recent",
+    {
+      title: "Recently Modified Notes",
+      description: "Last 10 modified notes in the vault",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const index = getIndex();
+      if (!index) {
+        return {
+          contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify({ error: "Index not ready" }) }]
+        };
+      }
+      const notes = Array.from(index.notes.values()).sort((a, b) => b.modified.getTime() - a.modified.getTime()).slice(0, 10).map((n) => ({
+        path: n.path,
+        title: n.title,
+        modified: n.modified.toISOString(),
+        tags: n.tags
+      }));
+      return {
+        contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify({ recent_notes: notes }, null, 2) }]
+      };
+    }
+  );
+}
+
 // src/index.ts
 var vaultPath = process.env.PROJECT_PATH || process.env.VAULT_PATH || findVaultRoot();
 var vaultIndex;
@@ -11661,6 +11873,7 @@ registerNoteTools(server, vaultPath, () => vaultIndex);
 registerMoveNoteTools(server, vaultPath);
 registerSystemTools2(server, vaultPath);
 registerPolicyTools(server, vaultPath);
+registerVaultResources(server, () => vaultIndex ?? null);
 console.error(`[Memory] Registered ${_registeredCount} tools, skipped ${_skippedCount}`);
 async function main() {
   console.error(`[Memory] Starting Flywheel Memory server...`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velvetmonkey/flywheel-memory",
-  "version": "2.0.8",
+  "version": "2.0.10",
   "description": "MCP server that gives Claude full read/write access to your Obsidian vault. 36 tools for search, backlinks, graph queries, and mutations.",
   "type": "module",
   "main": "dist/index.js",
@@ -50,7 +50,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "@velvetmonkey/vault-core": "^2.0.8",
+    "@velvetmonkey/vault-core": "^2.0.10",
     "better-sqlite3": "^11.0.0",
     "chokidar": "^4.0.0",
     "gray-matter": "^4.0.3",