neuro-vault-mcp 4.0.1 → 4.1.0

package/README.md

@@ -18,7 +18,7 @@ Your second brain stops being a folder you open between contexts and becomes a f
 
 - 🧠 **Semantic search that already knows your vault** — reuses [Smart Connections](https://github.com/brianpetro/obsidian-smart-connections) embeddings. No re-indexing, no API keys, no extra infrastructure.
 - 🎯 **Quick or deep, your call** — fast direct lookups for "find that note", or exploratory mode with related-note expansion when the question is fuzzy.
-- 🧭 **A real navigation toolkit for your agent** — instead of grepping files and opening notes one by one, your assistant walks the vault like a database: filter by tags and properties, batch-read metadata, discover the structure, jump to semantic neighbours.
+- 🧭 **A real navigation toolkit for your agent** — instead of grepping files and opening notes one by one, your assistant walks the vault like a database: filter by tags and properties, batch-read metadata, traverse the wikilink graph, discover the structure, jump to semantic neighbours.
 - 🔎 **Ask structured questions in plain language** — _"active projects tagged #ai"_, _"todo tasks with a deadline this week"_, _"meeting notes from `Work/` newest first"_ — one call, ranked answer, no chains of reads.
 - ✍️ **Read and write through Obsidian itself** — create, append, edit notes, manage frontmatter and daily notes via the [Obsidian CLI](https://github.com/AlexMost/obsidian-cli), so Smart Connections, sync, and other plugins stay in the loop.
 - ⚡ **Zero infrastructure** — local stdio MCP server, in-memory index, no database, no background processes, no watchers.

package/dist/cli.d.ts

@@ -18,6 +18,63 @@ interface SmartConnectionsCorpus {
     sources: Map<string, SmartSource>;
 }
 
+type ReadNotesField = 'frontmatter' | 'content';
+interface ReadNotesItemSuccess {
+    path: string;
+    frontmatter: Record<string, unknown> | null;
+    content: string;
+}
+interface ReadNotesItemError {
+    path: string;
+    error: {
+        code: 'NOT_FOUND' | 'INVALID_ARGUMENT' | 'READ_FAILED';
+        message: string;
+    };
+}
+type ReadNotesItem = ReadNotesItemSuccess | ReadNotesItemError;
+interface ReadNotesInput {
+    paths: string[];
+    fields: ReadNotesField[];
+}
+interface ScanOptions {
+    pathPrefix?: string;
+}
+interface VaultReader {
+    readNotes(input: ReadNotesInput): Promise<ReadNotesItem[]>;
+    scan(opts?: ScanOptions): Promise<string[]>;
+}
+
+interface OutgoingLink {
+    target: string;
+    resolved: boolean;
+    path?: string;
+}
+interface IncomingLink {
+    source: string;
+}
+interface NoteLinks {
+    incoming: IncomingLink[];
+    outgoing: OutgoingLink[];
+}
+interface WikilinkGraphIndexOptions {
+    reader: VaultReader;
+    ttlMs?: number;
+    now?: () => number;
+}
+declare class WikilinkGraphIndex {
+    private readonly reader;
+    private readonly ttlMs;
+    private readonly now;
+    private byPath;
+    private lastBuildAt;
+    private buildPromise;
+    constructor(opts: WikilinkGraphIndexOptions);
+    ensureFresh(): Promise<void>;
+    getNoteLinks(notePath: string): NoteLinks;
+    getBacklinkCount(notePath: string): number;
+    private rebuild;
+}
+
 interface BlockSearchResult {
     path: string;
     heading: string;
@@ -65,6 +122,10 @@ interface SemanticModuleDeps {
     searchEngine?: SearchEngine;
     pathExists?: PathExistsCheck;
     readNoteContent?: (vaultRelativePath: string) => Promise<string>;
+    graph?: WikilinkGraphIndex;
+    vaultReaderFactory?: (opts: {
+        vaultRoot: string;
+    }) => VaultReader;
 }
 
 type NoteIdentifier = {
@@ -150,37 +211,12 @@ interface ObsidianCLIProviderOptions {
     exec?: ExecFn;
 }
 
-type ReadNotesField = 'frontmatter' | 'content';
-interface ReadNotesItemSuccess {
-    path: string;
-    frontmatter: Record<string, unknown> | null;
-    content: string;
-}
-interface ReadNotesItemError {
-    path: string;
-    error: {
-        code: 'NOT_FOUND' | 'INVALID_ARGUMENT' | 'READ_FAILED';
-        message: string;
-    };
-}
-type ReadNotesItem = ReadNotesItemSuccess | ReadNotesItemError;
-interface ReadNotesInput {
-    paths: string[];
-    fields: ReadNotesField[];
-}
-interface ScanOptions {
-    pathPrefix?: string;
-}
-interface VaultReader {
-    readNotes(input: ReadNotesInput): Promise<ReadNotesItem[]>;
-    scan(opts?: ScanOptions): Promise<string[]>;
-}
-
 interface OperationsModuleDeps {
     vaultProviderFactory?: (opts: ObsidianCLIProviderOptions) => VaultProvider;
     vaultReaderFactory?: (opts: {
         vaultRoot: string;
     }) => VaultReader;
+    graph?: WikilinkGraphIndex;
 }
 
 type ToolServer = Pick<McpServer, 'registerTool' | 'connect'>;

package/dist/cli.js

@@ -753,6 +753,115 @@ async function getNoteLinks(opts) {
   return resolved;
 }
 
+// src/lib/obsidian/wikilink-graph.ts
+var DEFAULT_TTL_MS = 3 * 60 * 1e3;
+var READ_BATCH_SIZE = 32;
+var WikilinkGraphIndex = class {
+  reader;
+  ttlMs;
+  now;
+  byPath = /* @__PURE__ */ new Map();
+  lastBuildAt = 0;
+  buildPromise = null;
+  constructor(opts) {
+    this.reader = opts.reader;
+    this.ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS;
+    this.now = opts.now ?? Date.now;
+  }
+  async ensureFresh() {
+    if (this.buildPromise) {
+      await this.buildPromise;
+      return;
+    }
+    if (this.lastBuildAt > 0 && this.now() - this.lastBuildAt < this.ttlMs) {
+      return;
+    }
+    this.buildPromise = this.rebuild().then(() => {
+      this.lastBuildAt = this.now();
+    }).finally(() => {
+      this.buildPromise = null;
+    });
+    await this.buildPromise;
+  }
+  getNoteLinks(notePath) {
+    const entry = this.byPath.get(notePath);
+    if (!entry) return { incoming: [], outgoing: [] };
+    return {
+      incoming: entry.incoming.map((e) => ({ ...e })),
+      outgoing: entry.outgoing.map((e) => ({ ...e }))
+    };
+  }
+  getBacklinkCount(notePath) {
+    return this.byPath.get(notePath)?.incoming.length ?? 0;
+  }
+  async rebuild() {
+    const paths = await this.reader.scan();
+    const basenameIndex = buildBasenameIndex(paths);
+    const next = /* @__PURE__ */ new Map();
+    for (const p of paths) {
+      next.set(p, { outgoing: [], incoming: [] });
+    }
+    for (let i = 0; i < paths.length; i += READ_BATCH_SIZE) {
+      const slice = paths.slice(i, i + READ_BATCH_SIZE);
+      const items = await this.reader.readNotes({
+        paths: slice,
+        fields: ["frontmatter", "content"]
+      });
+      for (const item of items) {
+        if ("error" in item) {
+          if (item.error.code === "READ_FAILED") {
+            process.stderr.write(`[neuro-vault] wikilink-graph: ${item.error.message}
+`);
+          }
+          continue;
+        }
+        const adjacency = next.get(item.path);
+        if (!adjacency) continue;
+        const outgoing = collectOutgoing({
+          notePath: item.path,
+          body: item.content,
+          frontmatter: item.frontmatter,
+          basenameIndex
+        });
+        adjacency.outgoing = outgoing;
+        for (const edge of outgoing) {
+          if (!edge.resolved || !edge.path) continue;
+          const target = next.get(edge.path);
+          if (!target) continue;
+          target.incoming.push({ source: item.path });
+        }
+      }
+    }
+    this.byPath = next;
+  }
+};
+function collectOutgoing(args) {
+  const { notePath, body, frontmatter, basenameIndex } = args;
+  const rawTargets = [
+    ...parseWikilinks(body),
+    ...frontmatter ? extractWikilinksFromFrontmatter(frontmatter) : []
+  ];
+  const seenResolved = /* @__PURE__ */ new Set();
+  const seenUnresolved = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const raw of rawTargets) {
+    const target = normalizeWikilinkTarget(raw);
+    if (!target) continue;
+    const resolved = basenameIndex.resolve(target);
+    if (resolved) {
+      if (resolved === notePath) continue;
+      if (seenResolved.has(resolved)) continue;
+      seenResolved.add(resolved);
+      out.push({ target, resolved: true, path: resolved });
+    } else {
+      if (seenUnresolved.has(target)) continue;
+      seenUnresolved.add(target);
+      out.push({ target, resolved: false });
+    }
+  }
+  return out;
+}
+
 // src/lib/obsidian/query/query-notes.ts
 import siftModule from "sift";
 
@@ -812,12 +921,13 @@ async function invokeTool(handler) {
 }
 
 // src/lib/obsidian/query/note-record.ts
-function toNoteRecord(item) {
+function toNoteRecord(item, backlinkCount = 0) {
   const frontmatter = item.frontmatter && typeof item.frontmatter === "object" ? item.frontmatter : {};
   return {
     path: item.path,
     frontmatter,
-    tags: extractTags(frontmatter)
+    tags: extractTags(frontmatter),
+    backlink_count: backlinkCount
   };
 }
 function extractTags(frontmatter) {
@@ -883,10 +993,13 @@ var sift = typeof siftModule === "function" ? siftModule : siftModule.default;
 var DEFAULT_LIMIT = 100;
 var HARD_LIMIT_CAP = 1e3;
 var WINDOWS_ABSOLUTE_PATH_RE2 = /^[A-Za-z]:[\\/]/;
-var READ_BATCH_SIZE = 32;
-async function runQueryNotes(input, reader) {
+var READ_BATCH_SIZE2 = 32;
+async function runQueryNotes(input, reader, graph) {
   const validated = validateInput(input);
   validateFilter(validated.filter);
+  if (graph) {
+    await graph.ensureFresh();
+  }
   let paths;
   try {
     paths = await reader.scan({ pathPrefix: validated.pathPrefix });
@@ -911,8 +1024,8 @@ async function runQueryNotes(input, reader) {
   const fields = validated.includeContent ? ["frontmatter", "content"] : ["frontmatter"];
   const earlyExitAllowed = !validated.sort || validated.sort.field === "path" && validated.sort.order === "asc";
   const matched = [];
-  for (let i = 0; i < paths.length; i += READ_BATCH_SIZE) {
-    const slice = paths.slice(i, i + READ_BATCH_SIZE);
+  for (let i = 0; i < paths.length; i += READ_BATCH_SIZE2) {
+    const slice = paths.slice(i, i + READ_BATCH_SIZE2);
     const items = await reader.readNotes({ paths: slice, fields: [...fields] });
     for (const item of items) {
       if ("error" in item) {
@@ -922,7 +1035,8 @@ async function runQueryNotes(input, reader) {
         }
         continue;
       }
-      const record2 = toNoteRecord(item);
+      const backlinkCount = graph?.getBacklinkCount(item.path) ?? 0;
+      const record2 = toNoteRecord(item, backlinkCount);
       let isMatch;
       try {
         isMatch = matcher(record2);
@@ -944,8 +1058,13 @@ async function runQueryNotes(input, reader) {
     (row) => validated.includeContent ? {
       path: row.record.path,
       frontmatter: row.record.frontmatter,
+      backlink_count: row.record.backlink_count,
       content: row.content
-    } : { path: row.record.path, frontmatter: row.record.frontmatter }
+    } : {
+      path: row.record.path,
+      frontmatter: row.record.frontmatter,
+      backlink_count: row.record.backlink_count
+    }
   );
   return { results, count: results.length, truncated };
 }
@@ -1012,8 +1131,11 @@ function validateSort(raw) {
   if (typeof obj.field !== "string" || obj.field.trim() === "") {
     throw invalidParams("sort.field must be a non-empty string", "sort.field");
   }
-  if (obj.field !== "path" && !obj.field.startsWith("frontmatter.")) {
-    throw invalidParams('sort.field must be "path" or start with "frontmatter."', "sort.field");
+  if (obj.field !== "path" && obj.field !== "backlink_count" && !obj.field.startsWith("frontmatter.")) {
+    throw invalidParams(
+      'sort.field must be "path", "backlink_count", or start with "frontmatter."',
+      "sort.field"
+    );
   }
   if (obj.order !== "asc" && obj.order !== "desc") {
     throw invalidParams('sort.order must be "asc" or "desc"', "sort.order");
@@ -1030,6 +1152,7 @@ function sortInPlace(rows, sort) {
 }
 function readField(record2, field) {
   if (field === "path") return record2.path;
+  if (field === "backlink_count") return record2.backlink_count;
   const segments = field.split(".").slice(1);
   let cursor = record2.frontmatter;
   for (const seg of segments) {
@@ -15571,7 +15694,7 @@ function wrapDependencyError2(error48, message, details) {
   return new ToolHandlerError("DEPENDENCY_ERROR", message, { details, cause: error48 });
 }
 function buildSearchNotesTool(deps) {
-  const { sources, embeddingProvider, searchEngine, modelKey, pathExists } = deps;
+  const { sources, embeddingProvider, searchEngine, modelKey, pathExists, graph } = deps;
   return {
     name: "search_notes",
     title: "Search Notes",
@@ -15597,9 +15720,12 @@ function buildSearchNotesTool(deps) {
             ...output.results.map((r) => r.path),
             ...output.blockResults?.map((b) => b.path) ?? []
           ];
-          const existing = await buildExistingPathSet2(candidatePaths, pathExists);
+          const [existing] = await Promise.all([
+            buildExistingPathSet2(candidatePaths, pathExists),
+            graph.ensureFresh()
+          ]);
           return {
-            results: output.results.filter((r) => existing.has(r.path)),
+            results: output.results.filter((r) => existing.has(r.path)).map((r) => ({ ...r, backlink_count: graph.getBacklinkCount(r.path) })),
             ...output.blockResults !== void 0 ? { blockResults: output.blockResults.filter((b) => existing.has(b.path)) } : {},
             truncated: output.truncated
           };
@@ -15625,9 +15751,12 @@ function buildSearchNotesTool(deps) {
           ...output.results.map((r) => r.path),
           ...output.blockResults?.map((b) => b.path) ?? []
         ];
-        const existing = await buildExistingPathSet2(candidatePaths, pathExists);
+        const [existing] = await Promise.all([
+          buildExistingPathSet2(candidatePaths, pathExists),
+          graph.ensureFresh()
+        ]);
         return {
-          results: output.results.filter((r) => existing.has(r.path)),
+          results: output.results.filter((r) => existing.has(r.path)).map((r) => ({ ...r, backlink_count: graph.getBacklinkCount(r.path) })),
           ...output.blockResults !== void 0 ? { blockResults: output.blockResults.filter((b) => existing.has(b.path)) } : {}
         };
       } catch (error48) {
@@ -15676,6 +15805,12 @@ async function createSemanticModule(config2, deps = {}) {
   const pathExists = deps.pathExists ?? createDefaultPathExists(config2.vaultPath);
   const readNoteContent = deps.readNoteContent ?? createDefaultReadNoteContent(config2.vaultPath);
   const basenameIndex = buildBasenameIndex(corpus.sources.keys());
+  let graph = deps.graph;
+  if (!graph) {
+    const readerFactory = deps.vaultReaderFactory ?? ((opts) => new FsVaultReader({ vaultRoot: opts.vaultRoot }));
+    const reader = readerFactory({ vaultRoot: config2.vaultPath });
+    graph = new WikilinkGraphIndex({ reader });
+  }
   const semanticDeps = {
     sources: corpus.sources,
     embeddingProvider: embeddingService,
@@ -15683,7 +15818,8 @@ async function createSemanticModule(config2, deps = {}) {
     modelKey: config2.modelKey,
     pathExists,
     basenameIndex,
-    readNoteContent
+    readNoteContent,
+    graph
   };
   return {
     tools: buildSemanticTools(semanticDeps),
@@ -16100,15 +16236,43 @@ function buildEditNoteTool(deps) {
   };
 }
 
+// src/modules/operations/tools/get-note-links.ts
+var inputSchema8 = external_exports.object({
+  path: external_exports.string().min(1)
+});
+var DESCRIPTION = [
+  "Return the wikilink adjacency for a single note: full incoming and outgoing edge lists derived from the vault-wide wikilink graph.",
+  "",
+  "`incoming` is the resolved list of source notes whose body or frontmatter wikilinks (or `![[embeds]]`) point at the requested path. `outgoing` lists the wikilink targets in the requested note; each carries `resolved: bool`. Resolved entries also carry the resolved vault path; unresolved entries (concepts the user has anchored but not yet written) are kept verbatim and surfaced for traversal use cases.",
+  "",
+  "Backed by an in-memory index that rebuilds lazily on query when older than 3 minutes \u2014 no background timers, no watchers. The first call after a stale window pays the rebuild cost.",
+  "",
+  "Use `search_notes` / `query_notes` to find a starting note, then call `get_note_links` to traverse the graph around it."
+].join("\n");
+function buildGetNoteLinksTool(deps) {
+  const { graph } = deps;
+  return {
+    name: "get_note_links",
+    title: "Get Note Links",
+    description: DESCRIPTION,
+    inputSchema: inputSchema8,
+    handler: async (input) => {
+      const path6 = normalizePath(input.path);
+      await graph.ensureFresh();
+      return graph.getNoteLinks(path6);
+    }
+  };
+}
+
 // src/modules/operations/tools/list-properties.ts
-var inputSchema8 = external_exports.object({});
+var inputSchema9 = external_exports.object({});
 function buildListPropertiesTool(deps) {
   const { provider } = deps;
   return {
     name: "list_properties",
     title: "List Properties",
     description: "List all frontmatter properties used across the vault, sorted by occurrence count desc. Returns `[{name, count}]`. Useful for understanding the vault's metadata ontology.",
-    inputSchema: inputSchema8,
+    inputSchema: inputSchema9,
     handler: async (_input) => {
       return provider.listProperties();
     }
@@ -16116,14 +16280,14 @@ function buildListPropertiesTool(deps) {
 }
 
 // src/modules/operations/tools/list-tags.ts
-var inputSchema9 = external_exports.object({});
+var inputSchema10 = external_exports.object({});
 function buildListTagsTool(deps) {
   const { provider } = deps;
   return {
     name: "list_tags",
     title: "List Tags",
     description: "List all tags used across the vault, sorted by occurrence count desc. Returns `[{name, count}]`.",
-    inputSchema: inputSchema9,
+    inputSchema: inputSchema10,
     handler: async (_input) => {
       return provider.listTags();
     }
@@ -16135,7 +16299,7 @@ var queryNotesSortSchema = external_exports.object({
   field: external_exports.string().min(1),
   order: external_exports.enum(["asc", "desc"])
 });
-var inputSchema10 = external_exports.object({
+var inputSchema11 = external_exports.object({
   filter: external_exports.record(external_exports.string(), external_exports.unknown()),
   path_prefix: external_exports.string().optional(),
   sort: queryNotesSortSchema.optional(),
@@ -16143,27 +16307,27 @@ var inputSchema10 = external_exports.object({
   include_content: external_exports.boolean().optional()
 });
 function buildQueryNotesTool(deps) {
-  const { reader } = deps;
+  const { reader, graph } = deps;
   return {
     name: "query_notes",
     title: "Query Notes",
-    description: 'Run a structured MongoDB-style query against the vault\'s frontmatter and tags. `filter` is a sift/MongoDB filter object evaluated against `NoteRecord` shape `{ path, frontmatter, tags }` \u2014 `tags` is an array of strings (no leading `#`) extracted from the `tags:` frontmatter field. Reference frontmatter keys with the dotted prefix `frontmatter.<key>`. Supported operators: `$eq`, `$ne`, `$in`, `$nin`, `$gt`, `$gte`, `$lt`, `$lte`, `$exists`, `$regex`, `$and`, `$or`, `$nor`, `$not`. Optional `path_prefix` restricts the scan to a vault subtree (vault-relative POSIX, no leading slash). Optional `sort` is `{ field, order }` \u2014 `field` must be `"path"` or start with `"frontmatter."`. Optional `limit` defaults to 100, max 1000. Optional `include_content` (default false) \u2014 when true, each result also carries `content` (note body). Returns `{ results, count, truncated }`; `truncated` is true when more notes matched than `limit` allowed. Reads directly from disk and does not require Obsidian to be running.',
-    inputSchema: inputSchema10,
+    description: 'Run a structured MongoDB-style query against the vault\'s frontmatter, tags, and wikilink graph. `filter` is a sift/MongoDB filter object evaluated against `NoteRecord` shape `{ path, frontmatter, tags, backlink_count }` \u2014 `tags` is an array of strings (no leading `#`) extracted from the `tags:` frontmatter field; `backlink_count` is the number of vault-wide wikilinks (and `![[embeds]]`) that point at the note. Reference frontmatter keys with the dotted prefix `frontmatter.<key>`. Supported operators: `$eq`, `$ne`, `$in`, `$nin`, `$gt`, `$gte`, `$lt`, `$lte`, `$exists`, `$regex`, `$and`, `$or`, `$nor`, `$not`. Optional `path_prefix` restricts the scan to a vault subtree (vault-relative POSIX, no leading slash). Optional `sort` is `{ field, order }` \u2014 `field` must be `"path"`, `"backlink_count"`, or start with `"frontmatter."`. Optional `limit` defaults to 100, max 1000. Optional `include_content` (default false) \u2014 when true, each result also carries `content` (note body). Returns `{ results, count, truncated }`; each result item carries `backlink_count`. `truncated` is true when more notes matched than `limit` allowed. Reads directly from disk and does not require Obsidian to be running.',
+    inputSchema: inputSchema11,
     handler: async (input) => {
-      return runQueryNotes(input, reader);
+      return runQueryNotes(input, reader, graph);
     }
   };
 }
 
 // src/modules/operations/tools/read-daily.ts
-var inputSchema11 = external_exports.object({});
+var inputSchema12 = external_exports.object({});
 function buildReadDailyTool(deps) {
   const { provider } = deps;
   return {
     name: "read_daily",
     title: "Read Daily",
     description: "Read today's daily note. Returns `{ path, frontmatter, content }` where `frontmatter` is the parsed YAML object (or `null` if absent/malformed) and `content` is the body without the YAML block. Useful for 'what's on my agenda?' questions.",
-    inputSchema: inputSchema11,
+    inputSchema: inputSchema12,
     handler: async (_input) => {
       return provider.readDaily();
     }
@@ -16172,7 +16336,7 @@ function buildReadDailyTool(deps) {
 
 // src/modules/operations/tools/read-notes.ts
 var readNotesFieldSchema = external_exports.enum(["frontmatter", "content"]);
-var inputSchema12 = external_exports.object({
+var inputSchema13 = external_exports.object({
   paths: external_exports.union([external_exports.string().min(1), external_exports.array(external_exports.string()).min(1).max(50)]),
   fields: external_exports.array(readNotesFieldSchema).min(1).optional()
 });
@@ -16182,7 +16346,7 @@ function buildReadNotesTool(deps) {
     name: "read_notes",
     title: "Read Notes",
     description: "Read one or more notes in one call. `paths` is a vault-relative POSIX path string or an array of 1\u201350 such paths; duplicates are de-duplicated and results returned in input order. `fields` projects which parts of each note to return \u2014 choose from `frontmatter` and `content`; default `['frontmatter','content']`. One missing or unreadable path does not fail the others \u2014 per-item errors come back inline. A single MCP roundtrip with parallel disk reads. Reads are direct from disk and do not require Obsidian to be running.",
-    inputSchema: inputSchema12,
+    inputSchema: inputSchema13,
     handler: async (input) => {
       const { paths, fields } = validateReadNotesInput(input);
       const seen = /* @__PURE__ */ new Set();
@@ -16234,7 +16398,7 @@ function buildReadNotesTool(deps) {
 }
 
 // src/modules/operations/tools/read-property.ts
-var inputSchema13 = external_exports.object({
+var inputSchema14 = external_exports.object({
   name: external_exports.string().optional(),
   path: external_exports.string().optional(),
   key: external_exports.string()
@@ -16245,7 +16409,7 @@ function buildReadPropertyTool(deps) {
     name: "read_property",
     title: "Read Property",
     description: "Read a frontmatter property value from a note. Provide `name` or `path`, plus `key`. Returns `{ value }`. Use `read_notes` if you need the full frontmatter or accurate type information.",
-    inputSchema: inputSchema13,
+    inputSchema: inputSchema14,
     handler: async (input) => {
       const identifier = resolveIdentifier(input.name, input.path);
       if (!input.key || input.key.trim() === "") {
@@ -16257,7 +16421,7 @@ function buildReadPropertyTool(deps) {
 }
 
 // src/modules/operations/tools/remove-property.ts
-var inputSchema14 = external_exports.object({
+var inputSchema15 = external_exports.object({
   name: external_exports.string().optional(),
   path: external_exports.string().optional(),
   key: external_exports.string()
@@ -16268,7 +16432,7 @@ function buildRemovePropertyTool(deps) {
     name: "remove_property",
     title: "Remove Property",
     description: "Remove a frontmatter property from a note. Provide `name` or `path`, plus `key`. Idempotent \u2014 succeeds whether or not the property existed.",
-    inputSchema: inputSchema14,
+    inputSchema: inputSchema15,
     handler: async (input) => {
       const identifier = resolveIdentifier(input.name, input.path);
       if (!input.key || input.key.trim() === "") {
@@ -16281,7 +16445,7 @@ function buildRemovePropertyTool(deps) {
 }
 
 // src/modules/operations/tools/set-property.ts
-var inputSchema15 = external_exports.object({
+var inputSchema16 = external_exports.object({
   name: external_exports.string().optional(),
   path: external_exports.string().optional(),
   key: external_exports.string(),
@@ -16294,7 +16458,7 @@ function buildSetPropertyTool(deps) {
     name: "set_property",
     title: "Set Property",
     description: "Set a frontmatter property on a note. Provide either `name` (wikilink-style) or `path` (vault-relative). `key` is the frontmatter property name (e.g. `status`, `due`). `value` may be string/number/boolean/array \u2014 `type` is inferred from the JS type unless given. For `date`/`datetime` you MUST pass `type` explicitly AND use ISO format (`YYYY-MM-DD` for date, `YYYY-MM-DDTHH:mm:ss[.sss][Z|\xB1HH:mm]` for datetime) \u2014 non-ISO values are silently dropped by obsidian-cli, so this tool rejects them up front. List items must not contain commas (obsidian-cli limitation). Existing properties are overwritten.",
-    inputSchema: inputSchema15,
+    inputSchema: inputSchema16,
     handler: async (input) => {
       const identifier = resolveIdentifier(input.name, input.path);
       if (!input.key || input.key.trim() === "") {
@@ -16320,7 +16484,8 @@ function buildOperationsTools(deps) {
     registerTool(buildReadPropertyTool(deps)),
     registerTool(buildRemovePropertyTool(deps)),
     registerTool(buildListPropertiesTool(deps)),
-    registerTool(buildListTagsTool(deps))
+    registerTool(buildListTagsTool(deps)),
+    registerTool(buildGetNoteLinksTool(deps))
   ];
 }
 
@@ -16330,7 +16495,8 @@ function createOperationsModule(config2, deps = {}) {
   const readerFactory = deps.vaultReaderFactory ?? ((opts) => new FsVaultReader({ vaultRoot: opts.vaultRoot }));
   const provider = providerFactory({ binaryPath: config2.binaryPath });
   const reader = readerFactory({ vaultRoot: config2.vaultPath });
-  const toolDeps = { provider, reader };
+  const graph = deps.graph ?? new WikilinkGraphIndex({ reader });
+  const toolDeps = { provider, reader, graph };
   return { tools: buildOperationsTools(toolDeps) };
 }
 
@@ -16365,7 +16531,7 @@ Use \`read_notes\`, \`create_note\`, \`edit_note\`, \`read_daily\`, \`append_dai
 
 ### Structured queries
 
-Use \`query_notes\` for multi-criteria questions that combine tags, frontmatter properties, and ranges \u2014 for example "active projects with #ai", "todo tasks created this week", "notes with deadline set", "all notes tagged X". The \`filter\` is a MongoDB-style object evaluated against \`{ path, frontmatter, tags }\` \u2014 reference frontmatter keys as \`frontmatter.<key>\` and tags via the top-level \`tags\` field (no leading \`#\`). Supported operators: \`$eq\`, \`$ne\`, \`$in\`, \`$nin\`, \`$gt\`, \`$gte\`, \`$lt\`, \`$lte\`, \`$exists\`, \`$regex\`, \`$and\`, \`$or\`, \`$nor\`, \`$not\`. To list notes by a single tag use \`{ filter: { tags: 'X' } }\`. The result \`{ results, count, truncated }\` includes \`frontmatter\` always; pass \`include_content: true\` only when bodies are needed up-front (it can grow the response a lot). Reads directly from disk; does not need Obsidian running. \`limit\` defaults to 100 and is capped at 1000.
+Use \`query_notes\` for multi-criteria questions that combine tags, frontmatter properties, and ranges \u2014 for example "active projects with #ai", "todo tasks created this week", "notes with deadline set", "all notes tagged X". The \`filter\` is a MongoDB-style object evaluated against \`{ path, frontmatter, tags, backlink_count }\` \u2014 reference frontmatter keys as \`frontmatter.<key>\`, tags via the top-level \`tags\` field (no leading \`#\`), and \`backlink_count\` as a top-level scalar. Supported operators: \`$eq\`, \`$ne\`, \`$in\`, \`$nin\`, \`$gt\`, \`$gte\`, \`$lt\`, \`$lte\`, \`$exists\`, \`$regex\`, \`$and\`, \`$or\`, \`$nor\`, \`$not\`. To list notes by a single tag use \`{ filter: { tags: 'X' } }\`. \`backlink_count\` is filterable (\`{ backlink_count: { $gte: 5 } }\`) and sortable (\`sort: { field: 'backlink_count', order: 'desc' }\`). The result \`{ results, count, truncated }\` includes \`frontmatter\` and \`backlink_count\` always; pass \`include_content: true\` only when bodies are needed up-front (it can grow the response a lot). Reads directly from disk; does not need Obsidian running. \`limit\` defaults to 100 and is capped at 1000.
 
 ### Frontmatter properties
 
@@ -16379,6 +16545,10 @@ If you need frontmatter for one or more notes, call \`read_notes\` with \`fields
 
 Use \`list_tags\` to see all tags ranked by frequency. To list the notes that carry a specific tag, call \`query_notes\` with \`{ filter: { tags: '<name>' } }\` (no leading \`#\`).
 
+### Wikilink graph
+
+Use \`get_note_links\` for "what links here / where does this point" questions about a single note. It returns the full \`{ incoming, outgoing }\` adjacency from the vault-wide wikilink graph (covers both \`[[X]]\` and \`![[X]]\` embeds, in body and frontmatter). \`outgoing\` entries carry \`resolved: bool\`; unresolved targets are kept verbatim \u2014 useful for surfacing concepts the user has anchored but not yet written. The same graph powers the \`backlink_count\` field on \`search_notes\` and \`query_notes\` results, which is the right signal when you only need ranking by inbound popularity rather than a full edge list.
+
 ### CLI availability
 
 The vault-operations tools (other than \`read_notes\` and \`query_notes\`) route through the Obsidian CLI and require Obsidian to be running. If a call fails with \`CLI_NOT_FOUND\` or \`CLI_UNAVAILABLE\`, tell the user and stop \u2014 do not retry. \`read_notes\` and \`query_notes\` read directly from disk and do not need Obsidian to be running.
@@ -16399,7 +16569,7 @@ Use \`search_notes\` when the user is recalling a topic fuzzily, asking a concep
 - Use \`limit\` to override the default note count in either mode. Widening \`limit\` widens recall.
 
 ### 3. Use the results
-- \`results\` \u2014 notes ranked by similarity; read the file by path
+- \`results\` \u2014 notes ranked by similarity; read the file by path. Each result also carries \`backlink_count\` (vault-wide inbound wikilinks + embeds) \u2014 useful as a tiebreaker when several results share a similar similarity score.
 - \`matched_queries\` (only when \`query\` is an array) \u2014 which of your queries hit this note; lets you spot which synonym was load-bearing
 - \`truncated\` (only when \`query\` is an array) \u2014 true when unique merged candidates exceeded \`limit\`; widen \`limit\` to see more
 - \`via_expansion: true\` (deep mode only) \u2014 marks results pulled in by post-merge expansion; these have no \`matched_queries\`
@@ -16428,6 +16598,8 @@ async function startNeuroVaultServer(config2, deps = {}) {
   const serverFactory = deps.serverFactory ?? defaultServerFactory;
   const transportFactory = deps.transportFactory ?? defaultTransportFactory;
   const server = serverFactory();
+  const sharedReader = new FsVaultReader({ vaultRoot: config2.vaultPath });
+  const sharedGraph = new WikilinkGraphIndex({ reader: sharedReader });
   const registrations = [];
   let warmup = async () => {
   };
@@ -16439,7 +16611,7 @@ async function startNeuroVaultServer(config2, deps = {}) {
         modelKey: config2.semantic.modelKey,
         modelId: config2.semantic.modelId
       },
-      deps.semantic
+      { graph: sharedGraph, ...deps.semantic }
     );
     registrations.push(...semantic.tools);
     warmup = semantic.warmup;
@@ -16450,7 +16622,7 @@ async function startNeuroVaultServer(config2, deps = {}) {
         vaultPath: config2.vaultPath,
         binaryPath: config2.operations.binaryPath
       },
-      deps.operations
+      { graph: sharedGraph, ...deps.operations }
     );
     registrations.push(...operations.tools);
   }