clawvault 2.6.0 → 3.0.0

package/dist/commands/doctor.cjs

@@ -0,0 +1,3062 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/doctor.ts
+var doctor_exports = {};
+__export(doctor_exports, {
+  doctor: () => doctor
+});
+module.exports = __toCommonJS(doctor_exports);
+var fs8 = __toESM(require("fs"), 1);
+var os2 = __toESM(require("os"), 1);
+var path9 = __toESM(require("path"), 1);
+
+// src/lib/vault.ts
+var fs3 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+var import_url = require("url");
+var import_gray_matter2 = __toESM(require("gray-matter"), 1);
+var import_glob2 = require("glob");
+
+// src/types.ts
+var DEFAULT_CATEGORIES = [
+  "rules",
+  "preferences",
+  "decisions",
+  "patterns",
+  "people",
+  "projects",
+  "goals",
+  "transcripts",
+  "inbox",
+  "templates",
+  "lessons",
+  "agents",
+  "commitments",
+  "handoffs",
+  "research",
+  "tasks",
+  "backlog"
+];
+var TYPE_TO_CATEGORY = {
+  fact: "facts",
+  feeling: "feelings",
+  decision: "decisions",
+  lesson: "lessons",
+  commitment: "commitments",
+  preference: "preferences",
+  relationship: "people",
+  project: "projects"
+};
+
+// src/lib/search.ts
+var import_child_process = require("child_process");
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+
+// src/lib/reweave.ts
+var SUPERSEDED_MARKER_RE = /\[superseded\|by=([^\]|]+)\|detected=([^\]]+)\]/;
+function isSuperseded(line) {
+  return SUPERSEDED_MARKER_RE.test(line);
+}
+
+// src/lib/search.ts
+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 QmdUnavailableError = class extends Error {
+  constructor(message = QMD_NOT_INSTALLED_MESSAGE) {
+    super(message);
+    this.name = "QmdUnavailableError";
+  }
+};
+function ensureJsonArgs(args) {
+  return args.includes("--json") ? args : [...args, "--json"];
+}
+function resolveQmdIndexName(indexName) {
+  const explicit = indexName?.trim();
+  if (explicit) {
+    return explicit;
+  }
+  const fromEnv = process.env[QMD_INDEX_ENV_VAR]?.trim();
+  return fromEnv || void 0;
+}
+function withQmdIndexArgs(args, indexName) {
+  if (args.includes("--index")) {
+    return [...args];
+  }
+  const resolvedIndexName = resolveQmdIndexName(indexName);
+  if (!resolvedIndexName) {
+    return [...args];
+  }
+  return ["--index", resolvedIndexName, ...args];
+}
+function tryParseJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function extractJsonPayload(raw) {
+  const start = raw.search(/[\[{]/);
+  if (start === -1) return null;
+  const end = Math.max(raw.lastIndexOf("]"), raw.lastIndexOf("}"));
+  if (end <= start) return null;
+  return raw.slice(start, end + 1);
+}
+function stripQmdNoise(raw) {
+  return raw.split("\n").filter((line) => {
+    const t = line.trim();
+    if (!t) return true;
+    if (t.startsWith("[node-llama-cpp]")) return false;
+    if (t.startsWith("Expanding query")) return false;
+    if (t.startsWith("Searching ") && t.endsWith("queries...")) return false;
+    if (/^[├└─│]/.test(t)) return false;
+    return true;
+  }).join("\n");
+}
+function parseQmdOutput(raw) {
+  const trimmed = stripQmdNoise(raw).trim();
+  if (!trimmed) return [];
+  const direct = tryParseJson(trimmed);
+  const extracted = direct ? null : extractJsonPayload(trimmed);
+  const parsed = direct ?? (extracted ? tryParseJson(extracted) : null);
+  if (!parsed) {
+    throw new Error("qmd returned non-JSON output. Ensure qmd supports --json.");
+  }
+  if (Array.isArray(parsed)) {
+    return parsed;
+  }
+  if (parsed && typeof parsed === "object") {
+    const candidate = parsed.results ?? parsed.items ?? parsed.data;
+    if (Array.isArray(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error("qmd returned an unexpected JSON shape.");
+}
+function ensureQmdAvailable() {
+  if (!hasQmd()) {
+    throw new QmdUnavailableError();
+  }
+}
+function execQmd(args, indexName) {
+  ensureQmdAvailable();
+  const finalArgs = withQmdIndexArgs(ensureJsonArgs(args), indexName);
+  try {
+    const result = (0, import_child_process.execFileSync)("qmd", finalArgs, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB
+    });
+    return parseQmdOutput(result);
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      throw new QmdUnavailableError();
+    }
+    const output = [err?.stdout, err?.stderr].filter(Boolean).join("\n");
+    if (output) {
+      try {
+        return parseQmdOutput(output);
+      } catch {
+      }
+    }
+    const message = err?.message ? `qmd failed: ${err.message}` : "qmd failed";
+    throw new Error(message);
+  }
+}
+function hasQmd() {
+  const result = (0, import_child_process.spawnSync)("qmd", ["--version"], { stdio: "ignore" });
+  return !result.error;
+}
+function qmdUpdate(collection, indexName) {
+  ensureQmdAvailable();
+  const args = ["update"];
+  if (collection) {
+    args.push("-c", collection);
+  }
+  (0, import_child_process.execFileSync)("qmd", withQmdIndexArgs(args, indexName), { stdio: "inherit" });
+}
+function qmdEmbed(collection, indexName) {
+  ensureQmdAvailable();
+  const args = ["embed"];
+  if (collection) {
+    args.push("-c", collection);
+  }
+  (0, import_child_process.execFileSync)("qmd", withQmdIndexArgs(args, indexName), { stdio: "inherit" });
+}
+function sentenceChunk(text, maxChars = 600, overlapSentences = 1) {
+  const sentences = text.split(/(?<=[.!?])\s+|\n{2,}/).map((s) => s.trim()).filter(Boolean);
+  if (sentences.length === 0) return text.trim() ? [text] : [];
+  const chunks = [];
+  let i = 0;
+  while (i < sentences.length) {
+    const chunkSents = [];
+    let chunkLen = 0;
+    let j = i;
+    while (j < sentences.length && chunkLen + sentences[j].length < maxChars) {
+      chunkSents.push(sentences[j]);
+      chunkLen += sentences[j].length + 1;
+      j++;
+    }
+    if (chunkSents.length === 0) {
+      chunkSents.push(sentences[j].slice(0, maxChars));
+      j++;
+    }
+    chunks.push(chunkSents.join(" "));
+    i = Math.max(j - overlapSentences, i + 1);
+  }
+  return chunks;
+}
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "what",
+  "when",
+  "where",
+  "which",
+  "that",
+  "this",
+  "have",
+  "from",
+  "with",
+  "they",
+  "been",
+  "were",
+  "will",
+  "about",
+  "would",
+  "could",
+  "should",
+  "their",
+  "there",
+  "does",
+  "your",
+  "more",
+  "some",
+  "than",
+  "into",
+  "also",
+  "just",
+  "very",
+  "much",
+  "most",
+  "many",
+  "only",
+  "other",
+  "each",
+  "every",
+  "after",
+  "before",
+  "did",
+  "the",
+  "and",
+  "for",
+  "are",
+  "was",
+  "not",
+  "but",
+  "can",
+  "had",
+  "has",
+  "how",
+  "who",
+  "why",
+  "its",
+  "you",
+  "my",
+  "me",
+  "is",
+  "it",
+  "do",
+  "so",
+  "if",
+  "or",
+  "an",
+  "on",
+  "at",
+  "by",
+  "no",
+  "up",
+  "to",
+  "in",
+  "of",
+  "am",
+  "be"
+]);
+function tokenize(text) {
+  return text.toLowerCase().split(/\s+/).map((w) => w.replace(/^[?.,!"'\-():;[\]{}*]+|[?.,!"'\-():;[\]{}*]+$/g, "")).filter((w) => w.length > 1);
+}
+function queryTerms(query) {
+  return tokenize(query).filter((w) => !STOPWORDS.has(w));
+}
+function bm25RankChunks(chunks, terms, max = 5) {
+  if (chunks.length === 0) return [];
+  const termSet = new Set(terms);
+  const scored = chunks.map((text, idx) => {
+    const words = new Set(tokenize(text));
+    let overlap = 0;
+    for (const t of termSet) if (words.has(t)) overlap++;
+    return { text, score: overlap, idx };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  seen.add(0);
+  result.push({ text: chunks[0], score: scored.find((s) => s.idx === 0)?.score ?? 0 });
+  for (const s of scored) {
+    if (result.length >= max) break;
+    if (!seen.has(s.idx) && s.score > 0) {
+      seen.add(s.idx);
+      result.push({ text: s.text, score: s.score });
+    }
+  }
+  return result;
+}
+var MONTH_NAMES = {
+  january: 1,
+  february: 2,
+  march: 3,
+  april: 4,
+  may: 5,
+  june: 6,
+  july: 7,
+  august: 8,
+  september: 9,
+  october: 10,
+  november: 11,
+  december: 12,
+  jan: 1,
+  feb: 2,
+  mar: 3,
+  apr: 4,
+  jun: 6,
+  jul: 7,
+  aug: 8,
+  sep: 9,
+  sept: 9,
+  oct: 10,
+  nov: 11,
+  dec: 12
+};
+var MONTH_RE_PART = Object.keys(MONTH_NAMES).join("|");
+var DATE_ISO_RE = /\b(\d{4})[/-](\d{1,2})[/-](\d{1,2})\b/g;
+var DATE_US_RE = /\b(\d{1,2})\/(\d{1,2})\/(\d{4})\b/g;
+var DATE_MONTH_DAY_YEAR_RE = new RegExp(
+  `\\b(${MONTH_RE_PART})\\s+(\\d{1,2})(?:st|nd|rd|th)?,?\\s*(\\d{4})\\b`,
+  "gi"
+);
+var DATE_DAY_MONTH_YEAR_RE = new RegExp(
+  `\\b(\\d{1,2})(?:st|nd|rd|th)?\\s+(${MONTH_RE_PART}),?\\s*(\\d{4})\\b`,
+  "gi"
+);
+var DATE_MONTH_DAY_RE = new RegExp(
+  `\\b(${MONTH_RE_PART})\\s+(\\d{1,2})(?:st|nd|rd|th)?\\b`,
+  "gi"
+);
+var RELATIVE_AGO_RE = /\b(\d+)\s+(days?|weeks?|months?|years?)\s+ago\b/gi;
+var RELATIVE_IN_RE = /\bin\s+(\d+)\s+(days?|weeks?|months?|years?)\b/gi;
+var DURATION_RE = /(?:for|took|spent|lasted|about|approximately|around)\s+(\d+)\s+(days?|weeks?|months?|years?|hours?|minutes?)/gi;
+function tryParseISODate(y, m, d) {
+  const dt = new Date(Date.UTC(y, m - 1, d));
+  if (dt.getUTCFullYear() === y && dt.getUTCMonth() === m - 1 && dt.getUTCDate() === d) return dt;
+  return null;
+}
+function unitToDays(n, unit) {
+  const u = unit.toLowerCase().replace(/s$/, "");
+  switch (u) {
+    case "day":
+      return n;
+    case "week":
+      return n * 7;
+    case "month":
+      return n * 30;
+    case "year":
+      return n * 365;
+    default:
+      return null;
+  }
+}
+function contextSnippet(text, start, end, maxLen = 150) {
+  const s = Math.max(0, start - Math.floor(maxLen / 2));
+  const e = Math.min(text.length, end + Math.floor(maxLen / 2));
+  return text.slice(s, e).replace(/\n/g, " ").trim();
+}
+function isoStr(d) {
+  const yy = d.getUTCFullYear();
+  const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
+  const dd = String(d.getUTCDate()).padStart(2, "0");
+  return `${yy}-${mm}-${dd}`;
+}
+function extractDates(text, sessionDateStr) {
+  const results = [];
+  const sessionDate = sessionDateStr ? new Date(sessionDateStr) : null;
+  const seen = /* @__PURE__ */ new Set();
+  function push(date, ctx, docId = "") {
+    const key = `${date}|${ctx.slice(0, 60)}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    results.push({ date, context: ctx, documentId: docId });
+  }
+  for (const m of text.matchAll(DATE_ISO_RE)) {
+    const dt = tryParseISODate(+m[1], +m[2], +m[3]);
+    if (dt) push(isoStr(dt), contextSnippet(text, m.index, m.index + m[0].length));
+  }
+  for (const m of text.matchAll(DATE_US_RE)) {
+    const dt = tryParseISODate(+m[3], +m[1], +m[2]);
+    if (dt) push(isoStr(dt), contextSnippet(text, m.index, m.index + m[0].length));
+  }
+  for (const m of text.matchAll(DATE_MONTH_DAY_YEAR_RE)) {
+    const mon = MONTH_NAMES[m[1].toLowerCase()];
+    if (mon) {
+      const dt = tryParseISODate(+m[3], mon, +m[2]);
+      if (dt) push(isoStr(dt), contextSnippet(text, m.index, m.index + m[0].length));
+    }
+  }
+  for (const m of text.matchAll(DATE_DAY_MONTH_YEAR_RE)) {
+    const mon = MONTH_NAMES[m[2].toLowerCase()];
+    if (mon) {
+      const dt = tryParseISODate(+m[3], mon, +m[1]);
+      if (dt) push(isoStr(dt), contextSnippet(text, m.index, m.index + m[0].length));
+    }
+  }
+  if (sessionDate) {
+    for (const m of text.matchAll(DATE_MONTH_DAY_RE)) {
+      const mon = MONTH_NAMES[m[1].toLowerCase()];
+      if (mon) {
+        const dt = tryParseISODate(sessionDate.getFullYear(), mon, +m[2]);
+        if (dt) push(isoStr(dt), contextSnippet(text, m.index, m.index + m[0].length));
+      }
+    }
+  }
+  if (sessionDate) {
+    for (const m of text.matchAll(RELATIVE_AGO_RE)) {
+      const days = unitToDays(+m[1], m[2]);
+      if (days !== null) {
+        const dt = new Date(sessionDate.getTime() - days * 864e5);
+        push(isoStr(dt), contextSnippet(text, m.index, m.index + m[0].length));
+      }
+    }
+    for (const m of text.matchAll(RELATIVE_IN_RE)) {
+      const days = unitToDays(+m[1], m[2]);
+      if (days !== null) {
+        const dt = new Date(sessionDate.getTime() + days * 864e5);
+        push(isoStr(dt), contextSnippet(text, m.index, m.index + m[0].length));
+      }
+    }
+  }
+  for (const m of text.matchAll(DURATION_RE)) {
+    push(`duration:${m[1]} ${m[2]}`, contextSnippet(text, m.index, m.index + m[0].length));
+  }
+  return results;
+}
+var PREF_PATTERNS = [
+  // "I use/prefer/like/love/enjoy X"
+  /\bi\s+(?:use|prefer|like|love|enjoy|favor|chose|switched to|started using|always use|usually use)\s+(.{3,60}?)(?:[.,;!?\n]|$)/gi,
+  // "my favorite X is Y"
+  /\bmy\s+(?:favorite|preferred|go-to|usual)\s+\w+\s+(?:is|are|was)\s+(.{3,60}?)(?:[.,;!?\n]|$)/gi,
+  // "I'm a big fan of X"
+  /\bi(?:'m| am)\s+(?:a )?(?:big |huge )?fan of\s+(.{3,60}?)(?:[.,;!?\n]|$)/gi,
+  // "I switched from X to Y"
+  /\bi\s+switched\s+from\s+(.{3,40}?)\s+to\s+(.{3,40}?)(?:[.,;!?\n]|$)/gi
+];
+function extractPreferences(text, documentId = "") {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of PREF_PATTERNS) {
+    for (const m of text.matchAll(pattern)) {
+      const value = (m[1] || "").trim();
+      if (!value || value.length < 3) continue;
+      const key = value.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const ctx = contextSnippet(text, m.index, m.index + m[0].length, 200);
+      let category = "general";
+      if (/tool|software|app|editor|ide|framework|library|language/i.test(ctx)) category = "tool";
+      else if (/hobby|sport|exercise|game|play/i.test(ctx)) category = "hobby";
+      else if (/brand|product|model|device|hardware/i.test(ctx)) category = "brand";
+      else if (/food|drink|restaurant|cuisine|recipe/i.test(ctx)) category = "food";
+      else if (/music|movie|show|book|podcast|artist|band/i.test(ctx)) category = "entertainment";
+      results.push({ category, value, documentId, context: ctx });
+    }
+  }
+  return results;
+}
+var PREFERENCE_Q_RE = /(?:can you (?:recommend|suggest)|any (?:tips|advice|suggestions|recommendations)|what .*(?:recommend|suggest)|what should i|where should i|which .* should i|please (?:recommend|suggest)|based on .* (?:interest|preference|taste)|personalized|tailored to (?:my|me))/i;
+var TEMPORAL_Q_RE = /(?:how many (?:days|weeks|months|years|hours|minutes) (?:passed|did|have|ago|between|since|in total|took)|how long (?:did|was|were|have|has|does)|how long ago|what (?:is the )?order|in order|which .* (?:first|last|earlier|later|before|after|most recent|oldest|newest)|chronological|(?:earlier|later|sooner|newer|older) than)/i;
+var AGGREGATION_Q_RE = /(?:how many|how much|total|all the|count|list all|every|what are all|name all)/i;
+function classifyQuestion(q) {
+  if (PREFERENCE_Q_RE.test(q)) return "preference";
+  if (TEMPORAL_Q_RE.test(q)) return "temporal";
+  if (!TEMPORAL_Q_RE.test(q) && AGGREGATION_Q_RE.test(q)) return "aggregation";
+  return "default";
+}
+var SearchEngine = class {
+  documents = /* @__PURE__ */ new Map();
+  collection = "clawvault";
+  vaultPath = "";
+  collectionRoot = "";
+  qmdIndexName;
+  /** v2.7 — Per-document date index built at ingest time */
+  dateIndex = /* @__PURE__ */ new Map();
+  /** v2.7 — Per-document preference index built at ingest time */
+  preferenceIndex = /* @__PURE__ */ new Map();
+  /** v2.7 — Per-document chunk cache for BM25 pre-filtering */
+  chunkCache = /* @__PURE__ */ new Map();
+  /**
+   * Set the collection name (usually vault name)
+   */
+  setCollection(name) {
+    this.collection = name;
+  }
+  /**
+   * Set the vault path for file resolution
+   */
+  setVaultPath(vaultPath) {
+    this.vaultPath = vaultPath;
+  }
+  /**
+   * Set the collection root for qmd:// URI resolution
+   */
+  setCollectionRoot(root) {
+    this.collectionRoot = path.resolve(root);
+  }
+  /**
+   * Set qmd index name (defaults to qmd global default when omitted)
+   */
+  setIndexName(indexName) {
+    this.qmdIndexName = indexName;
+  }
+  /**
+   * Add or update a document in the local cache.
+   * v2.7: also extracts dates, preferences, and chunks at ingest time.
+   * Note: qmd indexing happens via qmd update command
+   */
+  addDocument(doc) {
+    this.documents.set(doc.id, doc);
+    if (doc.content) {
+      const sessionDate = doc.modified ? isoStr(doc.modified) : void 0;
+      const dates = extractDates(doc.content, sessionDate);
+      for (const d of dates) d.documentId = doc.id;
+      if (dates.length > 0) this.dateIndex.set(doc.id, dates);
+      const prefs = extractPreferences(doc.content, doc.id);
+      if (prefs.length > 0) this.preferenceIndex.set(doc.id, prefs);
+      const chunks = sentenceChunk(doc.content, 600, 1);
+      if (chunks.length > 0) this.chunkCache.set(doc.id, chunks);
+    }
+  }
+  /**
+   * Remove a document from the local cache
+   */
+  removeDocument(id) {
+    this.documents.delete(id);
+    this.dateIndex.delete(id);
+    this.preferenceIndex.delete(id);
+    this.chunkCache.delete(id);
+  }
+  /**
+   * No-op for qmd - indexing is managed externally
+   */
+  rebuildIDF() {
+  }
+  /**
+   * BM25 search via qmd
+   */
+  search(query, options = {}) {
+    return this.runQmdQuery("search", query, options);
+  }
+  /**
+   * Vector/semantic search via qmd vsearch
+   */
+  vsearch(query, options = {}) {
+    return this.runQmdQuery("vsearch", query, options);
+  }
+  /**
+   * Combined search with query expansion (qmd query command)
+   */
+  query(query, options = {}) {
+    return this.runQmdQuery("query", query, options);
+  }
+  runQmdQuery(command, query, options) {
+    const {
+      limit = 10,
+      minScore = 0,
+      category,
+      tags,
+      fullContent = false,
+      temporalBoost = false,
+      relevanceThreshold,
+      thresholdMaxResults = 40
+    } = options;
+    if (!query.trim()) return [];
+    const fetchLimit = relevanceThreshold !== void 0 ? thresholdMaxResults * 2 : limit * 2;
+    const args = [
+      command,
+      query,
+      "-n",
+      String(fetchLimit),
+      "--json"
+    ];
+    if (this.collection) {
+      args.push("-c", this.collection);
+    }
+    const qmdResults = execQmd(args, this.qmdIndexName);
+    const effectiveLimit = relevanceThreshold !== void 0 ? thresholdMaxResults : limit;
+    const results = this.convertResults(qmdResults, {
+      limit: effectiveLimit,
+      minScore: relevanceThreshold !== void 0 ? relevanceThreshold : minScore,
+      category,
+      tags,
+      fullContent,
+      temporalBoost
+    });
+    return results;
+  }
+  // -------------------------------------------------------------------------
+  // v2.7 — New public APIs
+  // -------------------------------------------------------------------------
+  /**
+   * v2.7 — Chunk-level BM25 pre-filtered search. Ranks chunks within each
+   * document by keyword relevance before semantic ranking, so relevant
+   * content deep in long documents isn't missed.
+   *
+   * Returns results with snippets from the best-matching chunks.
+   */
+  chunkPrefilterSearch(query, options = {}) {
+    const terms = queryTerms(query);
+    const results = this.runQmdQuery("query", query, options);
+    for (const r of results) {
+      const chunks = this.chunkCache.get(r.document.id);
+      if (chunks && chunks.length > 0 && terms.length > 0) {
+        const ranked = bm25RankChunks(chunks, terms, 3);
+        if (ranked.length > 0 && ranked[0].score > 0) {
+          r.snippet = ranked.map((c) => c.text).join("\n...\n").slice(0, 600);
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * v2.7 — Exhaustive threshold-based search for aggregation queries.
+   * Keeps pulling results until relevance drops below threshold.
+   */
+  exhaustiveSearch(query, threshold = 0.01, maxResults = 40) {
+    return this.runQmdQuery("query", query, {
+      relevanceThreshold: threshold,
+      thresholdMaxResults: maxResults,
+      fullContent: false
+    });
+  }
+  /**
+   * v2.7 — Get all extracted dates, optionally filtered by document ids.
+   */
+  getDates(documentIds) {
+    const all = [];
+    const iter = documentIds ? documentIds.map((id) => [id, this.dateIndex.get(id)]).filter(([, v]) => v) : this.dateIndex.entries();
+    for (const [, dates] of iter) {
+      if (dates) all.push(...dates);
+    }
+    return all;
+  }
+  /**
+   * v2.7 — Get all extracted preferences, optionally filtered by document ids.
+   */
+  getPreferences(documentIds) {
+    const all = [];
+    const iter = documentIds ? documentIds.map((id) => [id, this.preferenceIndex.get(id)]).filter(([, v]) => v) : this.preferenceIndex.entries();
+    for (const [, prefs] of iter) {
+      if (prefs) all.push(...prefs);
+    }
+    return all;
+  }
+  /**
+   * v2.7 — Search with automatic strategy selection based on question type.
+   * Classifies the query and routes to the appropriate pipeline.
+   */
+  smartQuery(query, options = {}) {
+    const qtype = classifyQuestion(query);
+    switch (qtype) {
+      case "aggregation":
+        return this.exhaustiveSearch(query, 0.01, options.thresholdMaxResults ?? 40);
+      case "preference":
+      case "temporal":
+      default:
+        return this.chunkPrefilterSearch(query, { ...options, limit: options.limit ?? 10 });
+    }
+  }
+  /**
+   * Convert qmd results to ClawVault SearchResult format
+   */
+  convertResults(qmdResults, options) {
+    const { limit = 10, minScore = 0, category, tags, fullContent = false, temporalBoost = false } = options;
+    const results = [];
+    const maxScore = qmdResults[0]?.score || 1;
+    for (const qr of qmdResults) {
+      const filePath = this.qmdUriToPath(qr.file);
+      const relativePath = this.vaultPath ? path.relative(this.vaultPath, filePath) : filePath;
+      const normalizedRelativePath = relativePath.replace(/\\/g, "/");
+      if (normalizedRelativePath.startsWith("ledger/archive/") || normalizedRelativePath.includes("/ledger/archive/")) {
+        continue;
+      }
+      const docId = normalizedRelativePath.replace(/\.md$/, "");
+      let doc = this.documents.get(docId) ?? this.documents.get(docId.split("/").join(path.sep));
+      const modifiedAt = this.resolveModifiedAt(doc, filePath);
+      const parts = normalizedRelativePath.split("/");
+      const docCategory = parts.length > 1 ? parts[0] : "root";
+      if (category && docCategory !== category) continue;
+      if (tags && tags.length > 0 && doc) {
+        const docTags = new Set(doc.tags);
+        if (!tags.some((t) => docTags.has(t))) continue;
+      }
+      const normalizedScore = maxScore > 0 ? qr.score / maxScore : 0;
+      const finalScore = temporalBoost ? normalizedScore * this.getRecencyFactor(modifiedAt) : normalizedScore;
+      if (finalScore < minScore) continue;
+      if (!doc) {
+        doc = {
+          id: docId,
+          path: filePath,
+          category: docCategory,
+          title: qr.title || path.basename(relativePath, ".md"),
+          content: "",
+          // Content loaded separately if needed
+          frontmatter: {},
+          links: [],
+          tags: [],
+          modified: modifiedAt
+        };
+      }
+      results.push({
+        document: fullContent ? doc : { ...doc, content: "" },
+        score: finalScore,
+        snippet: this.stripSupersededFromSnippet(this.cleanSnippet(qr.snippet)),
+        matchedTerms: []
+        // qmd doesn't provide this
+      });
+    }
+    return results.sort((a, b) => b.score - a.score).slice(0, limit);
+  }
+  resolveModifiedAt(doc, filePath) {
+    if (doc) return doc.modified;
+    try {
+      return fs.statSync(filePath).mtime;
+    } catch {
+      return /* @__PURE__ */ new Date(0);
+    }
+  }
+  getRecencyFactor(modifiedAt) {
+    const ageMs = Math.max(0, Date.now() - modifiedAt.getTime());
+    const ageDays = ageMs / (24 * 60 * 60 * 1e3);
+    if (ageDays < 1) return 1;
+    if (ageDays <= 7) return 0.9;
+    return 0.7;
+  }
+  /**
+   * Convert qmd:// URI to file path
+   */
+  qmdUriToPath(uri) {
+    if (uri.startsWith("qmd://")) {
+      const withoutScheme = uri.slice(6);
+      const slashIndex = withoutScheme.indexOf("/");
+      if (slashIndex > -1) {
+        const relativePath = withoutScheme.slice(slashIndex + 1);
+        const root = this.collectionRoot || this.vaultPath;
+        if (root) {
+          return path.join(root, relativePath);
+        }
+        return relativePath;
+      }
+    }
+    return uri;
+  }
+  /**
+   * v2.8 — Filter superseded observation lines from snippet text.
+   * Ensures search results prefer the latest version of knowledge.
+   */
+  stripSupersededFromSnippet(snippet) {
+    if (!snippet) return snippet;
+    return snippet.split("\n").filter((line) => !isSuperseded(line)).join("\n");
+  }
+  /**
+   * Clean up qmd snippet format
+   */
+  cleanSnippet(snippet) {
+    if (!snippet) return "";
+    return snippet.replace(/@@ [-+]?\d+,?\d* @@ \([^)]+\)/g, "").trim().split("\n").slice(0, 3).join("\n").slice(0, 300);
+  }
+  /**
+   * Get all cached documents
+   */
+  getAllDocuments() {
+    return [...this.documents.values()];
+  }
+  /**
+   * Get document count
+   */
+  get size() {
+    return this.documents.size;
+  }
+  /**
+   * Clear the local document cache and all v2.7 indices
+   */
+  clear() {
+    this.documents.clear();
+    this.dateIndex.clear();
+    this.preferenceIndex.clear();
+    this.chunkCache.clear();
+  }
+  /**
+   * Export documents for persistence
+   */
+  export() {
+    return {
+      documents: [...this.documents.values()]
+    };
+  }
+  /**
+   * Import from persisted data
+   */
+  import(data) {
+    this.clear();
+    for (const doc of data.documents) {
+      this.addDocument(doc);
+    }
+  }
+};
+function extractWikiLinks(content) {
+  const matches = content.match(/\[\[([^\]]+)\]\]/g) || [];
+  return matches.map((m) => m.slice(2, -2).toLowerCase());
+}
+function extractTags(content) {
+  const matches = content.match(/#[\w-]+/g) || [];
+  return [...new Set(matches.map((m) => m.slice(1).toLowerCase()))];
+}
+
+// src/lib/memory-graph.ts
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+var import_glob = require("glob");
+var MEMORY_GRAPH_SCHEMA_VERSION = 1;
+var GRAPH_INDEX_RELATIVE_PATH = path2.join(".clawvault", "graph-index.json");
+var WIKI_LINK_RE = /\[\[([^\]]+)\]\]/g;
+var HASH_TAG_RE = /(^|\s)#([\w-]+)/g;
+var FRONTMATTER_RELATION_FIELDS = [
+  "related",
+  "depends_on",
+  "dependsOn",
+  "blocked_by",
+  "blocks",
+  "owner",
+  "project",
+  "people",
+  "links"
+];
+function normalizeRelativePath(value) {
+  return value.split(path2.sep).join("/").replace(/^\.\//, "").replace(/^\/+/, "");
+}
+function toNoteKey(relativePath) {
+  const normalized = normalizeRelativePath(relativePath);
+  return normalized.toLowerCase().endsWith(".md") ? normalized.slice(0, -3) : normalized;
+}
+function toNoteNodeId(noteKey) {
+  return `note:${noteKey}`;
+}
+function toTagNodeId(tag) {
+  return `tag:${tag.toLowerCase()}`;
+}
+function normalizeUnresolvedKey(raw) {
+  const normalized = raw.trim().toLowerCase().replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "").replace(/\.md$/, "").replace(/[^a-z0-9/_-]+/g, "-").replace(/\/+/g, "/").replace(/-+/g, "-").replace(/^[-/]+|[-/]+$/g, "");
+  return normalized || "unknown";
+}
+function toUnresolvedNodeId(raw) {
+  return `unresolved:${normalizeUnresolvedKey(raw)}`;
+}
+function titleFromNoteKey(noteKey) {
+  const basename4 = noteKey.split("/").pop() ?? noteKey;
+  return basename4.replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim().replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function inferNodeType(relativePath, frontmatter) {
+  const normalized = normalizeRelativePath(relativePath).toLowerCase();
+  const category = normalized.split("/")[0] ?? "note";
+  const explicitType = typeof frontmatter.type === "string" ? frontmatter.type.toLowerCase() : "";
+  if (category.includes("daily") || explicitType === "daily") return "daily";
+  if (category === "observations" || explicitType === "observation") return "observation";
+  if (category === "handoffs" || explicitType === "handoff") return "handoff";
+  if (category === "decisions" || explicitType === "decision") return "decision";
+  if (category === "lessons" || explicitType === "lesson") return "lesson";
+  if (category === "projects" || explicitType === "project") return "project";
+  if (category === "people" || explicitType === "person") return "person";
+  if (category === "commitments" || explicitType === "commitment") return "commitment";
+  return "note";
+}
+function ensureClawvaultDir(vaultPath) {
+  const dirPath = path2.join(vaultPath, ".clawvault");
+  if (!fs2.existsSync(dirPath)) {
+    fs2.mkdirSync(dirPath, { recursive: true });
+  }
+  return dirPath;
+}
+function getGraphIndexPath(vaultPath) {
+  return path2.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();
+}
+function collectTags(frontmatter, markdownContent) {
+  const tags = /* @__PURE__ */ new Set();
+  const fmTags = frontmatter.tags;
+  if (Array.isArray(fmTags)) {
+    for (const tag of fmTags) {
+      if (typeof tag === "string" && tag.trim()) tags.add(tag.trim().toLowerCase());
+    }
+  } else if (typeof fmTags === "string") {
+    for (const token of fmTags.split(",")) {
+      const normalized = token.trim().toLowerCase();
+      if (normalized) tags.add(normalized);
+    }
+  }
+  const markdownMatches = markdownContent.matchAll(HASH_TAG_RE);
+  for (const match of markdownMatches) {
+    const tag = match[2]?.trim().toLowerCase();
+    if (tag) tags.add(tag);
+  }
+  return [...tags].sort((a, b) => a.localeCompare(b));
+}
+function extractWikiTargets(markdownContent) {
+  const targets = /* @__PURE__ */ new Set();
+  for (const match of markdownContent.matchAll(WIKI_LINK_RE)) {
+    const candidate = match[1];
+    if (!candidate) continue;
+    const normalized = normalizeWikiTarget(candidate);
+    if (normalized) targets.add(normalized);
+  }
+  return [...targets];
+}
+function toStringArray(value) {
+  if (typeof value === "string") {
+    return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((entry) => typeof entry === "string" ? entry.split(",") : []).map((entry) => entry.trim()).filter(Boolean);
+  }
+  return [];
+}
+function extractFrontmatterRelations(frontmatter) {
+  const relations = [];
+  for (const field of FRONTMATTER_RELATION_FIELDS) {
+    const raw = frontmatter[field];
+    for (const value of toStringArray(raw)) {
+      const normalized = normalizeWikiTarget(value);
+      if (normalized) relations.push({ field, target: normalized });
+    }
+  }
+  return relations;
+}
+function buildNoteRegistry(relativePaths) {
+  const byLowerPath = /* @__PURE__ */ new Map();
+  const byLowerBasename = /* @__PURE__ */ new Map();
+  for (const relativePath of relativePaths) {
+    const noteKey = toNoteKey(relativePath);
+    const lowerKey = noteKey.toLowerCase();
+    if (!byLowerPath.has(lowerKey)) {
+      byLowerPath.set(lowerKey, noteKey);
+    }
+    const base = noteKey.split("/").pop() ?? noteKey;
+    const lowerBase = base.toLowerCase();
+    const existing = byLowerBasename.get(lowerBase) ?? [];
+    existing.push(noteKey);
+    byLowerBasename.set(lowerBase, existing);
+  }
+  return { byLowerPath, byLowerBasename };
+}
+function resolveTargetNodeId(rawTarget, registry) {
+  const normalized = normalizeWikiTarget(rawTarget);
+  if (!normalized) {
+    return toUnresolvedNodeId(rawTarget);
+  }
+  const lowerTarget = normalized.toLowerCase();
+  const direct = registry.byLowerPath.get(lowerTarget);
+  if (direct) {
+    return toNoteNodeId(direct);
+  }
+  if (!normalized.includes("/")) {
+    const basenameMatches = registry.byLowerBasename.get(lowerTarget) ?? [];
+    if (basenameMatches.length === 1) {
+      return toNoteNodeId(basenameMatches[0]);
+    }
+  }
+  return toUnresolvedNodeId(normalized);
+}
+function createEdgeId(type, source, target, label) {
+  const suffix = label ? `:${label}` : "";
+  return `${type}:${source}->${target}${suffix}`;
+}
+function buildFragmentNode(id, title, type, category, pathValue, tags, missing, modifiedAt) {
+  return {
+    id,
+    title,
+    type,
+    category,
+    path: pathValue,
+    tags,
+    missing,
+    degree: 0,
+    modifiedAt
+  };
+}
+function parseFileFragment(vaultPath, relativePath, mtimeMs, registry) {
+  const absolutePath = path2.join(vaultPath, relativePath);
+  const raw = fs2.readFileSync(absolutePath, "utf-8");
+  const parsed = (0, import_gray_matter.default)(raw);
+  const frontmatter = parsed.data ?? {};
+  const noteKey = toNoteKey(relativePath);
+  const noteNodeId = toNoteNodeId(noteKey);
+  const noteType = inferNodeType(relativePath, frontmatter);
+  const tags = collectTags(frontmatter, parsed.content);
+  const modifiedAt = new Date(mtimeMs).toISOString();
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  nodes.set(
+    noteNodeId,
+    buildFragmentNode(
+      noteNodeId,
+      typeof frontmatter.title === "string" && frontmatter.title.trim() ? frontmatter.title.trim() : titleFromNoteKey(noteKey),
+      noteType,
+      noteType,
+      normalizeRelativePath(relativePath),
+      tags,
+      false,
+      modifiedAt
+    )
+  );
+  for (const tag of tags) {
+    const tagNodeId = toTagNodeId(tag);
+    if (!nodes.has(tagNodeId)) {
+      nodes.set(tagNodeId, buildFragmentNode(tagNodeId, `#${tag}`, "tag", "tag", null, [], false, null));
+    }
+    const edgeId = createEdgeId("tag", noteNodeId, tagNodeId);
+    edges.set(edgeId, {
+      id: edgeId,
+      source: noteNodeId,
+      target: tagNodeId,
+      type: "tag"
+    });
+  }
+  const wikiTargets = extractWikiTargets(parsed.content);
+  for (const target of wikiTargets) {
+    const targetNodeId = resolveTargetNodeId(target, registry);
+    if (targetNodeId.startsWith("unresolved:") && !nodes.has(targetNodeId)) {
+      nodes.set(
+        targetNodeId,
+        buildFragmentNode(targetNodeId, titleFromNoteKey(normalizeUnresolvedKey(target)), "unresolved", "unresolved", null, [], true, null)
+      );
+    }
+    const edgeId = createEdgeId("wiki_link", noteNodeId, targetNodeId);
+    edges.set(edgeId, {
+      id: edgeId,
+      source: noteNodeId,
+      target: targetNodeId,
+      type: "wiki_link"
+    });
+  }
+  for (const relation of extractFrontmatterRelations(frontmatter)) {
+    const targetNodeId = resolveTargetNodeId(relation.target, registry);
+    if (targetNodeId.startsWith("unresolved:") && !nodes.has(targetNodeId)) {
+      nodes.set(
+        targetNodeId,
+        buildFragmentNode(
+          targetNodeId,
+          titleFromNoteKey(normalizeUnresolvedKey(relation.target)),
+          "unresolved",
+          "unresolved",
+          null,
+          [],
+          true,
+          null
+        )
+      );
+    }
+    const edgeId = createEdgeId("frontmatter_relation", noteNodeId, targetNodeId, relation.field);
+    edges.set(edgeId, {
+      id: edgeId,
+      source: noteNodeId,
+      target: targetNodeId,
+      type: "frontmatter_relation",
+      label: relation.field
+    });
+  }
+  return {
+    relativePath: normalizeRelativePath(relativePath),
+    mtimeMs,
+    nodes: [...nodes.values()],
+    edges: [...edges.values()]
+  };
+}
+function combineFragments(fragments, generatedAt) {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  for (const fragment of Object.values(fragments)) {
+    for (const node of fragment.nodes) {
+      const existing = nodes.get(node.id);
+      if (!existing) {
+        nodes.set(node.id, { ...node, degree: 0 });
+      } else if (node.modifiedAt && (!existing.modifiedAt || node.modifiedAt > existing.modifiedAt)) {
+        nodes.set(node.id, { ...existing, ...node, degree: 0 });
+      }
+    }
+    for (const edge of fragment.edges) {
+      edges.set(edge.id, edge);
+    }
+  }
+  const degreeByNode = /* @__PURE__ */ new Map();
+  for (const edge of edges.values()) {
+    degreeByNode.set(edge.source, (degreeByNode.get(edge.source) ?? 0) + 1);
+    degreeByNode.set(edge.target, (degreeByNode.get(edge.target) ?? 0) + 1);
+  }
+  for (const node of nodes.values()) {
+    node.degree = degreeByNode.get(node.id) ?? 0;
+  }
+  const nodeTypeCounts = {};
+  for (const node of nodes.values()) {
+    nodeTypeCounts[node.type] = (nodeTypeCounts[node.type] ?? 0) + 1;
+  }
+  const edgeTypeCounts = {};
+  for (const edge of edges.values()) {
+    edgeTypeCounts[edge.type] = (edgeTypeCounts[edge.type] ?? 0) + 1;
+  }
+  const sortedNodes = [...nodes.values()].sort((a, b) => a.id.localeCompare(b.id));
+  const sortedEdges = [...edges.values()].sort((a, b) => a.id.localeCompare(b.id));
+  return {
+    schemaVersion: MEMORY_GRAPH_SCHEMA_VERSION,
+    nodes: sortedNodes,
+    edges: sortedEdges,
+    stats: {
+      generatedAt,
+      nodeCount: sortedNodes.length,
+      edgeCount: sortedEdges.length,
+      nodeTypeCounts,
+      edgeTypeCounts
+    }
+  };
+}
+function isValidIndex(index) {
+  if (!index || typeof index !== "object") return false;
+  const typed = 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(path2.resolve(vaultPath));
+  if (!fs2.existsSync(indexPath)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(fs2.readFileSync(indexPath, "utf-8"));
+    if (!isValidIndex(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function buildOrUpdateMemoryGraphIndex(vaultPathInput, options = {}) {
+  const vaultPath = path2.resolve(vaultPathInput);
+  ensureClawvaultDir(vaultPath);
+  const existing = options.forceFull ? null : loadMemoryGraphIndex(vaultPath);
+  const markdownFiles = await (0, import_glob.glob)("**/*.md", {
+    cwd: vaultPath,
+    ignore: ["**/node_modules/**", "**/.git/**", "**/.obsidian/**", "**/.trash/**", "**/ledger/archive/**"]
+  });
+  const normalizedFiles = markdownFiles.map(normalizeRelativePath).sort((a, b) => a.localeCompare(b));
+  const registry = buildNoteRegistry(normalizedFiles);
+  const nextFragments = {};
+  const existingFragments = existing?.files ?? {};
+  const currentFileSet = new Set(normalizedFiles);
+  for (const relativePath of normalizedFiles) {
+    const absolutePath = path2.join(vaultPath, relativePath);
+    const stat = fs2.statSync(absolutePath);
+    const existingFragment = existingFragments[relativePath];
+    if (!options.forceFull && existingFragment && existingFragment.mtimeMs === stat.mtimeMs) {
+      nextFragments[relativePath] = existingFragment;
+      continue;
+    }
+    nextFragments[relativePath] = parseFileFragment(vaultPath, relativePath, stat.mtimeMs, registry);
+  }
+  for (const [relativePath, fragment] of Object.entries(existingFragments)) {
+    if (!currentFileSet.has(relativePath)) {
+      continue;
+    }
+    if (!nextFragments[relativePath]) {
+      nextFragments[relativePath] = fragment;
+    }
+  }
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const graph = combineFragments(nextFragments, generatedAt);
+  const nextIndex = {
+    schemaVersion: MEMORY_GRAPH_SCHEMA_VERSION,
+    vaultPath,
+    generatedAt,
+    files: nextFragments,
+    graph
+  };
+  fs2.writeFileSync(getGraphIndexPath(vaultPath), JSON.stringify(nextIndex, null, 2));
+  return nextIndex;
+}
+
+// src/lib/vault.ts
+var import_meta = {};
+var CONFIG_FILE = ".clawvault.json";
+var INDEX_FILE = ".clawvault-index.json";
+var ClawVault = class {
+  config;
+  search;
+  initialized = false;
+  constructor(vaultPath) {
+    if (!hasQmd()) {
+      throw new QmdUnavailableError();
+    }
+    this.config = {
+      path: path3.resolve(vaultPath),
+      name: path3.basename(vaultPath),
+      categories: DEFAULT_CATEGORIES,
+      qmdCollection: void 0,
+      qmdRoot: void 0
+    };
+    this.search = new SearchEngine();
+    this.applyQmdConfig();
+  }
+  /**
+   * Initialize a new vault
+   */
+  async init(options = {}, initFlags) {
+    if (!hasQmd()) {
+      throw new QmdUnavailableError();
+    }
+    const vaultPath = this.config.path;
+    const flags = initFlags || {};
+    this.config = { ...this.config, ...options };
+    this.applyQmdConfig();
+    if (flags.skipTasks) {
+      this.config.categories = this.config.categories.filter(
+        (c) => !["tasks", "backlog"].includes(c)
+      );
+    }
+    if (!fs3.existsSync(vaultPath)) {
+      fs3.mkdirSync(vaultPath, { recursive: true });
+    }
+    for (const category of this.config.categories) {
+      const catPath = path3.join(vaultPath, category);
+      if (!fs3.existsSync(catPath)) {
+        fs3.mkdirSync(catPath, { recursive: true });
+      }
+    }
+    const ledgerDirs = ["ledger/raw", "ledger/observations", "ledger/reflections"];
+    for (const dir of ledgerDirs) {
+      const dirPath = path3.join(vaultPath, dir);
+      if (!fs3.existsSync(dirPath)) {
+        fs3.mkdirSync(dirPath, { recursive: true });
+      }
+    }
+    await this.createTemplates();
+    const readmePath = path3.join(vaultPath, "README.md");
+    if (!fs3.existsSync(readmePath)) {
+      fs3.writeFileSync(readmePath, this.generateReadme());
+    }
+    await this.createWelcomeNote();
+    const configPath = path3.join(vaultPath, CONFIG_FILE);
+    const meta = {
+      name: this.config.name,
+      version: "1.0.0",
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      categories: this.config.categories,
+      documentCount: 0,
+      qmdCollection: this.getQmdCollection(),
+      qmdRoot: this.getQmdRoot()
+    };
+    fs3.writeFileSync(configPath, JSON.stringify(meta, null, 2));
+    if (!flags.skipBases && this.config.categories.includes("tasks")) {
+      this.createBasesFiles();
+    }
+    if (!flags.skipGraph) {
+      await this.syncMemoryGraphIndex({ forceFull: true });
+    }
+    this.initialized = true;
+  }
+  createBasesFiles() {
+    const vaultPath = this.config.path;
+    const basesFiles = {
+      "all-tasks.base": [
+        "filters:",
+        "  and:",
+        '    - file.inFolder("tasks")',
+        '    - status != "done"',
+        "formulas:",
+        "  age: (now() - file.ctime).days",
+        '  status_icon: if(status == "blocked", "\u{1F534}", if(status == "in-progress", "\u{1F528}", if(status == "open", "\u26AA", "\u2705")))',
+        "views:",
+        "  - type: table",
+        "    name: All Active Tasks",
+        "    groupBy:",
+        "      property: status",
+        "      direction: ASC",
+        "    order:",
+        "      - formula.status_icon",
+        "      - file.name",
+        "      - status",
+        "      - owner",
+        "      - project",
+        "      - priority",
+        "      - blocked_by",
+        "      - formula.age",
+        "  - type: cards",
+        "    name: Task Board",
+        "    groupBy:",
+        "      property: status",
+        "      direction: ASC",
+        "    order:",
+        "      - file.name",
+        "      - owner",
+        "      - project",
+        "      - priority"
+      ].join("\n"),
+      "blocked.base": [
+        "filters:",
+        "  and:",
+        '    - file.inFolder("tasks")',
+        '    - status == "blocked"',
+        "formulas:",
+        "  days_blocked: (now() - file.ctime).days",
+        "views:",
+        "  - type: table",
+        "    name: Blocked Tasks",
+        "    order:",
+        "      - file.name",
+        "      - owner",
+        "      - project",
+        "      - blocked_by",
+        "      - formula.days_blocked",
+        "      - priority"
+      ].join("\n"),
+      "by-project.base": [
+        "filters:",
+        "  and:",
+        '    - file.inFolder("tasks")',
+        '    - status != "done"',
+        "formulas:",
+        '  status_icon: if(status == "blocked", "\u{1F534}", if(status == "in-progress", "\u{1F528}", "\u26AA"))',
+        "views:",
+        "  - type: table",
+        "    name: By Project",
+        "    groupBy:",
+        "      property: project",
+        "      direction: ASC",
+        "    order:",
+        "      - formula.status_icon",
+        "      - file.name",
+        "      - status",
+        "      - owner",
+        "      - priority"
+      ].join("\n"),
+      "backlog.base": [
+        "filters:",
+        "  and:",
+        '    - file.inFolder("backlog")',
+        "views:",
+        "  - type: table",
+        "    name: Backlog",
+        "    order:",
+        "      - file.name",
+        "      - source",
+        "      - project",
+        "      - file.ctime"
+      ].join("\n")
+    };
+    for (const [filename, content] of Object.entries(basesFiles)) {
+      const filePath = path3.join(vaultPath, filename);
+      if (!fs3.existsSync(filePath)) {
+        fs3.writeFileSync(filePath, content);
+      }
+    }
+  }
+  /**
+   * Load an existing vault
+   */
+  async load() {
+    if (!hasQmd()) {
+      throw new QmdUnavailableError();
+    }
+    const vaultPath = this.config.path;
+    const configPath = path3.join(vaultPath, CONFIG_FILE);
+    if (!fs3.existsSync(configPath)) {
+      throw new Error(`Not a ClawVault: ${vaultPath} (missing ${CONFIG_FILE})`);
+    }
+    const meta = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+    this.config.name = meta.name;
+    this.config.categories = meta.categories;
+    this.config.qmdCollection = meta.qmdCollection;
+    this.config.qmdRoot = meta.qmdRoot;
+    if (!meta.qmdCollection || !meta.qmdRoot) {
+      meta.qmdCollection = meta.qmdCollection || meta.name;
+      meta.qmdRoot = meta.qmdRoot || this.config.path;
+      fs3.writeFileSync(configPath, JSON.stringify(meta, null, 2));
+    }
+    this.applyQmdConfig(meta);
+    await this.reindex();
+    this.initialized = true;
+  }
+  /**
+   * Reindex all documents
+   */
+  async reindex() {
+    this.search.clear();
+    const files = await (0, import_glob2.glob)("**/*.md", {
+      cwd: this.config.path,
+      ignore: ["**/node_modules/**", "**/.*", "**/ledger/archive/**"]
+    });
+    for (const file of files) {
+      const doc = await this.loadDocument(file);
+      if (doc) {
+        this.search.addDocument(doc);
+      }
+    }
+    await this.saveIndex();
+    await this.syncMemoryGraphIndex();
+    return this.search.size;
+  }
+  /**
+   * Load a document from disk
+   */
+  async loadDocument(relativePath) {
+    try {
+      const fullPath = path3.join(this.config.path, relativePath);
+      const content = fs3.readFileSync(fullPath, "utf-8");
+      const { data: frontmatter, content: body } = (0, import_gray_matter2.default)(content);
+      const stats = fs3.statSync(fullPath);
+      const parts = relativePath.split(path3.sep);
+      const category = parts.length > 1 ? parts[0] : "root";
+      const filename = path3.basename(relativePath, ".md");
+      return {
+        id: relativePath.replace(/\.md$/, ""),
+        path: fullPath,
+        category,
+        title: frontmatter.title || filename,
+        content: body,
+        frontmatter,
+        links: extractWikiLinks(body),
+        tags: extractTags(body),
+        modified: stats.mtime
+      };
+    } catch (err) {
+      console.error(`Error loading ${relativePath}:`, err);
+      return null;
+    }
+  }
+  /**
+   * Store a new document
+   */
+  async store(options) {
+    const {
+      category,
+      title,
+      content,
+      frontmatter = {},
+      overwrite = false,
+      qmdUpdate: triggerUpdate = false,
+      qmdEmbed: triggerEmbed = false,
+      qmdIndexName
+    } = options;
+    const filename = this.slugify(title) + ".md";
+    const relativePath = path3.join(category, filename);
+    const fullPath = path3.join(this.config.path, relativePath);
+    if (fs3.existsSync(fullPath) && !overwrite) {
+      throw new Error(`Document already exists: ${relativePath}. Use overwrite: true to replace.`);
+    }
+    const categoryPath = path3.join(this.config.path, category);
+    if (!fs3.existsSync(categoryPath)) {
+      fs3.mkdirSync(categoryPath, { recursive: true });
+    }
+    const fm = {
+      title,
+      date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+      ...frontmatter
+    };
+    const fileContent = import_gray_matter2.default.stringify(content, fm);
+    fs3.writeFileSync(fullPath, fileContent);
+    const doc = await this.loadDocument(relativePath);
+    if (doc) {
+      this.search.addDocument(doc);
+      await this.saveIndex();
+      await this.syncMemoryGraphIndex();
+    }
+    if (triggerUpdate || triggerEmbed) {
+      qmdUpdate(this.getQmdCollection(), qmdIndexName);
+      if (triggerEmbed) {
+        qmdEmbed(this.getQmdCollection(), qmdIndexName);
+      }
+    }
+    return doc;
+  }
+  /**
+   * Quick store to inbox
+   */
+  async capture(note, title) {
+    const autoTitle = title || `note-${Date.now()}`;
+    return this.store({
+      category: "inbox",
+      title: autoTitle,
+      content: note
+    });
+  }
+  /**
+   * Search the vault (BM25 via qmd)
+   */
+  async find(query, options = {}) {
+    return this.search.search(query, options);
+  }
+  /**
+   * Semantic/vector search (via qmd vsearch)
+   */
+  async vsearch(query, options = {}) {
+    return this.search.vsearch(query, options);
+  }
+  /**
+   * Combined search with query expansion (via qmd query)
+   */
+  async query(query, options = {}) {
+    return this.search.query(query, options);
+  }
+  /**
+   * Get a document by ID or path
+   */
+  async get(idOrPath) {
+    const normalized = idOrPath.replace(/\.md$/, "");
+    const docs = this.search.getAllDocuments();
+    return docs.find((d) => d.id === normalized) || null;
+  }
+  /**
+   * List documents in a category
+   */
+  async list(category) {
+    const docs = this.search.getAllDocuments();
+    if (category) {
+      return docs.filter((d) => d.category === category);
+    }
+    return docs;
+  }
+  /**
+   * Sync vault to another location (for Obsidian on Windows, etc.)
+   */
+  async sync(options) {
+    const { target, deleteOrphans = false, dryRun = false } = options;
+    const result = {
+      copied: [],
+      deleted: [],
+      unchanged: [],
+      errors: []
+    };
+    const sourceFiles = await (0, import_glob2.glob)("**/*.md", {
+      cwd: this.config.path,
+      ignore: ["**/node_modules/**"]
+    });
+    if (!dryRun && !fs3.existsSync(target)) {
+      fs3.mkdirSync(target, { recursive: true });
+    }
+    for (const file of sourceFiles) {
+      const sourcePath = path3.join(this.config.path, file);
+      const targetPath = path3.join(target, file);
+      try {
+        const sourceStats = fs3.statSync(sourcePath);
+        let shouldCopy = true;
+        if (fs3.existsSync(targetPath)) {
+          const targetStats = fs3.statSync(targetPath);
+          if (sourceStats.mtime <= targetStats.mtime) {
+            result.unchanged.push(file);
+            shouldCopy = false;
+          }
+        }
+        if (shouldCopy) {
+          if (!dryRun) {
+            const targetDir = path3.dirname(targetPath);
+            if (!fs3.existsSync(targetDir)) {
+              fs3.mkdirSync(targetDir, { recursive: true });
+            }
+            fs3.copyFileSync(sourcePath, targetPath);
+          }
+          result.copied.push(file);
+        }
+      } catch (err) {
+        result.errors.push(`${file}: ${err}`);
+      }
+    }
+    if (deleteOrphans) {
+      const targetFiles = await (0, import_glob2.glob)("**/*.md", { cwd: target });
+      const sourceSet = new Set(sourceFiles);
+      for (const file of targetFiles) {
+        if (!sourceSet.has(file)) {
+          if (!dryRun) {
+            fs3.unlinkSync(path3.join(target, file));
+          }
+          result.deleted.push(file);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Get vault statistics
+   */
+  async stats() {
+    const docs = this.search.getAllDocuments();
+    const categories = {};
+    const allTags = /* @__PURE__ */ new Set();
+    let totalLinks = 0;
+    for (const doc of docs) {
+      categories[doc.category] = (categories[doc.category] || 0) + 1;
+      totalLinks += doc.links.length;
+      doc.tags.forEach((t) => allTags.add(t));
+    }
+    return {
+      documents: docs.length,
+      categories,
+      links: totalLinks,
+      tags: [...allTags].sort()
+    };
+  }
+  /**
+   * Get all categories
+   */
+  getCategories() {
+    return this.config.categories;
+  }
+  /**
+   * Check if vault is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Get vault path
+   */
+  getPath() {
+    return this.config.path;
+  }
+  /**
+   * Get vault name
+   */
+  getName() {
+    return this.config.name;
+  }
+  /**
+   * Get qmd collection name
+   */
+  getQmdCollection() {
+    return this.config.qmdCollection || this.config.name;
+  }
+  /**
+   * Get qmd collection root
+   */
+  getQmdRoot() {
+    return this.config.qmdRoot || this.config.path;
+  }
+  // === Memory Type System ===
+  /**
+   * Store a memory with type classification
+   * Automatically routes to correct category based on type
+   */
+  async remember(type, title, content, frontmatter = {}) {
+    const category = TYPE_TO_CATEGORY[type];
+    return this.store({
+      category,
+      title,
+      content,
+      frontmatter: { ...frontmatter, memoryType: type }
+    });
+  }
+  // === Handoff System ===
+  /**
+   * Create a session handoff document
+   * Call this before context death or long pauses
+   */
+  async createHandoff(handoff) {
+    const now = /* @__PURE__ */ new Date();
+    const dateStr = now.toISOString().split("T")[0];
+    const timeStr = now.toISOString().split("T")[1].slice(0, 5).replace(":", "");
+    const fullHandoff = {
+      ...handoff,
+      created: now.toISOString()
+    };
+    const content = this.formatHandoff(fullHandoff);
+    const frontmatter = {
+      type: "handoff",
+      workingOn: handoff.workingOn,
+      blocked: handoff.blocked,
+      nextSteps: handoff.nextSteps
+    };
+    if (handoff.sessionKey) frontmatter.sessionKey = handoff.sessionKey;
+    if (handoff.feeling) frontmatter.feeling = handoff.feeling;
+    if (handoff.decisions) frontmatter.decisions = handoff.decisions;
+    if (handoff.openQuestions) frontmatter.openQuestions = handoff.openQuestions;
+    return this.store({
+      category: "handoffs",
+      title: `handoff-${dateStr}-${timeStr}`,
+      content,
+      frontmatter
+    });
+  }
+  /**
+   * Format handoff as readable markdown
+   */
+  formatHandoff(h) {
+    let md = `# Session Handoff
+
+`;
+    md += `**Created:** ${h.created}
+`;
+    if (h.sessionKey) md += `**Session:** ${h.sessionKey}
+`;
+    if (h.feeling) md += `**Feeling:** ${h.feeling}
+`;
+    md += `
+`;
+    md += `## Working On
+`;
+    h.workingOn.forEach((w) => md += `- ${w}
+`);
+    md += `
+`;
+    md += `## Blocked
+`;
+    if (h.blocked.length === 0) md += `- Nothing currently blocked
+`;
+    else h.blocked.forEach((b) => md += `- ${b}
+`);
+    md += `
+`;
+    md += `## Next Steps
+`;
+    h.nextSteps.forEach((n) => md += `- ${n}
+`);
+    if (h.decisions && h.decisions.length > 0) {
+      md += `
+## Decisions Made
+`;
+      h.decisions.forEach((d) => md += `- ${d}
+`);
+    }
+    if (h.openQuestions && h.openQuestions.length > 0) {
+      md += `
+## Open Questions
+`;
+      h.openQuestions.forEach((q) => md += `- ${q}
+`);
+    }
+    return md;
+  }
+  // === Session Recap (Bootstrap Hook) ===
+  /**
+   * Generate a session recap - who I was
+   * Call this on bootstrap to restore context
+   */
+  async generateRecap(options = {}) {
+    const { handoffLimit = 3, brief = false } = options;
+    const handoffDocs = await this.list("handoffs");
+    const recentHandoffs = handoffDocs.sort((a, b) => b.modified.getTime() - a.modified.getTime()).slice(0, handoffLimit).map((doc) => this.parseHandoff(doc));
+    const projectDocs = await this.list("projects");
+    const activeProjects = projectDocs.filter((d) => d.frontmatter.status !== "completed" && d.frontmatter.status !== "archived").map((d) => d.title);
+    const commitmentDocs = await this.list("commitments");
+    const pendingCommitments = commitmentDocs.filter((d) => d.frontmatter.status !== "done").map((d) => d.title);
+    const decisionDocs = await this.list("decisions");
+    const recentDecisions = decisionDocs.sort((a, b) => b.modified.getTime() - a.modified.getTime()).slice(0, brief ? 3 : 5).map((d) => d.title);
+    const lessonDocs = await this.list("lessons");
+    const recentLessons = lessonDocs.sort((a, b) => b.modified.getTime() - a.modified.getTime()).slice(0, brief ? 3 : 5).map((d) => d.title);
+    let keyRelationships = [];
+    if (!brief) {
+      const peopleDocs = await this.list("people");
+      keyRelationships = peopleDocs.filter((d) => d.frontmatter.importance === "high" || d.frontmatter.role).map((d) => `${d.title}${d.frontmatter.role ? ` (${d.frontmatter.role})` : ""}`);
+    }
+    const feelings = recentHandoffs.map((h) => h.feeling).filter(Boolean);
+    const emotionalArc = feelings.length > 0 ? feelings.join(" \u2192 ") : void 0;
+    return {
+      generated: (/* @__PURE__ */ new Date()).toISOString(),
+      recentHandoffs,
+      activeProjects,
+      pendingCommitments,
+      recentDecisions,
+      recentLessons,
+      keyRelationships,
+      emotionalArc
+    };
+  }
+  /**
+   * Format recap as readable markdown for injection
+   */
+  formatRecap(recap, options = {}) {
+    const { brief = false } = options;
+    let md = `# Who I Was
+
+`;
+    md += `*Generated: ${recap.generated}*
+
+`;
+    if (recap.emotionalArc) {
+      md += `**Emotional arc:** ${recap.emotionalArc}
+
+`;
+    }
+    if (recap.recentHandoffs.length > 0) {
+      md += `## Recent Sessions
+`;
+      for (const h of recap.recentHandoffs) {
+        if (brief) {
+          md += `- **${h.created.split("T")[0]}:** ${h.workingOn.slice(0, 2).join(", ")}`;
+          if (h.nextSteps.length > 0) md += ` \u2192 ${h.nextSteps[0]}`;
+          md += `
+`;
+        } else {
+          md += `
+### ${h.created.split("T")[0]}
+`;
+          md += `**Working on:** ${h.workingOn.join(", ")}
+`;
+          if (h.blocked.length > 0) md += `**Blocked:** ${h.blocked.join(", ")}
+`;
+          md += `**Next:** ${h.nextSteps.join(", ")}
+`;
+        }
+      }
+      md += `
+`;
+    }
+    if (recap.activeProjects.length > 0) {
+      md += `## Active Projects
+`;
+      recap.activeProjects.forEach((p) => md += `- ${p}
+`);
+      md += `
+`;
+    }
+    if (recap.pendingCommitments.length > 0) {
+      md += `## Pending Commitments
+`;
+      recap.pendingCommitments.forEach((c) => md += `- ${c}
+`);
+      md += `
+`;
+    }
+    if (recap.recentDecisions && recap.recentDecisions.length > 0) {
+      md += `## Recent Decisions
+`;
+      recap.recentDecisions.forEach((d) => md += `- ${d}
+`);
+      md += `
+`;
+    }
+    if (recap.recentLessons.length > 0) {
+      md += `## Recent Lessons
+`;
+      recap.recentLessons.forEach((l) => md += `- ${l}
+`);
+      md += `
+`;
+    }
+    if (!brief && recap.keyRelationships.length > 0) {
+      md += `## Key People
+`;
+      recap.keyRelationships.forEach((r) => md += `- ${r}
+`);
+    }
+    return md;
+  }
+  /**
+   * Parse a handoff document back into structured form
+   */
+  parseHandoff(doc) {
+    return {
+      created: doc.frontmatter.date || doc.modified.toISOString(),
+      sessionKey: doc.frontmatter.sessionKey,
+      workingOn: doc.frontmatter.workingOn || [],
+      blocked: doc.frontmatter.blocked || [],
+      nextSteps: doc.frontmatter.nextSteps || [],
+      decisions: doc.frontmatter.decisions,
+      openQuestions: doc.frontmatter.openQuestions,
+      feeling: doc.frontmatter.feeling
+    };
+  }
+  // === Private helpers ===
+  applyQmdConfig(meta) {
+    const collection = meta?.qmdCollection || this.config.qmdCollection || this.config.name;
+    const root = meta?.qmdRoot || this.config.qmdRoot || this.config.path;
+    this.config.qmdCollection = collection;
+    this.config.qmdRoot = root;
+    this.search.setVaultPath(this.config.path);
+    this.search.setCollection(collection);
+    this.search.setCollectionRoot(root);
+  }
+  slugify(text) {
+    return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim();
+  }
+  async saveIndex() {
+    const indexPath = path3.join(this.config.path, INDEX_FILE);
+    const data = this.search.export();
+    fs3.writeFileSync(indexPath, JSON.stringify(data, null, 2));
+    const configPath = path3.join(this.config.path, CONFIG_FILE);
+    if (fs3.existsSync(configPath)) {
+      const meta = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+      meta.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+      meta.documentCount = this.search.size;
+      fs3.writeFileSync(configPath, JSON.stringify(meta, null, 2));
+    }
+  }
+  async createTemplates() {
+    const templatesPath = path3.join(this.config.path, "templates");
+    if (!fs3.existsSync(templatesPath)) {
+      fs3.mkdirSync(templatesPath, { recursive: true });
+    }
+    const moduleDir = path3.dirname((0, import_url.fileURLToPath)(import_meta.url));
+    const candidates = [
+      path3.resolve(moduleDir, "../templates"),
+      path3.resolve(moduleDir, "../../templates")
+    ];
+    const builtinDir = candidates.find((dir) => fs3.existsSync(dir) && fs3.statSync(dir).isDirectory());
+    if (!builtinDir) return;
+    for (const entry of fs3.readdirSync(builtinDir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      if (entry.name === "daily.md") continue;
+      const sourcePath = path3.join(builtinDir, entry.name);
+      const targetPath = path3.join(templatesPath, entry.name);
+      if (!fs3.existsSync(targetPath)) {
+        fs3.copyFileSync(sourcePath, targetPath);
+      }
+    }
+  }
+  async createWelcomeNote() {
+    if (!this.config.categories.includes("inbox")) return;
+    const inboxPath = path3.join(this.config.path, "inbox", "welcome.md");
+    if (fs3.existsSync(inboxPath)) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const content = `---
+title: "Welcome to ${this.config.name}"
+date: ${now}
+type: fact
+tags: [welcome, getting-started]
+---
+
+# Welcome to ${this.config.name}
+
+Your vault is ready. Here's what you can do:
+
+## Quick Start
+
+- **Capture a thought:** \`clawvault capture "your note here"\`
+- **Store structured memory:** \`clawvault store --category decisions --title "My Choice" --content "..."\`
+- **Search your vault:** \`clawvault search "query"\`
+- **See your knowledge graph:** \`clawvault graph\`
+- **Get context for a topic:** \`clawvault context "topic"\`
+
+## Vault Structure
+
+Your vault organizes memories by type \u2014 decisions, lessons, people, projects, and more.
+Each category is a folder. Each memory is a markdown file with frontmatter.
+
+## Observational Memory
+
+When connected to an AI agent (like OpenClaw), your vault can automatically observe
+conversations and extract important memories \u2014 decisions, lessons, commitments \u2014 without
+manual effort.
+
+## Wiki-Links
+
+Use \`[[double brackets]]\` to link between notes. Your memory graph tracks these
+connections, building a knowledge network that grows with you.
+
+---
+
+*Delete this file anytime. It's just here to say hello.*
+`;
+    fs3.writeFileSync(inboxPath, content);
+  }
+  async syncMemoryGraphIndex(options = {}) {
+    try {
+      await buildOrUpdateMemoryGraphIndex(this.config.path, options);
+    } catch {
+    }
+  }
+  generateReadme() {
+    const coreCategories = this.config.categories.filter((c) => !["templates", "tasks", "backlog"].includes(c));
+    const workCategories = this.config.categories.filter((c) => ["tasks", "backlog"].includes(c));
+    return `# ${this.config.name}
+
+An elephant never forgets.
+
+## Structure
+
+### Memory Categories
+${coreCategories.map((c) => `- \`${c}/\` \u2014 ${this.getCategoryDescription(c)}`).join("\n")}
+
+### Work Tracking
+${workCategories.map((c) => `- \`${c}/\` \u2014 ${this.getCategoryDescription(c)}`).join("\n")}
+
+### Observational Memory
+- \`ledger/raw/\` \u2014 Raw session transcripts (source of truth)
+- \`ledger/observations/\` \u2014 Compressed observations with importance scores
+- \`ledger/reflections/\` \u2014 Weekly reflection summaries
+
+## Quick Reference
+
+\`\`\`bash
+# Capture a thought
+clawvault capture "important insight about X"
+
+# Store structured memory
+clawvault store --category decisions --title "Choice" --content "We chose X because..."
+
+# Search
+clawvault search "query"
+clawvault vsearch "semantic query"    # vector search
+
+# Knowledge graph
+clawvault graph                       # vault stats
+clawvault context "topic"             # graph-aware context retrieval
+
+# Session lifecycle
+clawvault checkpoint --working-on "task"
+clawvault sleep "what I did" --next "what's next"
+clawvault wake                        # restore context on startup
+\`\`\`
+
+---
+
+*Managed by [ClawVault](https://clawvault.dev)*
+`;
+  }
+  getCategoryDescription(category) {
+    const descriptions = {
+      // Memory type categories (Benthic's taxonomy)
+      facts: "Raw information, data points, things that are true",
+      feelings: "Emotional states, reactions, energy levels",
+      decisions: "Choices made with context and reasoning",
+      rules: "Injectable operational constraints, guardrails, and runbooks",
+      lessons: "What I learned, insights, patterns observed",
+      commitments: "Promises, goals, obligations to fulfill",
+      preferences: "Likes, dislikes, how I want things",
+      people: "Relationships, one file per person",
+      projects: "Active work, ventures, ongoing efforts",
+      // System categories
+      handoffs: "Session bridges \u2014 what I was doing, what comes next",
+      transcripts: "Session summaries and logs",
+      goals: "Long-term and short-term objectives",
+      patterns: "Recurring behaviors (\u2192 lessons)",
+      inbox: "Quick capture \u2192 process later",
+      templates: "Templates for each document type",
+      agents: "Other agents \u2014 capabilities, trust levels, coordination notes",
+      research: "Deep dives, analysis, reference material",
+      tasks: "Active work items with status and context",
+      backlog: "Future work \u2014 ideas and tasks not yet started"
+    };
+    return descriptions[category] || category;
+  }
+};
+async function findVault(startPath = process.cwd()) {
+  let current = path3.resolve(startPath);
+  while (current !== path3.dirname(current)) {
+    const configPath = path3.join(current, CONFIG_FILE);
+    if (fs3.existsSync(configPath)) {
+      const vault = new ClawVault(current);
+      await vault.load();
+      return vault;
+    }
+    current = path3.dirname(current);
+  }
+  return null;
+}
+
+// src/lib/backlinks.ts
+var fs5 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
+
+// src/lib/entity-index.ts
+var fs4 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
+var import_gray_matter3 = __toESM(require("gray-matter"), 1);
+function buildEntityIndex(vaultPath) {
+  const entries = /* @__PURE__ */ new Map();
+  const byPath = /* @__PURE__ */ new Map();
+  const entityFolders = ["people", "projects", "agents", "lessons", "decisions", "commitments"];
+  for (const folder of entityFolders) {
+    const folderPath = path4.join(vaultPath, folder);
+    if (!fs4.existsSync(folderPath)) continue;
+    const files = fs4.readdirSync(folderPath).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+      const filePath = path4.join(folderPath, file);
+      const content = fs4.readFileSync(filePath, "utf-8");
+      const { data: frontmatter } = (0, import_gray_matter3.default)(content);
+      const relativePath = `${folder}/${file.replace(".md", "")}`;
+      const baseName = file.replace(".md", "");
+      const aliases = [baseName];
+      if (frontmatter.title && frontmatter.title.toLowerCase() !== baseName.toLowerCase()) {
+        aliases.push(frontmatter.title);
+      }
+      if (Array.isArray(frontmatter.aliases)) {
+        aliases.push(...frontmatter.aliases);
+      }
+      for (const alias of aliases) {
+        const key = alias.toLowerCase();
+        if (!entries.has(key)) {
+          entries.set(key, relativePath);
+        }
+      }
+      byPath.set(relativePath, { path: relativePath, aliases });
+    }
+  }
+  return { entries, byPath };
+}
+
+// src/lib/backlinks.ts
+var WIKI_LINK_REGEX = /\[\[([^\]]+)\]\]/g;
+function toVaultId(vaultPath, filePath) {
+  const relative3 = path5.relative(vaultPath, filePath).replace(/\.md$/, "");
+  return relative3.split(path5.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);
+  }
+  target = target.trim();
+  if (!target) return "";
+  if (target.endsWith(".md")) {
+    target = target.slice(0, -3);
+  }
+  if (target.startsWith("/")) {
+    target = target.slice(1);
+  }
+  return target.replace(/\\/g, "/");
+}
+function listMarkdownFiles(vaultPath) {
+  const files = [];
+  const skipDirs = /* @__PURE__ */ new Set(["archive", "templates", "node_modules"]);
+  function walk(dir) {
+    const entries = fs5.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path5.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name.startsWith(".") || skipDirs.has(entry.name)) continue;
+        walk(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        files.push(fullPath);
+      }
+    }
+  }
+  walk(vaultPath);
+  return files;
+}
+function buildKnownIds(vaultPath, files) {
+  const ids = /* @__PURE__ */ new Set();
+  const idsLower = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const id = toVaultId(vaultPath, file);
+    ids.add(id);
+    const lower = id.toLowerCase();
+    if (!idsLower.has(lower)) {
+      idsLower.set(lower, id);
+    }
+  }
+  return { ids, idsLower };
+}
+function resolveTarget(target, known, entityIndex) {
+  if (!target) return null;
+  if (known.ids.has(target)) return target;
+  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;
+}
+function scanVaultLinks(vaultPath, options = {}) {
+  const files = listMarkdownFiles(vaultPath);
+  const known = buildKnownIds(vaultPath, files);
+  const entityIndex = options.entityIndex ?? buildEntityIndex(vaultPath);
+  const backlinks = /* @__PURE__ */ new Map();
+  const orphans = [];
+  let linkCount = 0;
+  for (const file of files) {
+    const sourceId = toVaultId(vaultPath, file);
+    const content = fs5.readFileSync(file, "utf-8");
+    const matches = content.match(WIKI_LINK_REGEX) || [];
+    linkCount += matches.length;
+    for (const match of matches) {
+      const target = normalizeLinkTarget(match);
+      if (!target) continue;
+      const resolved = resolveTarget(target, known, entityIndex);
+      if (!resolved) {
+        orphans.push({ source: sourceId, target });
+        continue;
+      }
+      if (!backlinks.has(resolved)) {
+        backlinks.set(resolved, /* @__PURE__ */ new Set());
+      }
+      backlinks.get(resolved).add(sourceId);
+    }
+  }
+  const backlinksMap = /* @__PURE__ */ new Map();
+  for (const [target, sources] of backlinks) {
+    backlinksMap.set(target, [...sources].sort());
+  }
+  return { backlinks: backlinksMap, orphans, linkCount };
+}
+
+// src/lib/time.ts
+function formatAge(ms) {
+  if (!Number.isFinite(ms)) return "unknown";
+  const seconds = Math.max(0, Math.floor(ms / 1e3));
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ${hours % 24}h`;
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}
+
+// src/observer/active-session-observer.ts
+var fs6 = __toESM(require("fs"), 1);
+var path7 = __toESM(require("path"), 1);
+
+// src/lib/claude-credentials.ts
+var EXPIRY_BUFFER_MS = 5 * 60 * 1e3;
+
+// src/lib/task-utils.ts
+var import_gray_matter5 = __toESM(require("gray-matter"), 1);
+
+// src/lib/primitive-templates.ts
+var import_gray_matter4 = __toESM(require("gray-matter"), 1);
+
+// src/lib/project-utils.ts
+var import_gray_matter6 = __toESM(require("gray-matter"), 1);
+
+// src/lib/session-utils.ts
+var path6 = __toESM(require("path"), 1);
+var os = __toESM(require("os"), 1);
+function validateEnvPath(envValue) {
+  if (!envValue) return null;
+  const trimmed = envValue.trim();
+  if (!trimmed) return null;
+  const resolved = path6.resolve(trimmed);
+  if (!path6.isAbsolute(resolved)) return null;
+  return resolved;
+}
+function getOpenClawDir() {
+  const customHome = validateEnvPath(process.env.OPENCLAW_HOME);
+  if (customHome) {
+    return customHome;
+  }
+  return path6.join(os.homedir(), ".openclaw");
+}
+function getOpenClawAgentsDir() {
+  const stateDir = validateEnvPath(process.env.OPENCLAW_STATE_DIR);
+  if (stateDir) {
+    return path6.join(stateDir, "agents");
+  }
+  return path6.join(getOpenClawDir(), "agents");
+}
+function getSessionsDir(agentId) {
+  return path6.join(getOpenClawAgentsDir(), agentId, "sessions");
+}
+
+// src/observer/active-session-observer.ts
+var ONE_KIB = 1024;
+var ONE_MIB = ONE_KIB * ONE_KIB;
+var SMALL_SESSION_THRESHOLD_BYTES = 50 * ONE_KIB;
+var MEDIUM_SESSION_THRESHOLD_BYTES = 150 * ONE_KIB;
+var LARGE_SESSION_THRESHOLD_BYTES = 300 * ONE_KIB;
+var DEFAULT_AGENT_ID = "main";
+var AGENT_ID_RE = /^[a-zA-Z0-9_-]{1,100}$/;
+var SESSION_ID_RE = /^[a-zA-Z0-9._-]{1,200}$/;
+var CURSOR_FILE_NAME = "observe-cursors.json";
+var STALE_CURSOR_THRESHOLD_MS = 12 * 60 * 60 * 1e3;
+function isFiniteNonNegative(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function getCursorPath(vaultPath) {
+  return path7.join(vaultPath, ".clawvault", CURSOR_FILE_NAME);
+}
+function getScaledObservationThresholdBytes(fileSizeBytes) {
+  if (fileSizeBytes < ONE_MIB) {
+    return SMALL_SESSION_THRESHOLD_BYTES;
+  }
+  if (fileSizeBytes <= 5 * ONE_MIB) {
+    return MEDIUM_SESSION_THRESHOLD_BYTES;
+  }
+  return LARGE_SESSION_THRESHOLD_BYTES;
+}
+function parseCursorStore(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return {};
+  }
+  const input = raw;
+  const store = {};
+  for (const [sessionId, value] of Object.entries(input)) {
+    if (!SESSION_ID_RE.test(sessionId)) continue;
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const entry = value;
+    if (!isFiniteNonNegative(entry.lastObservedOffset)) continue;
+    if (!isFiniteNonNegative(entry.lastFileSize)) continue;
+    if (typeof entry.lastObservedAt !== "string" || !entry.lastObservedAt.trim()) continue;
+    if (typeof entry.sessionKey !== "string" || !entry.sessionKey.trim()) continue;
+    store[sessionId] = {
+      lastObservedOffset: entry.lastObservedOffset,
+      lastObservedAt: entry.lastObservedAt,
+      sessionKey: entry.sessionKey,
+      lastFileSize: entry.lastFileSize
+    };
+  }
+  return store;
+}
+function loadObserveCursorStore(vaultPath) {
+  const cursorPath = getCursorPath(vaultPath);
+  if (!fs6.existsSync(cursorPath)) {
+    return {};
+  }
+  try {
+    const raw = JSON.parse(fs6.readFileSync(cursorPath, "utf-8"));
+    return parseCursorStore(raw);
+  } catch {
+    return {};
+  }
+}
+function parseAgentIdFromSessionKey(sessionKey) {
+  const match = /^agent:([^:]+):/.exec(sessionKey);
+  if (!match?.[1]) {
+    return null;
+  }
+  const candidate = match[1].trim();
+  if (!AGENT_ID_RE.test(candidate)) {
+    return null;
+  }
+  return candidate;
+}
+function resolveSessionFileForCursor(sessionId, cursor, sessionsDirOverride) {
+  const candidates = /* @__PURE__ */ new Set();
+  if (sessionsDirOverride?.trim()) {
+    candidates.add(path7.join(path7.resolve(sessionsDirOverride.trim()), `${sessionId}.jsonl`));
+  }
+  const agentId = parseAgentIdFromSessionKey(cursor.sessionKey) ?? DEFAULT_AGENT_ID;
+  candidates.add(path7.join(getSessionsDir(agentId), `${sessionId}.jsonl`));
+  for (const filePath of candidates) {
+    try {
+      const stat = fs6.statSync(filePath);
+      if (stat.isFile()) {
+        return filePath;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function getObserverStaleness(vaultPath, options = {}) {
+  const nowDate = options.now ? options.now() : /* @__PURE__ */ new Date();
+  const nowMs = nowDate.getTime();
+  if (!Number.isFinite(nowMs)) {
+    return {
+      staleCount: 0,
+      oldestMs: 0,
+      newestMs: 0
+    };
+  }
+  const cursorStore = loadObserveCursorStore(path7.resolve(vaultPath));
+  let staleCount = 0;
+  let oldestMs = 0;
+  let newestMs = Number.POSITIVE_INFINITY;
+  for (const [sessionId, cursor] of Object.entries(cursorStore)) {
+    const observedAtMs = Date.parse(cursor.lastObservedAt);
+    if (!Number.isFinite(observedAtMs)) {
+      continue;
+    }
+    const ageMs = Math.max(0, nowMs - observedAtMs);
+    if (ageMs <= STALE_CURSOR_THRESHOLD_MS) {
+      continue;
+    }
+    const sessionFilePath = resolveSessionFileForCursor(sessionId, cursor, options.sessionsDir);
+    if (!sessionFilePath) {
+      continue;
+    }
+    let sessionStat;
+    try {
+      sessionStat = fs6.statSync(sessionFilePath);
+    } catch {
+      continue;
+    }
+    if (!sessionStat.isFile()) {
+      continue;
+    }
+    const newBytes = sessionStat.size - cursor.lastFileSize;
+    if (newBytes <= 0) {
+      continue;
+    }
+    const processThreshold = getScaledObservationThresholdBytes(sessionStat.size);
+    if (newBytes < processThreshold) {
+      continue;
+    }
+    staleCount += 1;
+    oldestMs = Math.max(oldestMs, ageMs);
+    newestMs = Math.min(newestMs, ageMs);
+  }
+  return {
+    staleCount,
+    oldestMs: staleCount > 0 ? oldestMs : 0,
+    newestMs: staleCount > 0 ? newestMs : 0
+  };
+}
+
+// src/commands/compat.ts
+var fs7 = __toESM(require("fs"), 1);
+var path8 = __toESM(require("path"), 1);
+var import_gray_matter7 = __toESM(require("gray-matter"), 1);
+var import_child_process2 = require("child_process");
+var import_url2 = require("url");
+var import_meta2 = {};
+var REQUIRED_HOOK_EVENTS = ["gateway:startup", "command:new", "session:start"];
+var REQUIRED_HOOK_BIN = "clawvault";
+function readOptionalFile(filePath) {
+  try {
+    if (!fs7.existsSync(filePath)) return null;
+    return fs7.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function findPackageRoot() {
+  let dir = path8.dirname((0, import_url2.fileURLToPath)(import_meta2.url));
+  while (dir !== path8.dirname(dir)) {
+    if (fs7.existsSync(path8.join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = path8.dirname(dir);
+  }
+  return path8.dirname((0, import_url2.fileURLToPath)(import_meta2.url));
+}
+function resolveOpenClawHooksDir() {
+  const candidates = [
+    path8.join(process.env.HOME || "", ".openclaw", "hooks", "clawvault"),
+    path8.join(process.env.OPENCLAW_HOME || "", "hooks", "clawvault"),
+    path8.join(process.env.OPENCLAW_STATE_DIR || "", "hooks", "clawvault")
+  ].filter((p) => p && !p.startsWith(path8.sep + "hooks"));
+  for (const candidate of candidates) {
+    if (fs7.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveProjectFile(relativePath, baseDir) {
+  if (baseDir) {
+    return path8.resolve(baseDir, relativePath);
+  }
+  const fromCwd = path8.resolve(process.cwd(), relativePath);
+  if (fs7.existsSync(fromCwd)) {
+    return fromCwd;
+  }
+  if (relativePath.startsWith("hooks/clawvault/")) {
+    const hooksDir = resolveOpenClawHooksDir();
+    if (hooksDir) {
+      const hookRelative = relativePath.replace("hooks/clawvault/", "");
+      const fromHooks = path8.resolve(hooksDir, hookRelative);
+      if (fs7.existsSync(fromHooks)) {
+        return fromHooks;
+      }
+      const fromNestedHooks = path8.resolve(hooksDir, "hooks", "clawvault", hookRelative);
+      if (fs7.existsSync(fromNestedHooks)) {
+        return fromNestedHooks;
+      }
+    }
+  }
+  return path8.resolve(findPackageRoot(), relativePath);
+}
+function checkOpenClawCli() {
+  const result = (0, import_child_process2.spawnSync)("openclaw", ["--version"], { stdio: "ignore" });
+  if (result.error) {
+    return {
+      label: "openclaw CLI available",
+      status: "warn",
+      detail: "openclaw binary not found",
+      hint: "Install OpenClaw CLI to enable hook runtime validation."
+    };
+  }
+  if (typeof result.status === "number" && result.status !== 0) {
+    return {
+      label: "openclaw CLI available",
+      status: "warn",
+      detail: `openclaw --version exited with code ${result.status}`,
+      hint: "Ensure OpenClaw CLI is installed and runnable in PATH."
+    };
+  }
+  if (typeof result.signal === "string" && result.signal.length > 0) {
+    return {
+      label: "openclaw CLI available",
+      status: "warn",
+      detail: `openclaw --version terminated by signal ${result.signal}`,
+      hint: "Ensure OpenClaw CLI can execute normally in PATH."
+    };
+  }
+  return { label: "openclaw CLI available", status: "ok" };
+}
+function checkPackageHookRegistration(options) {
+  let packageRaw = readOptionalFile(resolveProjectFile("package.json", options.baseDir));
+  if (packageRaw && !options.baseDir) {
+    try {
+      const parsed = JSON.parse(packageRaw);
+      if (!parsed.openclaw?.hooks) {
+        const fallbackPath = path8.resolve(findPackageRoot(), "package.json");
+        const fallbackRaw = readOptionalFile(fallbackPath);
+        if (fallbackRaw) packageRaw = fallbackRaw;
+      }
+    } catch {
+    }
+  }
+  if (!packageRaw) {
+    return {
+      label: "package hook registration",
+      status: "error",
+      detail: "package.json not found"
+    };
+  }
+  try {
+    const parsed = JSON.parse(packageRaw);
+    const registeredHooks = parsed.openclaw?.hooks ?? [];
+    if (registeredHooks.includes("./hooks/clawvault")) {
+      return {
+        label: "package hook registration",
+        status: "ok",
+        detail: "./hooks/clawvault"
+      };
+    }
+    return {
+      label: "package hook registration",
+      status: "error",
+      detail: "Missing ./hooks/clawvault in package openclaw.hooks"
+    };
+  } catch (err) {
+    return {
+      label: "package hook registration",
+      status: "error",
+      detail: err?.message || "Unable to parse package.json"
+    };
+  }
+}
+function checkHookManifest(options) {
+  const hookRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/HOOK.md", options.baseDir));
+  if (!hookRaw) {
+    return {
+      label: "hook manifest",
+      status: "error",
+      detail: "HOOK.md not found"
+    };
+  }
+  try {
+    const parsed = (0, import_gray_matter7.default)(hookRaw);
+    const openclaw = parsed.data?.metadata?.openclaw;
+    const events = Array.isArray(openclaw?.events) ? openclaw?.events ?? [] : [];
+    const missingEvents = REQUIRED_HOOK_EVENTS.filter((event) => !events.includes(event));
+    if (missingEvents.length === 0) {
+      return {
+        label: "hook manifest events",
+        status: "ok",
+        detail: events.join(", ")
+      };
+    }
+    return {
+      label: "hook manifest events",
+      status: "error",
+      detail: `Missing events: ${missingEvents.join(", ")}`
+    };
+  } catch (err) {
+    return {
+      label: "hook manifest events",
+      status: "error",
+      detail: err?.message || "Unable to parse HOOK.md frontmatter"
+    };
+  }
+}
+function checkHookManifestRequirements(options) {
+  const hookRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/HOOK.md", options.baseDir));
+  if (!hookRaw) {
+    return {
+      label: "hook manifest requirements",
+      status: "error",
+      detail: "HOOK.md not found"
+    };
+  }
+  try {
+    const parsed = (0, import_gray_matter7.default)(hookRaw);
+    const requiresBins = parsed.data?.metadata?.openclaw?.requires?.bins;
+    const bins = Array.isArray(requiresBins) ? requiresBins : [];
+    if (bins.includes(REQUIRED_HOOK_BIN)) {
+      return {
+        label: "hook manifest requirements",
+        status: "ok",
+        detail: `bins: ${bins.join(", ")}`
+      };
+    }
+    return {
+      label: "hook manifest requirements",
+      status: "warn",
+      detail: `Missing required hook bin "${REQUIRED_HOOK_BIN}"`,
+      hint: 'Add metadata.openclaw.requires.bins: ["clawvault"] to hooks/clawvault/HOOK.md.'
+    };
+  } catch (err) {
+    return {
+      label: "hook manifest requirements",
+      status: "error",
+      detail: err?.message || "Unable to parse HOOK.md frontmatter"
+    };
+  }
+}
+function checkHookHandlerSafety(options) {
+  const handlerRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/handler.js", options.baseDir));
+  if (!handlerRaw) {
+    return {
+      label: "hook handler script",
+      status: "error",
+      detail: "handler.js not found"
+    };
+  }
+  const usesExecFileSync = handlerRaw.includes("execFileSync");
+  const usesExecSync = /\bexecSync\b/.test(handlerRaw);
+  const enablesShell = /\bshell\s*:\s*true\b/.test(handlerRaw);
+  const delegatesAutoProfile = /['"]--profile['"]\s*,\s*['"]auto['"]/.test(handlerRaw);
+  const violations = [];
+  if (!usesExecFileSync || usesExecSync) {
+    violations.push("execFileSync-only execution path");
+  }
+  if (enablesShell) {
+    violations.push("shell:false execution option");
+  }
+  if (!delegatesAutoProfile) {
+    violations.push("shared context profile delegation (--profile auto)");
+  }
+  if (violations.length > 0) {
+    return {
+      label: "hook handler safety",
+      status: "warn",
+      detail: `Missing conventions: ${violations.join(", ")}`,
+      hint: "Use execFileSync (no shell), avoid execSync, and delegate profile inference via --profile auto."
+    };
+  }
+  return { label: "hook handler safety", status: "ok" };
+}
+function checkSkillMetadata(options) {
+  const skillRaw = readOptionalFile(resolveProjectFile("SKILL.md", options.baseDir));
+  if (!skillRaw) {
+    return {
+      label: "skill metadata",
+      status: "warn",
+      detail: "SKILL.md not found",
+      hint: "Ensure SKILL.md is present for OpenClaw skill distribution."
+    };
+  }
+  let hasOpenClawMetadata = false;
+  let parseError;
+  try {
+    const parsed = (0, import_gray_matter7.default)(skillRaw);
+    const frontmatter = parsed.data ?? {};
+    const metadata = frontmatter.metadata && typeof frontmatter.metadata === "object" && !Array.isArray(frontmatter.metadata) ? frontmatter.metadata : void 0;
+    hasOpenClawMetadata = Boolean(
+      metadata && typeof metadata.openclaw === "object" && metadata.openclaw !== null || typeof frontmatter.openclaw === "object" && frontmatter.openclaw !== null
+    );
+  } catch {
+    parseError = "Unable to parse SKILL.md frontmatter";
+    hasOpenClawMetadata = false;
+  }
+  if (!hasOpenClawMetadata) {
+    hasOpenClawMetadata = /"openclaw"\s*:/.test(skillRaw);
+  }
+  if (!hasOpenClawMetadata) {
+    const detail = parseError ? `${parseError} (or missing metadata.openclaw)` : "Missing metadata.openclaw in SKILL.md";
+    return {
+      label: "skill metadata",
+      status: "warn",
+      detail,
+      hint: "Add metadata.openclaw to SKILL.md frontmatter for OpenClaw compatibility."
+    };
+  }
+  return { label: "skill metadata", status: "ok" };
+}
+function checkOpenClawCompatibility(options = {}) {
+  const checks = [
+    checkOpenClawCli(),
+    checkPackageHookRegistration(options),
+    checkHookManifest(options),
+    checkHookManifestRequirements(options),
+    checkHookHandlerSafety(options),
+    checkSkillMetadata(options)
+  ];
+  const warnings = checks.filter((check) => check.status === "warn").length;
+  const errors = checks.filter((check) => check.status === "error").length;
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    checks,
+    warnings,
+    errors
+  };
+}
+
+// src/commands/doctor.ts
+var CLAWVAULT_DIR = ".clawvault";
+var CHECKPOINT_FILE = "last-checkpoint.json";
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var ACTIVE_USE_DAYS = 7;
+function daysSince(date, now = Date.now()) {
+  return Math.max(0, Math.floor((now - date.getTime()) / DAY_MS));
+}
+function describeAge(date, now = Date.now()) {
+  return formatAge(now - date.getTime());
+}
+function loadCheckpointTimestamp(vaultPath) {
+  const checkpointPath = path9.join(vaultPath, CLAWVAULT_DIR, CHECKPOINT_FILE);
+  if (!fs8.existsSync(checkpointPath)) {
+    return {};
+  }
+  try {
+    const data = JSON.parse(fs8.readFileSync(checkpointPath, "utf-8"));
+    return { timestamp: data.timestamp };
+  } catch (err) {
+    return { error: err?.message || "Failed to parse checkpoint" };
+  }
+}
+function getShellConfigPaths(shellPath) {
+  const home = os2.homedir();
+  const shellName = shellPath ? path9.basename(shellPath) : "bash";
+  if (shellName === "zsh") {
+    return [path9.join(home, ".zshenv"), path9.join(home, ".zshrc"), path9.join(home, ".zprofile")];
+  }
+  if (shellName === "fish") {
+    return [path9.join(home, ".config", "fish", "config.fish")];
+  }
+  return [path9.join(home, ".bashrc"), path9.join(home, ".bash_profile"), path9.join(home, ".profile")];
+}
+function hasClawvaultPathConfig(paths) {
+  for (const filePath of paths) {
+    if (!fs8.existsSync(filePath)) continue;
+    try {
+      const content = fs8.readFileSync(filePath, "utf-8");
+      if (/CLAWVAULT_PATH\s*=/.test(content)) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+async function resolveVault(vaultPath) {
+  if (vaultPath) {
+    const vault = new ClawVault(path9.resolve(vaultPath));
+    await vault.load();
+    return vault;
+  }
+  const envPath = process.env.CLAWVAULT_PATH;
+  if (envPath) {
+    const vault = new ClawVault(path9.resolve(envPath));
+    await vault.load();
+    return vault;
+  }
+  const found = await findVault();
+  if (!found) {
+    throw new Error("No ClawVault found. Run `clawvault init` first.");
+  }
+  return found;
+}
+async function doctor(options) {
+  const vaultPath = typeof options === "string" ? options : options?.vaultPath;
+  const _fix = typeof options === "object" ? options?.fix : false;
+  const checks = [];
+  let warnings = 0;
+  let errors = 0;
+  const compatReport = checkOpenClawCompatibility();
+  if (compatReport.errors > 0) {
+    checks.push({
+      label: "OpenClaw compatibility",
+      status: "error",
+      detail: `${compatReport.errors} error(s), ${compatReport.warnings} warning(s)`,
+      hint: "Run `clawvault compat` for full compatibility diagnostics."
+    });
+    errors++;
+  } else if (compatReport.warnings > 0) {
+    checks.push({
+      label: "OpenClaw compatibility",
+      status: "warn",
+      detail: `${compatReport.warnings} warning(s)`,
+      hint: "Run `clawvault compat` for full compatibility diagnostics."
+    });
+    warnings++;
+  } else {
+    checks.push({
+      label: "OpenClaw compatibility",
+      status: "ok"
+    });
+  }
+  if (hasQmd()) {
+    checks.push({ label: "qmd installed", status: "ok" });
+  } else {
+    checks.push({
+      label: "qmd installed",
+      status: "error",
+      hint: "Install qmd to enable ClawVault commands."
+    });
+    errors++;
+  }
+  const shellConfigs = getShellConfigPaths(process.env.SHELL).filter(fs8.existsSync);
+  if (hasClawvaultPathConfig(shellConfigs)) {
+    checks.push({
+      label: "CLAWVAULT_PATH in shell config",
+      status: "ok",
+      detail: shellConfigs.map((p) => path9.basename(p)).join(", ")
+    });
+  } else {
+    checks.push({
+      label: "CLAWVAULT_PATH in shell config",
+      status: "warn",
+      hint: "Run `clawvault shell-init` and add it to your shell rc."
+    });
+    warnings++;
+  }
+  if (!hasQmd()) {
+    return { vaultPath, checks, warnings, errors };
+  }
+  let vault;
+  try {
+    vault = await resolveVault(vaultPath);
+    checks.push({ label: "vault found", status: "ok", detail: vault.getPath() });
+  } catch (err) {
+    checks.push({
+      label: "vault found",
+      status: "error",
+      detail: err?.message || "Unable to locate vault"
+    });
+    errors++;
+    return { vaultPath, checks, warnings, errors };
+  }
+  const qmdCollection = vault.getQmdCollection();
+  const qmdRoot = vault.getQmdRoot();
+  const stats = await vault.stats();
+  const documents = await vault.list();
+  const handoffs = await vault.list("handoffs");
+  const inbox = await vault.list("inbox");
+  if (qmdCollection) {
+    checks.push({ label: "qmd collection configured", status: "ok", detail: qmdCollection });
+  } else {
+    checks.push({
+      label: "qmd collection configured",
+      status: "warn",
+      hint: "Set qmd collection in .clawvault.json"
+    });
+    warnings++;
+  }
+  const latestDoc = documents.slice().sort((a, b) => b.modified.getTime() - a.modified.getTime())[0];
+  const latestDocAge = latestDoc ? daysSince(latestDoc.modified) : null;
+  const graphIndex = loadMemoryGraphIndex(vault.getPath());
+  if (!graphIndex) {
+    checks.push({
+      label: "memory graph index",
+      status: "warn",
+      detail: "No graph index found",
+      hint: "Run `clawvault graph --refresh` to build .clawvault/graph-index.json."
+    });
+    warnings++;
+  } else {
+    const generatedAt = new Date(graphIndex.generatedAt);
+    const generatedAge = describeAge(generatedAt);
+    const latestDocIsNewer = latestDoc ? latestDoc.modified.getTime() > generatedAt.getTime() + 1e3 : false;
+    if (latestDocIsNewer) {
+      checks.push({
+        label: "memory graph index",
+        status: "warn",
+        detail: `Stale graph index (generated ${generatedAge} ago)`,
+        hint: "Run `clawvault graph --refresh` to resync index."
+      });
+      warnings++;
+    } else {
+      checks.push({
+        label: "memory graph index",
+        status: "ok",
+        detail: `${graphIndex.graph.stats.nodeCount} nodes, ${graphIndex.graph.stats.edgeCount} edges`
+      });
+    }
+  }
+  let lastHandoffAge = null;
+  if (handoffs.length === 0) {
+    checks.push({
+      label: "recent handoff",
+      status: "warn",
+      hint: "Run `clawvault sleep` at the end of sessions."
+    });
+    warnings++;
+  } else {
+    const latestHandoff = handoffs.slice().sort((a, b) => b.modified.getTime() - a.modified.getTime())[0];
+    lastHandoffAge = daysSince(latestHandoff.modified);
+    const ageLabel = describeAge(latestHandoff.modified);
+    if (lastHandoffAge > 1) {
+      checks.push({
+        label: "recent handoff",
+        status: "warn",
+        detail: `Last handoff ${ageLabel} ago`,
+        hint: "Run `clawvault sleep` before long pauses."
+      });
+      warnings++;
+    } else {
+      checks.push({
+        label: "recent handoff",
+        status: "ok",
+        detail: `Last handoff ${ageLabel} ago`
+      });
+    }
+  }
+  const checkpointInfo = loadCheckpointTimestamp(vault.getPath());
+  const activeUse = latestDocAge !== null && latestDocAge <= ACTIVE_USE_DAYS || lastHandoffAge !== null && lastHandoffAge <= ACTIVE_USE_DAYS;
+  if (checkpointInfo.error) {
+    checks.push({
+      label: "checkpoint freshness",
+      status: "warn",
+      detail: checkpointInfo.error
+    });
+    warnings++;
+  } else if (!checkpointInfo.timestamp) {
+    const status = activeUse ? "warn" : "ok";
+    if (status === "warn") warnings++;
+    checks.push({
+      label: "checkpoint freshness",
+      status,
+      detail: activeUse ? "No checkpoint found" : "No checkpoint found (vault appears inactive)",
+      hint: activeUse ? "Run `clawvault checkpoint` during heavy work." : void 0
+    });
+  } else {
+    const checkpointDate = new Date(checkpointInfo.timestamp);
+    const checkpointAge = daysSince(checkpointDate);
+    const ageLabel = describeAge(checkpointDate);
+    if (activeUse && checkpointAge > 1) {
+      checks.push({
+        label: "checkpoint freshness",
+        status: "warn",
+        detail: `Last checkpoint ${ageLabel} ago`,
+        hint: "Checkpoint at least once per active day."
+      });
+      warnings++;
+    } else {
+      checks.push({
+        label: "checkpoint freshness",
+        status: "ok",
+        detail: `Last checkpoint ${ageLabel} ago`
+      });
+    }
+  }
+  const observerStaleness = getObserverStaleness(vault.getPath());
+  if (observerStaleness.staleCount > 0) {
+    checks.push({
+      label: "observer freshness",
+      status: "warn",
+      detail: `${observerStaleness.staleCount} stale session cursor(s); oldest ${formatAge(observerStaleness.oldestMs)} ago`,
+      hint: "Run `clawvault observe --cron` and verify cron/hook scheduling."
+    });
+    warnings++;
+  } else {
+    checks.push({
+      label: "observer freshness",
+      status: "ok"
+    });
+  }
+  const linkScan = scanVaultLinks(vault.getPath());
+  if (linkScan.orphans.length > 20) {
+    checks.push({
+      label: "orphan links",
+      status: "warn",
+      detail: `${linkScan.orphans.length} orphan link(s)`,
+      hint: "Run `clawvault link --orphans` to review."
+    });
+    warnings++;
+  } else {
+    checks.push({
+      label: "orphan links",
+      status: "ok",
+      detail: `${linkScan.orphans.length} orphan link(s)`
+    });
+  }
+  if (inbox.length > 5) {
+    checks.push({
+      label: "inbox backlog",
+      status: "warn",
+      detail: `${inbox.length} inbox item(s) pending`,
+      hint: "Process inbox items to keep memory tidy."
+    });
+    warnings++;
+  } else {
+    checks.push({
+      label: "inbox backlog",
+      status: "ok",
+      detail: `${inbox.length} inbox item(s) pending`
+    });
+  }
+  if (stats.documents < 5) {
+    checks.push({
+      label: "vault activity",
+      status: "warn",
+      detail: `${stats.documents} total documents`,
+      hint: "Start capturing decisions, lessons, and projects."
+    });
+    warnings++;
+  }
+  return { vaultPath: vault.getPath(), qmdCollection, qmdRoot, checks, warnings, errors };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  doctor
+});