clawvault 3.1.0 → 3.2.1

package/dist/commands/status.cjs

@@ -1,2737 +0,0 @@
-"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/status.ts
-var status_exports = {};
-__export(status_exports, {
-  formatStatus: () => formatStatus,
-  getStatus: () => getStatus,
-  statusCommand: () => statusCommand
-});
-module.exports = __toCommonJS(status_exports);
-var fs7 = __toESM(require("fs"), 1);
-var path8 = __toESM(require("path"), 1);
-var import_child_process2 = require("child_process");
-
-// 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 [];
-  if (trimmed.startsWith("No results") || trimmed.startsWith("No matches")) 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 basename3 = noteKey.split("/").pop() ?? noteKey;
-  return basename3.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;
-  }
-};
-
-// 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/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/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/status.ts
-var CLAWVAULT_DIR = ".clawvault";
-var CHECKPOINT_FILE = "last-checkpoint.json";
-var DIRTY_DEATH_FLAG = "dirty-death.flag";
-function findGitRoot(startPath) {
-  let current = path8.resolve(startPath);
-  while (true) {
-    if (fs7.existsSync(path8.join(current, ".git"))) {
-      return current;
-    }
-    const parent = path8.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-function getGitStatus(repoRoot) {
-  const output = (0, import_child_process2.execFileSync)("git", ["-C", repoRoot, "status", "--porcelain"], {
-    encoding: "utf-8"
-  });
-  const lines = output.split("\n").filter(Boolean);
-  return { clean: lines.length === 0, dirtyCount: lines.length };
-}
-function getLatestVaultMarkdownMtime(vaultPath) {
-  const skipDirs = /* @__PURE__ */ new Set([".git", ".obsidian", ".trash", "node_modules", ".clawvault"]);
-  let latest = null;
-  function walk(currentPath) {
-    const entries = fs7.readdirSync(currentPath, { withFileTypes: true });
-    for (const entry of entries) {
-      const absolute = path8.join(currentPath, entry.name);
-      if (entry.isDirectory()) {
-        if (!skipDirs.has(entry.name)) {
-          walk(absolute);
-        }
-        continue;
-      }
-      if (!entry.isFile() || !entry.name.endsWith(".md")) {
-        continue;
-      }
-      const mtime = fs7.statSync(absolute).mtime;
-      if (!latest || mtime.getTime() > latest.getTime()) {
-        latest = mtime;
-      }
-    }
-  }
-  walk(vaultPath);
-  return latest;
-}
-function parseQmdCollectionsText(raw) {
-  const names = [];
-  const regex = /^(\S+)\s+\(qmd:\/\/\1\/\)/gm;
-  let match;
-  while ((match = regex.exec(raw)) !== null) {
-    names.push(match[1]);
-  }
-  return names;
-}
-function getQmdIndexStatus(collection, root, indexName) {
-  const output = (0, import_child_process2.execFileSync)("qmd", withQmdIndexArgs(["collection", "list"], indexName), { encoding: "utf-8" });
-  const names = parseQmdCollectionsText(output);
-  if (names.includes(collection)) {
-    return "present";
-  }
-  return "missing";
-}
-function loadCheckpoint(vaultPath) {
-  const checkpointPath = path8.join(vaultPath, CLAWVAULT_DIR, CHECKPOINT_FILE);
-  if (!fs7.existsSync(checkpointPath)) {
-    return { data: null };
-  }
-  try {
-    const data = JSON.parse(fs7.readFileSync(checkpointPath, "utf-8"));
-    return { data };
-  } catch (err) {
-    return { data: null, error: err?.message || "Failed to parse checkpoint" };
-  }
-}
-async function getStatus(vaultPath, options = {}) {
-  if (!hasQmd()) {
-    throw new QmdUnavailableError();
-  }
-  const vault = new ClawVault(path8.resolve(vaultPath));
-  await vault.load();
-  const stats = await vault.stats();
-  const linkScan = scanVaultLinks(vault.getPath());
-  const issues = [];
-  const checkpointInfo = loadCheckpoint(vault.getPath());
-  const checkpoint = checkpointInfo.data;
-  if (checkpointInfo.error) {
-    issues.push(`Checkpoint parse error: ${checkpointInfo.error}`);
-  }
-  const checkpointStatus = {
-    exists: Boolean(checkpoint),
-    timestamp: checkpoint?.timestamp,
-    age: checkpoint?.timestamp ? formatAge(Date.now() - new Date(checkpoint.timestamp).getTime()) : void 0,
-    sessionKey: checkpoint?.sessionKey,
-    model: checkpoint?.model,
-    tokenEstimate: checkpoint?.tokenEstimate
-  };
-  if (!checkpointStatus.exists) {
-    issues.push("No checkpoint found");
-  }
-  const dirtyFlagPath = path8.join(vault.getPath(), CLAWVAULT_DIR, DIRTY_DEATH_FLAG);
-  if (fs7.existsSync(dirtyFlagPath)) {
-    issues.push("Dirty death flag is set");
-  }
-  const qmdCollection = vault.getQmdCollection();
-  const qmdRoot = vault.getQmdRoot();
-  let qmdIndexStatus = "missing";
-  let qmdError;
-  try {
-    qmdIndexStatus = getQmdIndexStatus(qmdCollection, qmdRoot, options.qmdIndexName);
-    if (qmdIndexStatus !== "present") {
-      issues.push(`qmd collection ${qmdIndexStatus.replace("-", " ")}`);
-    }
-  } catch (err) {
-    qmdError = err?.message || "Failed to check qmd index";
-    issues.push(`qmd status error: ${qmdError}`);
-  }
-  let gitStatus;
-  const gitRoot = findGitRoot(vault.getPath());
-  if (gitRoot) {
-    try {
-      const gitInfo = getGitStatus(gitRoot);
-      gitStatus = { repoRoot: gitRoot, ...gitInfo };
-      if (!gitInfo.clean) {
-        issues.push(`Uncommitted changes: ${gitInfo.dirtyCount}`);
-      }
-    } catch (err) {
-      issues.push(`Git status error: ${err?.message || "unknown error"}`);
-    }
-  }
-  const graphIndex = loadMemoryGraphIndex(vault.getPath());
-  let graphStatus = {
-    indexStatus: "missing"
-  };
-  if (!graphIndex) {
-    issues.push("Memory graph index missing");
-  } else {
-    const generatedAt = graphIndex.generatedAt;
-    const latestDocMtime = getLatestVaultMarkdownMtime(vault.getPath());
-    const isStale = latestDocMtime ? latestDocMtime.getTime() > new Date(generatedAt).getTime() + 1e3 : false;
-    graphStatus = {
-      indexStatus: isStale ? "stale" : "present",
-      generatedAt,
-      nodeCount: graphIndex.graph.stats.nodeCount,
-      edgeCount: graphIndex.graph.stats.edgeCount
-    };
-    if (isStale) {
-      issues.push("Memory graph index stale");
-    }
-  }
-  const observerStaleness = getObserverStaleness(vault.getPath());
-  if (observerStaleness.staleCount > 0) {
-    issues.push(`Observer stale sessions: ${observerStaleness.staleCount}`);
-  }
-  return {
-    vaultName: vault.getName(),
-    vaultPath: vault.getPath(),
-    health: issues.length === 0 ? "ok" : "warning",
-    issues,
-    checkpoint: checkpointStatus,
-    qmd: {
-      collection: qmdCollection,
-      root: qmdRoot,
-      indexStatus: qmdIndexStatus,
-      error: qmdError
-    },
-    graph: graphStatus,
-    observer: observerStaleness,
-    git: gitStatus,
-    links: {
-      total: linkScan.linkCount,
-      orphans: linkScan.orphans.length
-    },
-    documents: stats.documents,
-    categories: stats.categories
-  };
-}
-function formatStatus(status) {
-  let output = "ClawVault Status\n";
-  output += "-".repeat(40) + "\n";
-  output += `Vault: ${status.vaultName}
-`;
-  output += `Path: ${status.vaultPath}
-`;
-  output += `Health: ${status.health}
-`;
-  if (status.issues.length > 0) {
-    output += `Issues: ${status.issues.join("; ")}
-`;
-  } else {
-    output += "Issues: none\n";
-  }
-  output += "\nCheckpoint:\n";
-  if (!status.checkpoint.exists) {
-    output += "  - none\n";
-  } else {
-    output += `  - Timestamp: ${status.checkpoint.timestamp}
-`;
-    if (status.checkpoint.age) {
-      output += `  - Age: ${status.checkpoint.age}
-`;
-    }
-    if (status.checkpoint.sessionKey) {
-      output += `  - Session key: ${status.checkpoint.sessionKey}
-`;
-    }
-    if (status.checkpoint.model) {
-      output += `  - Model: ${status.checkpoint.model}
-`;
-    }
-    if (status.checkpoint.tokenEstimate !== void 0) {
-      output += `  - Token estimate: ${status.checkpoint.tokenEstimate}
-`;
-    }
-  }
-  output += "\nqmd:\n";
-  output += `  - Collection: ${status.qmd.collection}
-`;
-  output += `  - Root: ${status.qmd.root}
-`;
-  output += `  - Index: ${status.qmd.indexStatus}
-`;
-  if (status.qmd.error) {
-    output += `  - Error: ${status.qmd.error}
-`;
-  }
-  if (status.git) {
-    output += "\nGit:\n";
-    output += `  - Repo: ${status.git.repoRoot}
-`;
-    output += `  - Status: ${status.git.clean ? "clean" : "dirty"} (${status.git.dirtyCount} change(s))
-`;
-  }
-  output += "\nGraph:\n";
-  output += `  - Index: ${status.graph.indexStatus}
-`;
-  if (status.graph.generatedAt) {
-    output += `  - Generated: ${status.graph.generatedAt}
-`;
-  }
-  if (status.graph.nodeCount !== void 0 && status.graph.edgeCount !== void 0) {
-    output += `  - Size: ${status.graph.nodeCount} nodes, ${status.graph.edgeCount} edges
-`;
-  }
-  output += "\nObserver:\n";
-  output += `  - Stale sessions: ${status.observer.staleCount}
-`;
-  if (status.observer.staleCount > 0) {
-    output += `  - Oldest stale age: ${formatAge(status.observer.oldestMs)}
-`;
-    output += `  - Newest stale age: ${formatAge(status.observer.newestMs)}
-`;
-  }
-  output += "\nLinks:\n";
-  output += `  - Total: ${status.links.total}
-`;
-  if (status.links.orphans > 0) {
-    output += `  - Orphans: ${status.links.orphans}
-`;
-  }
-  output += "\nDocuments:\n";
-  output += `  - Total: ${status.documents}
-`;
-  output += "  - By category:\n";
-  for (const [category, count] of Object.entries(status.categories)) {
-    output += `    * ${category}: ${count}
-`;
-  }
-  output += "-".repeat(40) + "\n";
-  return output;
-}
-async function statusCommand(vaultPath, options = {}) {
-  const status = await getStatus(vaultPath, { qmdIndexName: options.qmdIndexName });
-  if (options.json) {
-    console.log(JSON.stringify(status, null, 2));
-    return;
-  }
-  console.log(formatStatus(status));
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  formatStatus,
-  getStatus,
-  statusCommand
-});