clawvault 2.6.3 → 2.6.5

package/dist/{chunk-ZZA73MFY.js → chunk-33DOSHTA.js}

@@ -1,11 +1,123 @@
 // src/lib/memory-graph.ts
 import * as fs from "fs";
-import * as path from "path";
+import * as path2 from "path";
 import matter from "gray-matter";
 import { glob } from "glob";
+
+// src/lib/wiki-links.ts
+import * as path from "path";
+function stripInlineCode(line) {
+  let result = "";
+  let cursor = 0;
+  while (cursor < line.length) {
+    if (line[cursor] !== "`") {
+      result += line[cursor];
+      cursor += 1;
+      continue;
+    }
+    let fenceLength = 1;
+    while (cursor + fenceLength < line.length && line[cursor + fenceLength] === "`") {
+      fenceLength += 1;
+    }
+    const fence = "`".repeat(fenceLength);
+    const closeIndex = line.indexOf(fence, cursor + fenceLength);
+    if (closeIndex === -1) {
+      result += fence;
+      cursor += fenceLength;
+      continue;
+    }
+    cursor = closeIndex + fenceLength;
+  }
+  return result;
+}
+function parseFence(line) {
+  const match = line.match(/^[ \t]{0,3}(`{3,}|~{3,})/);
+  if (!match) return null;
+  const marker = match[1][0];
+  if (marker !== "`" && marker !== "~") return null;
+  return { marker, length: match[1].length };
+}
+function isFenceClose(line, fence) {
+  const re = new RegExp(`^[ \\t]{0,3}${fence.marker}{${fence.length},}[ \\t]*$`);
+  return re.test(line);
+}
+function stripMarkdownCode(markdownContent) {
+  const lines = markdownContent.split("\n");
+  const visibleLines = [];
+  let activeFence = null;
+  for (const line of lines) {
+    if (activeFence) {
+      if (isFenceClose(line, activeFence)) {
+        activeFence = null;
+      }
+      visibleLines.push("");
+      continue;
+    }
+    const openingFence = parseFence(line);
+    if (openingFence) {
+      activeFence = openingFence;
+      visibleLines.push("");
+      continue;
+    }
+    if (/^(?: {4}|\t)/.test(line)) {
+      visibleLines.push("");
+      continue;
+    }
+    visibleLines.push(stripInlineCode(line));
+  }
+  return visibleLines.join("\n");
+}
+function extractRawWikiLinks(markdownContent) {
+  const content = stripMarkdownCode(markdownContent);
+  const links = [];
+  let cursor = 0;
+  while (cursor < content.length) {
+    const start = content.indexOf("[[", cursor);
+    if (start === -1) break;
+    const end = content.indexOf("]]", start + 2);
+    if (end === -1) break;
+    const candidate = content.slice(start + 2, end).trim();
+    if (candidate) {
+      links.push(candidate);
+    }
+    cursor = end + 2;
+  }
+  return links;
+}
+function normalizeWikiLinkTarget(rawTarget) {
+  let value = rawTarget.trim();
+  if (!value) return "";
+  if (value.startsWith("[[") && value.endsWith("]]")) {
+    value = value.slice(2, -2).trim();
+  }
+  const pipeIndex = value.indexOf("|");
+  if (pipeIndex >= 0) {
+    value = value.slice(0, pipeIndex);
+  }
+  if (value.startsWith("#")) {
+    return "";
+  }
+  const hashIndex = value.indexOf("#");
+  if (hashIndex >= 0) {
+    value = value.slice(0, hashIndex);
+  }
+  value = value.trim().replace(/\\/g, "/").replace(/^\/+/, "");
+  if (!value) return "";
+  value = value.split("/").map((segment) => segment.trim()).join("/");
+  const normalizedPath = path.posix.normalize(value);
+  if (!normalizedPath || normalizedPath === ".") {
+    return "";
+  }
+  value = normalizedPath;
+  if (value.toLowerCase().endsWith(".md")) {
+    value = value.slice(0, -3);
+  }
+  return value.trim();
+}
+
+// src/lib/memory-graph.ts
 var MEMORY_GRAPH_SCHEMA_VERSION = 1;
-var GRAPH_INDEX_RELATIVE_PATH = path.join(".clawvault", "graph-index.json");
-var WIKI_LINK_RE = /\[\[([^\]]+)\]\]/g;
+var GRAPH_INDEX_RELATIVE_PATH = path2.join(".clawvault", "graph-index.json");
 var HASH_TAG_RE = /(^|\s)#([\w-]+)/g;
 var FRONTMATTER_RELATION_FIELDS = [
   "related",
@@ -19,7 +131,7 @@ var FRONTMATTER_RELATION_FIELDS = [
   "links"
 ];
 function normalizeRelativePath(value) {
-  return value.split(path.sep).join("/").replace(/^\.\//, "").replace(/^\/+/, "");
+  return value.split(path2.sep).join("/").replace(/^\.\//, "").replace(/^\/+/, "");
 }
 function toNoteKey(relativePath) {
   const normalized = normalizeRelativePath(relativePath);
@@ -57,31 +169,14 @@ function inferNodeType(relativePath, frontmatter) {
   return "note";
 }
 function ensureClawvaultDir(vaultPath) {
-  const dirPath = path.join(vaultPath, ".clawvault");
+  const dirPath = path2.join(vaultPath, ".clawvault");
   if (!fs.existsSync(dirPath)) {
     fs.mkdirSync(dirPath, { recursive: true });
   }
   return dirPath;
 }
 function getGraphIndexPath(vaultPath) {
-  return path.join(vaultPath, GRAPH_INDEX_RELATIVE_PATH);
-}
-function normalizeWikiTarget(target) {
-  let value = target.trim();
-  if (!value) return "";
-  const pipeIndex = value.indexOf("|");
-  if (pipeIndex >= 0) {
-    value = value.slice(0, pipeIndex);
-  }
-  const hashIndex = value.indexOf("#");
-  if (hashIndex >= 0) {
-    value = value.slice(0, hashIndex);
-  }
-  value = value.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
-  if (value.toLowerCase().endsWith(".md")) {
-    value = value.slice(0, -3);
-  }
-  return value.trim();
+  return path2.join(vaultPath, GRAPH_INDEX_RELATIVE_PATH);
 }
 function collectTags(frontmatter, markdownContent) {
   const tags = /* @__PURE__ */ new Set();
@@ -105,14 +200,15 @@ function collectTags(frontmatter, markdownContent) {
 }
 function extractWikiTargets(markdownContent) {
   const targets = /* @__PURE__ */ new Set();
-  for (const match of markdownContent.matchAll(WIKI_LINK_RE)) {
-    const candidate = match[1];
-    if (!candidate) continue;
+  for (const candidate of extractRawWikiLinks(markdownContent)) {
     const normalized = normalizeWikiTarget(candidate);
     if (normalized) targets.add(normalized);
   }
   return [...targets];
 }
+function normalizeWikiTarget(target) {
+  return normalizeWikiLinkTarget(target);
+}
 function toStringArray(value) {
   if (typeof value === "string") {
     return value.split(",").map((entry) => entry.trim()).filter(Boolean);
@@ -150,15 +246,57 @@ function buildNoteRegistry(relativePaths) {
   }
   return { byLowerPath, byLowerBasename };
 }
-function resolveTargetNodeId(rawTarget, registry) {
+function normalizeLookupPath(candidate) {
+  const normalized = normalizeWikiTarget(candidate);
+  if (!normalized) return "";
+  const resolved = path2.posix.normalize(normalized).replace(/^\/+/, "");
+  if (!resolved || resolved === "." || resolved.startsWith("../")) {
+    return "";
+  }
+  return resolved;
+}
+function buildTargetLookupCandidates(target, sourceNoteKey) {
+  const candidates = [];
+  const sourceDir = path2.posix.dirname(sourceNoteKey);
+  const hasSourceDir = sourceDir !== ".";
+  const isRelativeTarget = target.startsWith("./") || target.startsWith("../");
+  const addCandidate = (candidate) => {
+    const normalized = normalizeLookupPath(candidate);
+    if (!normalized || candidates.includes(normalized)) return;
+    candidates.push(normalized);
+  };
+  if (isRelativeTarget) {
+    if (hasSourceDir) {
+      addCandidate(path2.posix.join(sourceDir, target));
+    } else {
+      addCandidate(target);
+    }
+    if (target.startsWith("./")) {
+      addCandidate(target.slice(2));
+    }
+    return candidates;
+  }
+  if (!target.includes("/")) {
+    if (hasSourceDir) {
+      addCandidate(`${sourceDir}/${target}`);
+    }
+    addCandidate(target);
+    return candidates;
+  }
+  addCandidate(target);
+  return candidates;
+}
+function resolveTargetNodeId(rawTarget, registry, sourceNoteKey) {
   const normalized = normalizeWikiTarget(rawTarget);
   if (!normalized) {
     return toUnresolvedNodeId(rawTarget);
   }
   const lowerTarget = normalized.toLowerCase();
-  const direct = registry.byLowerPath.get(lowerTarget);
-  if (direct) {
-    return toNoteNodeId(direct);
+  for (const candidate of buildTargetLookupCandidates(normalized, sourceNoteKey)) {
+    const direct = registry.byLowerPath.get(candidate.toLowerCase());
+    if (direct) {
+      return toNoteNodeId(direct);
+    }
   }
   if (!normalized.includes("/")) {
     const basenameMatches = registry.byLowerBasename.get(lowerTarget) ?? [];
@@ -186,7 +324,7 @@ function buildFragmentNode(id, title, type, category, pathValue, tags, missing,
   };
 }
 function parseFileFragment(vaultPath, relativePath, mtimeMs, registry) {
-  const absolutePath = path.join(vaultPath, relativePath);
+  const absolutePath = path2.join(vaultPath, relativePath);
   const raw = fs.readFileSync(absolutePath, "utf-8");
   const parsed = matter(raw);
   const frontmatter = parsed.data ?? {};
@@ -225,7 +363,7 @@ function parseFileFragment(vaultPath, relativePath, mtimeMs, registry) {
   }
   const wikiTargets = extractWikiTargets(parsed.content);
   for (const target of wikiTargets) {
-    const targetNodeId = resolveTargetNodeId(target, registry);
+    const targetNodeId = resolveTargetNodeId(target, registry, noteKey);
     if (targetNodeId.startsWith("unresolved:") && !nodes.has(targetNodeId)) {
       nodes.set(
         targetNodeId,
@@ -241,7 +379,7 @@ function parseFileFragment(vaultPath, relativePath, mtimeMs, registry) {
     });
   }
   for (const relation of extractFrontmatterRelations(frontmatter)) {
-    const targetNodeId = resolveTargetNodeId(relation.target, registry);
+    const targetNodeId = resolveTargetNodeId(relation.target, registry, noteKey);
     if (targetNodeId.startsWith("unresolved:") && !nodes.has(targetNodeId)) {
       nodes.set(
         targetNodeId,
@@ -326,7 +464,7 @@ function isValidIndex(index) {
   return typed.schemaVersion === MEMORY_GRAPH_SCHEMA_VERSION && typeof typed.vaultPath === "string" && typeof typed.generatedAt === "string" && Boolean(typed.files && typeof typed.files === "object") && Boolean(typed.graph && typeof typed.graph === "object");
 }
 function loadMemoryGraphIndex(vaultPath) {
-  const indexPath = getGraphIndexPath(path.resolve(vaultPath));
+  const indexPath = getGraphIndexPath(path2.resolve(vaultPath));
   if (!fs.existsSync(indexPath)) {
     return null;
   }
@@ -341,7 +479,7 @@ function loadMemoryGraphIndex(vaultPath) {
   }
 }
 async function buildOrUpdateMemoryGraphIndex(vaultPathInput, options = {}) {
-  const vaultPath = path.resolve(vaultPathInput);
+  const vaultPath = path2.resolve(vaultPathInput);
   ensureClawvaultDir(vaultPath);
   const existing = options.forceFull ? null : loadMemoryGraphIndex(vaultPath);
   const markdownFiles = await glob("**/*.md", {
@@ -354,7 +492,7 @@ async function buildOrUpdateMemoryGraphIndex(vaultPathInput, options = {}) {
   const existingFragments = existing?.files ?? {};
   const currentFileSet = new Set(normalizedFiles);
   for (const relativePath of normalizedFiles) {
-    const absolutePath = path.join(vaultPath, relativePath);
+    const absolutePath = path2.join(vaultPath, relativePath);
     const stat = fs.statSync(absolutePath);
     const existingFragment = existingFragments[relativePath];
     if (!options.forceFull && existingFragment && existingFragment.mtimeMs === stat.mtimeMs) {
@@ -391,6 +529,8 @@ async function getMemoryGraph(vaultPath, options = {}) {
 }
 
 export {
+  extractRawWikiLinks,
+  normalizeWikiLinkTarget,
   MEMORY_GRAPH_SCHEMA_VERSION,
   loadMemoryGraphIndex,
   buildOrUpdateMemoryGraphIndex,

package/dist/chunk-4BQTQMJP.js

@@ -0,0 +1,93 @@
+import {
+  __export
+} from "./chunk-2ZDO52B4.js";
+
+// src/workgraph/ledger.ts
+var ledger_exports = {};
+__export(ledger_exports, {
+  activityOf: () => activityOf,
+  allClaims: () => allClaims,
+  append: () => append,
+  currentOwner: () => currentOwner,
+  historyOf: () => historyOf,
+  isClaimed: () => isClaimed,
+  ledgerPath: () => ledgerPath,
+  readAll: () => readAll,
+  readSince: () => readSince,
+  recent: () => recent
+});
+import fs from "fs";
+import path from "path";
+var LEDGER_FILE = ".clawvault/ledger.jsonl";
+function ledgerPath(vaultPath) {
+  return path.join(vaultPath, LEDGER_FILE);
+}
+function append(vaultPath, actor, op, target, type, data) {
+  const entry = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    actor,
+    op,
+    target,
+    ...type ? { type } : {},
+    ...data && Object.keys(data).length > 0 ? { data } : {}
+  };
+  const lPath = ledgerPath(vaultPath);
+  const dir = path.dirname(lPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.appendFileSync(lPath, JSON.stringify(entry) + "\n", "utf-8");
+  return entry;
+}
+function readAll(vaultPath) {
+  const lPath = ledgerPath(vaultPath);
+  if (!fs.existsSync(lPath)) return [];
+  const lines = fs.readFileSync(lPath, "utf-8").split("\n").filter(Boolean);
+  return lines.map((line) => JSON.parse(line));
+}
+function readSince(vaultPath, since) {
+  return readAll(vaultPath).filter((e) => e.ts >= since);
+}
+function currentOwner(vaultPath, target) {
+  const entries = readAll(vaultPath).filter((e) => e.target === target);
+  let owner = null;
+  for (const e of entries) {
+    if (e.op === "claim") owner = e.actor;
+    if (e.op === "release" || e.op === "done" || e.op === "cancel") owner = null;
+  }
+  return owner;
+}
+function isClaimed(vaultPath, target) {
+  return currentOwner(vaultPath, target) !== null;
+}
+function historyOf(vaultPath, target) {
+  return readAll(vaultPath).filter((e) => e.target === target);
+}
+function activityOf(vaultPath, actor) {
+  return readAll(vaultPath).filter((e) => e.actor === actor);
+}
+function allClaims(vaultPath) {
+  const claims = /* @__PURE__ */ new Map();
+  const entries = readAll(vaultPath);
+  for (const e of entries) {
+    if (e.op === "claim") claims.set(e.target, e.actor);
+    if (e.op === "release" || e.op === "done" || e.op === "cancel") claims.delete(e.target);
+  }
+  return claims;
+}
+function recent(vaultPath, count = 20) {
+  const all = readAll(vaultPath);
+  return all.slice(-count);
+}
+
+export {
+  ledgerPath,
+  append,
+  readAll,
+  readSince,
+  currentOwner,
+  isClaimed,
+  historyOf,
+  activityOf,
+  allClaims,
+  recent,
+  ledger_exports
+};

package/dist/{chunk-MAKNAHAW.js → chunk-5PJ4STIC.js}

@@ -4,12 +4,57 @@ import * as fs from "fs";
 import * as path from "path";
 var QMD_INSTALL_URL = "https://github.com/tobi/qmd";
 var QMD_INSTALL_COMMAND = "bun install -g github:tobi/qmd";
-var QMD_NOT_INSTALLED_MESSAGE = `ClawVault requires qmd. Install: ${QMD_INSTALL_COMMAND}`;
 var QMD_INDEX_ENV_VAR = "CLAWVAULT_QMD_INDEX";
+var QMD_ERROR_MESSAGES = {
+  NOT_INSTALLED: {
+    code: "NOT_INSTALLED",
+    message: "qmd is not installed",
+    hint: `Install qmd to enable ClawVault search and indexing:
+  ${QMD_INSTALL_COMMAND}
+
+For more information: ${QMD_INSTALL_URL}`
+  },
+  NOT_CONFIGURED: {
+    code: "NOT_CONFIGURED",
+    message: "qmd collection is not configured",
+    hint: "Run `clawvault doctor` to diagnose configuration issues, or `clawvault migrate` to fix common setup problems."
+  },
+  COLLECTION_NOT_FOUND: {
+    code: "COLLECTION_NOT_FOUND",
+    message: "qmd collection not found",
+    hint: "The configured qmd collection does not exist. Run `clawvault migrate` to recreate it, or `qmd collection add <name> <path>` manually."
+  },
+  EXECUTION_FAILED: {
+    code: "EXECUTION_FAILED",
+    message: "qmd command failed",
+    hint: "Run `clawvault doctor` to diagnose qmd issues."
+  }
+};
 var QmdUnavailableError = class extends Error {
-  constructor(message = QMD_NOT_INSTALLED_MESSAGE) {
-    super(message);
+  code;
+  hint;
+  constructor(code = "NOT_INSTALLED", additionalContext) {
+    const details = QMD_ERROR_MESSAGES[code];
+    const fullMessage = additionalContext ? `${details.message}: ${additionalContext}` : details.message;
+    super(fullMessage);
     this.name = "QmdUnavailableError";
+    this.code = code;
+    this.hint = details.hint;
+  }
+  toUserMessage() {
+    return `Error: ${this.message}
+
+${this.hint}`;
+  }
+};
+function getQmdErrorDetails(code) {
+  return QMD_ERROR_MESSAGES[code];
+}
+var QmdConfigurationError = class extends Error {
+  constructor(message, hint) {
+    super(message);
+    this.hint = hint;
+    this.name = "QmdConfigurationError";
   }
 };
 function ensureJsonArgs(args) {
@@ -80,9 +125,39 @@ function parseQmdOutput(raw) {
 }
 function ensureQmdAvailable() {
   if (!hasQmd()) {
-    throw new QmdUnavailableError();
+    throw new QmdUnavailableError("NOT_INSTALLED");
   }
 }
+function detectQmdError(output, args) {
+  const lowerOutput = output.toLowerCase();
+  if (lowerOutput.includes("missing required arguments") || lowerOutput.includes("unknown option")) {
+    return new QmdConfigurationError(
+      'qmd does not support the search command with the expected arguments. This may indicate an incompatible qmd version or a different tool named "qmd".',
+      `Ensure you have the correct qmd installed: ${QMD_INSTALL_COMMAND}`
+    );
+  }
+  if (lowerOutput.includes("collection not found") || lowerOutput.includes("no collection")) {
+    const collectionArg = args.findIndex((a) => a === "-c");
+    const collectionName = collectionArg >= 0 && args[collectionArg + 1] ? args[collectionArg + 1] : "unknown";
+    return new QmdConfigurationError(
+      `qmd collection "${collectionName}" not found.`,
+      'Run `qmd update -c <collection>` to create the collection, or check your vault\'s .clawvault.json "name" field.'
+    );
+  }
+  if (lowerOutput.includes("no index") || lowerOutput.includes("index not found")) {
+    return new QmdConfigurationError(
+      "qmd index not found. The vault may not be indexed yet.",
+      "Run `clawvault rebuild` or `qmd update` to build the search index."
+    );
+  }
+  if (lowerOutput.includes("embedding") && (lowerOutput.includes("not found") || lowerOutput.includes("missing"))) {
+    return new QmdConfigurationError(
+      "qmd embeddings not found. Vector search requires embeddings to be generated.",
+      "Run `clawvault embed` or `qmd embed` to generate embeddings for semantic search."
+    );
+  }
+  return null;
+}
 function execQmd(args, indexName) {
   ensureQmdAvailable();
   const finalArgs = withQmdIndexArgs(ensureJsonArgs(args), indexName);
@@ -96,17 +171,24 @@ function execQmd(args, indexName) {
     return parseQmdOutput(result);
   } catch (err) {
     if (err?.code === "ENOENT") {
-      throw new QmdUnavailableError();
+      throw new QmdUnavailableError("NOT_INSTALLED");
     }
     const output = [err?.stdout, err?.stderr].filter(Boolean).join("\n");
+    const detectedError = detectQmdError(output, finalArgs);
+    if (detectedError) {
+      throw detectedError;
+    }
     if (output) {
       try {
         return parseQmdOutput(output);
       } catch {
       }
+      if (output.includes("collection not found") || output.includes("no such collection")) {
+        throw new QmdUnavailableError("COLLECTION_NOT_FOUND", output.trim());
+      }
     }
-    const message = err?.message ? `qmd failed: ${err.message}` : "qmd failed";
-    throw new Error(message);
+    const errorDetail = err?.message || "unknown error";
+    throw new QmdUnavailableError("EXECUTION_FAILED", errorDetail);
   }
 }
 function hasQmd() {
@@ -131,7 +213,7 @@ function qmdEmbed(collection, indexName) {
 }
 var SearchEngine = class {
   documents = /* @__PURE__ */ new Map();
-  collection = "clawvault";
+  collection = "";
   vaultPath = "";
   collectionRoot = "";
   qmdIndexName;
@@ -141,6 +223,12 @@ var SearchEngine = class {
   setCollection(name) {
     this.collection = name;
   }
+  /**
+   * Get the current collection name
+   */
+  getCollection() {
+    return this.collection;
+  }
   /**
    * Set the vault path for file resolution
    */
@@ -365,6 +453,8 @@ export {
   QMD_INSTALL_URL,
   QMD_INSTALL_COMMAND,
   QmdUnavailableError,
+  getQmdErrorDetails,
+  QmdConfigurationError,
   withQmdIndexArgs,
   hasQmd,
   qmdUpdate,

package/dist/{chunk-RVYA52PY.js → chunk-5UM4PMMM.js}

@@ -1,7 +1,7 @@
 import {
   hasQmd,
   withQmdIndexArgs
-} from "./chunk-MAKNAHAW.js";
+} from "./chunk-5PJ4STIC.js";
 import {
   DEFAULT_CATEGORIES
 } from "./chunk-2CDEETQN.js";

package/dist/{chunk-4VQTUVH7.js → chunk-7YZWHM36.js}

@@ -1,13 +1,16 @@
 import {
   buildEntityIndex
 } from "./chunk-J7ZWCI2C.js";
+import {
+  extractRawWikiLinks,
+  normalizeWikiLinkTarget
+} from "./chunk-33DOSHTA.js";
 
 // src/lib/backlinks.ts
 import * as fs from "fs";
 import * as path from "path";
 var CLAWVAULT_DIR = ".clawvault";
 var BACKLINKS_FILE = "backlinks.json";
-var WIKI_LINK_REGEX = /\[\[([^\]]+)\]\]/g;
 function ensureClawvaultDir(vaultPath) {
   const dir = path.join(vaultPath, CLAWVAULT_DIR);
   if (!fs.existsSync(dir)) {
@@ -20,29 +23,47 @@ function toVaultId(vaultPath, filePath) {
   return relative2.split(path.sep).join("/");
 }
 function normalizeLinkTarget(raw) {
-  let target = raw.trim();
-  if (!target) return "";
-  if (target.startsWith("[[") && target.endsWith("]]")) {
-    target = target.slice(2, -2);
-  }
-  const pipeIndex = target.indexOf("|");
-  if (pipeIndex !== -1) {
-    target = target.slice(0, pipeIndex);
-  }
-  if (target.startsWith("#")) return "";
-  const hashIndex = target.indexOf("#");
-  if (hashIndex !== -1) {
-    target = target.slice(0, hashIndex);
+  return normalizeWikiLinkTarget(raw);
+}
+function normalizeLookupCandidate(value) {
+  const normalized = normalizeLinkTarget(value);
+  if (!normalized) return "";
+  const resolved = path.posix.normalize(normalized).replace(/^\/+/, "");
+  if (!resolved || resolved === "." || resolved.startsWith("../")) {
+    return "";
   }
-  target = target.trim();
-  if (!target) return "";
-  if (target.endsWith(".md")) {
-    target = target.slice(0, -3);
+  return resolved;
+}
+function buildLookupCandidates(target, sourceId) {
+  const candidates = [];
+  const sourceDir = path.posix.dirname(sourceId);
+  const hasSourceDir = sourceDir !== ".";
+  const isRelativeTarget = target.startsWith("./") || target.startsWith("../");
+  const addCandidate = (candidate) => {
+    const normalized = normalizeLookupCandidate(candidate);
+    if (!normalized || candidates.includes(normalized)) return;
+    candidates.push(normalized);
+  };
+  if (isRelativeTarget) {
+    if (hasSourceDir) {
+      addCandidate(path.posix.join(sourceDir, target));
+    } else {
+      addCandidate(target);
+    }
+    if (target.startsWith("./")) {
+      addCandidate(target.slice(2));
+    }
+    return candidates;
   }
-  if (target.startsWith("/")) {
-    target = target.slice(1);
+  if (!target.includes("/")) {
+    if (hasSourceDir) {
+      addCandidate(`${sourceDir}/${target}`);
+    }
+    addCandidate(target);
+    return candidates;
   }
-  return target.replace(/\\/g, "/");
+  addCandidate(target);
+  return candidates;
 }
 function listMarkdownFiles(vaultPath) {
   const files = [];
@@ -75,11 +96,16 @@ function buildKnownIds(vaultPath, files) {
   }
   return { ids, idsLower };
 }
-function resolveTarget(target, known, entityIndex) {
+function resolveTarget(target, sourceId, known, entityIndex) {
   if (!target) return null;
-  if (known.ids.has(target)) return target;
+  for (const candidate of buildLookupCandidates(target, sourceId)) {
+    if (known.ids.has(candidate)) return candidate;
+    const lowerCandidate = candidate.toLowerCase();
+    if (known.idsLower.has(lowerCandidate)) {
+      return known.idsLower.get(lowerCandidate);
+    }
+  }
   const lower = target.toLowerCase();
-  if (known.idsLower.has(lower)) return known.idsLower.get(lower);
   if (entityIndex?.entries.has(lower)) return entityIndex.entries.get(lower);
   return null;
 }
@@ -93,12 +119,12 @@ function scanVaultLinks(vaultPath, options = {}) {
   for (const file of files) {
     const sourceId = toVaultId(vaultPath, file);
     const content = fs.readFileSync(file, "utf-8");
-    const matches = content.match(WIKI_LINK_REGEX) || [];
+    const matches = extractRawWikiLinks(content);
     linkCount += matches.length;
     for (const match of matches) {
       const target = normalizeLinkTarget(match);
       if (!target) continue;
-      const resolved = resolveTarget(target, known, entityIndex);
+      const resolved = resolveTarget(target, sourceId, known, entityIndex);
       if (!resolved) {
         orphans.push({ source: sourceId, target });
         continue;