clawvault 3.0.0 → 3.2.0

package/dist/commands/context.cjs

@@ -1,2989 +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/context.ts
-var context_exports = {};
-__export(context_exports, {
-  buildContext: () => buildContext,
-  contextCommand: () => contextCommand,
-  formatContextMarkdown: () => formatContextMarkdown,
-  registerContextCommand: () => registerContextCommand
-});
-module.exports = __toCommonJS(context_exports);
-var path5 = __toESM(require("path"), 1);
-
-// src/lib/vault.ts
-var fs4 = __toESM(require("fs"), 1);
-var path4 = __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 fs2 = __toESM(require("fs"), 1);
-var path2 = __toESM(require("path"), 1);
-
-// src/lib/observation-format.ts
-var DATE_HEADING_RE = /^##\s+(\d{4}-\d{2}-\d{2})\s*$/;
-var SCORED_LINE_RE = /^(?:-\s*)?\[(decision|preference|fact|commitment|task|todo|commitment-unresolved|milestone|lesson|relationship|project)\|c=(0(?:\.\d+)?|1(?:\.0+)?)\|i=(0(?:\.\d+)?|1(?:\.0+)?)\]\s+(.+)$/i;
-var EMOJI_LINE_RE = /^(?:-\s*)?(🔴|🟡|🟢)\s+(\d{2}:\d{2})?\s*(.+)$/u;
-var DECISION_RE = /\b(decis(?:ion|ions)?|decid(?:e|ed|ing)|chose|selected|opted|went with|picked)\b/i;
-var PREFERENCE_RE = /\b(prefer(?:ence|s|red)?|likes?|dislikes?|default to|always use|never use|enjoys?|loves?|favou?rite|fan of|interested in|go-to|tend(?:s)? to use|passionate about|hobby|hobbies|(?:I|my|our)\s+(?:own|have|use|got|bought|drive|wear|eat|drink|cook|play|watch|read|listen)|(?:I(?:'m| am))\s+(?:a |an |into |allergic|vegetarian|vegan|gluten|lactose|trying to|learning)|usually|every (?:morning|evening|night|day|week)|routine)\b/i;
-var COMMITMENT_RE = /\b(commit(?:ment|ted)?|promised|deadline|due|scheduled|will deliver|agreed to)\b/i;
-var TODO_RE = /(?:\btodo:\s*|\bwe need to\b|\bdon't forget(?: to)?\b|\bremember to\b|\bmake sure to\b)/i;
-var COMMITMENT_TASK_RE = /\b(?:i'?ll|i will|let me|(?:i'?m\s+)?going to|plan to|should)\b/i;
-var UNRESOLVED_RE = /\b(?:need to figure out|tbd|to be determined)\b/i;
-var DEADLINE_RE = /\b(?:by\s+(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday|tomorrow)|before\s+the\s+\w+|deadline is)\b/i;
-var MILESTONE_RE = /\b(released?|shipped|launched|merged|published|milestone|v\d+\.\d+)\b/i;
-var LESSON_RE = /\b(learn(?:ed|ing|t)|lesson|insight|realized|discovered|never again)\b/i;
-var RELATIONSHIP_RE = /\b(talked to|met with|spoke with|asked|client|partner|teammate|colleague)\b/i;
-var PROJECT_RE = /\b(project|feature|service|repo|api|roadmap|sprint)\b/i;
-function clamp01(value) {
-  if (!Number.isFinite(value)) return 0;
-  if (value < 0) return 0;
-  if (value > 1) return 1;
-  return value;
-}
-function scoreFromLegacyPriority(priority) {
-  if (priority === "\u{1F534}") return 0.9;
-  if (priority === "\u{1F7E1}") return 0.6;
-  return 0.2;
-}
-function confidenceFromLegacyPriority(priority) {
-  if (priority === "\u{1F534}") return 0.9;
-  if (priority === "\u{1F7E1}") return 0.8;
-  return 0.7;
-}
-function inferObservationType(content) {
-  if (DECISION_RE.test(content)) return "decision";
-  if (UNRESOLVED_RE.test(content)) return "commitment-unresolved";
-  if (TODO_RE.test(content)) return "todo";
-  if (PREFERENCE_RE.test(content)) return "preference";
-  if (COMMITMENT_TASK_RE.test(content) || DEADLINE_RE.test(content)) return "task";
-  if (COMMITMENT_RE.test(content)) return "commitment";
-  if (MILESTONE_RE.test(content)) return "milestone";
-  if (LESSON_RE.test(content)) return "lesson";
-  if (RELATIONSHIP_RE.test(content)) return "relationship";
-  if (PROJECT_RE.test(content)) return "project";
-  return "fact";
-}
-function parseObservationLine(line, date) {
-  const scored = line.match(SCORED_LINE_RE);
-  if (scored) {
-    return {
-      date,
-      type: scored[1].toLowerCase(),
-      confidence: clamp01(Number.parseFloat(scored[2])),
-      importance: clamp01(Number.parseFloat(scored[3])),
-      content: scored[4].trim(),
-      format: "scored",
-      rawLine: line
-    };
-  }
-  const emoji = line.match(EMOJI_LINE_RE);
-  if (!emoji) {
-    return null;
-  }
-  const priority = emoji[1];
-  const time = emoji[2]?.trim();
-  const text = emoji[3].trim();
-  const content = time ? `${time} ${text}` : text;
-  return {
-    date,
-    type: inferObservationType(content),
-    confidence: confidenceFromLegacyPriority(priority),
-    importance: scoreFromLegacyPriority(priority),
-    content,
-    format: "emoji",
-    priority,
-    time,
-    rawLine: line
-  };
-}
-function parseObservationMarkdown(markdown) {
-  const parsed = [];
-  let currentDate = "";
-  for (const line of markdown.split(/\r?\n/)) {
-    const heading = line.match(DATE_HEADING_RE);
-    if (heading) {
-      currentDate = heading[1];
-      continue;
-    }
-    if (!currentDate) {
-      continue;
-    }
-    const record = parseObservationLine(line.trim(), currentDate);
-    if (record) {
-      parsed.push(record);
-    }
-  }
-  return parsed;
-}
-
-// src/lib/ledger.ts
-var fs = __toESM(require("fs"), 1);
-var path = __toESM(require("path"), 1);
-var DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
-var YEAR_RE = /^\d{4}$/;
-var MONTH_RE = /^(0[1-9]|1[0-2])$/;
-var DAY_FILE_RE = /^(0[1-9]|[12]\d|3[01])\.md$/;
-var RAW_DAY_FILE_RE = /^(0[1-9]|[12]\d|3[01])\.jsonl$/;
-function walkThreeLevelDateTree(rootPath, extension) {
-  if (!fs.existsSync(rootPath)) {
-    return [];
-  }
-  const results = [];
-  for (const yearEntry of fs.readdirSync(rootPath, { withFileTypes: true })) {
-    if (!yearEntry.isDirectory() || !YEAR_RE.test(yearEntry.name)) continue;
-    const yearDir = path.join(rootPath, yearEntry.name);
-    for (const monthEntry of fs.readdirSync(yearDir, { withFileTypes: true })) {
-      if (!monthEntry.isDirectory() || !MONTH_RE.test(monthEntry.name)) continue;
-      const monthDir = path.join(yearDir, monthEntry.name);
-      for (const dayEntry of fs.readdirSync(monthDir, { withFileTypes: true })) {
-        if (!dayEntry.isFile()) continue;
-        const matches = extension === ".md" ? DAY_FILE_RE.test(dayEntry.name) : RAW_DAY_FILE_RE.test(dayEntry.name);
-        if (!matches) continue;
-        const day = dayEntry.name.slice(0, extension.length * -1);
-        const date = `${yearEntry.name}-${monthEntry.name}-${day}`;
-        if (!DATE_RE.test(date)) continue;
-        results.push({
-          date,
-          absolutePath: path.join(monthDir, dayEntry.name)
-        });
-      }
-    }
-  }
-  return results;
-}
-function inDateRange(date, fromDate, toDate) {
-  if (fromDate && date < fromDate) {
-    return false;
-  }
-  if (toDate && date > toDate) {
-    return false;
-  }
-  return true;
-}
-function getLedgerRoot(vaultPath) {
-  return path.join(path.resolve(vaultPath), "ledger");
-}
-function getObservationsRoot(vaultPath) {
-  return path.join(getLedgerRoot(vaultPath), "observations");
-}
-function getArchiveObservationsRoot(vaultPath) {
-  return path.join(getLedgerRoot(vaultPath), "archive", "observations");
-}
-function getLegacyObservationsRoot(vaultPath) {
-  return path.join(path.resolve(vaultPath), "observations");
-}
-function listLedgerObservationFiles(vaultPath, options = {}) {
-  return walkThreeLevelDateTree(getObservationsRoot(vaultPath), ".md").filter((entry) => inDateRange(entry.date, options.fromDate, options.toDate)).map((entry) => ({
-    date: entry.date,
-    path: entry.absolutePath,
-    location: "ledger"
-  })).sort((left, right) => left.date.localeCompare(right.date));
-}
-function listArchiveObservationFiles(vaultPath, options = {}) {
-  return walkThreeLevelDateTree(getArchiveObservationsRoot(vaultPath), ".md").filter((entry) => inDateRange(entry.date, options.fromDate, options.toDate)).map((entry) => ({
-    date: entry.date,
-    path: entry.absolutePath,
-    location: "archive"
-  })).sort((left, right) => left.date.localeCompare(right.date));
-}
-function listLegacyObservationFiles(vaultPath, options = {}) {
-  const legacyRoot = getLegacyObservationsRoot(vaultPath);
-  if (!fs.existsSync(legacyRoot)) {
-    return [];
-  }
-  return fs.readdirSync(legacyRoot, { withFileTypes: true }).filter((entry) => entry.isFile() && DATE_RE.test(entry.name.replace(/\.md$/, "")) && entry.name.endsWith(".md")).map((entry) => {
-    const date = entry.name.replace(/\.md$/, "");
-    return {
-      date,
-      path: path.join(legacyRoot, entry.name),
-      location: "legacy"
-    };
-  }).filter((entry) => inDateRange(entry.date, options.fromDate, options.toDate)).sort((left, right) => left.date.localeCompare(right.date));
-}
-function listObservationFiles(vaultPath, options = {}) {
-  const includeLegacy = options.includeLegacy ?? true;
-  const includeArchive = options.includeArchive ?? false;
-  const dedupeByDate = options.dedupeByDate ?? true;
-  const files = [
-    ...listLedgerObservationFiles(vaultPath, options),
-    ...includeLegacy ? listLegacyObservationFiles(vaultPath, options) : [],
-    ...includeArchive ? listArchiveObservationFiles(vaultPath, options) : []
-  ];
-  if (!dedupeByDate) {
-    return files.sort((left, right) => left.date.localeCompare(right.date));
-  }
-  const byDate = /* @__PURE__ */ new Map();
-  const locationRank = {
-    ledger: 3,
-    legacy: 2,
-    archive: 1
-  };
-  for (const file of files) {
-    const existing = byDate.get(file.date);
-    if (!existing || locationRank[file.location] > locationRank[existing.location]) {
-      byDate.set(file.date, file);
-    }
-  }
-  return [...byDate.values()].sort((left, right) => left.date.localeCompare(right.date));
-}
-
-// 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 = path2.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 ? path2.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(path2.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 || path2.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 fs2.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 path2.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 fs3 = __toESM(require("fs"), 1);
-var path3 = __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 = path3.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(path3.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 = path3.join(vaultPath, ".clawvault");
-  if (!fs3.existsSync(dirPath)) {
-    fs3.mkdirSync(dirPath, { recursive: true });
-  }
-  return dirPath;
-}
-function getGraphIndexPath(vaultPath) {
-  return path3.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 = path3.join(vaultPath, relativePath);
-  const raw = fs3.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(path3.resolve(vaultPath));
-  if (!fs3.existsSync(indexPath)) {
-    return null;
-  }
-  try {
-    const parsed = JSON.parse(fs3.readFileSync(indexPath, "utf-8"));
-    if (!isValidIndex(parsed)) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-async function buildOrUpdateMemoryGraphIndex(vaultPathInput, options = {}) {
-  const vaultPath = path3.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 = path3.join(vaultPath, relativePath);
-    const stat = fs3.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
-  };
-  fs3.writeFileSync(getGraphIndexPath(vaultPath), JSON.stringify(nextIndex, null, 2));
-  return nextIndex;
-}
-async function getMemoryGraph(vaultPath, options = {}) {
-  if (options.refresh === true) {
-    return (await buildOrUpdateMemoryGraphIndex(vaultPath, { forceFull: true })).graph;
-  }
-  return (await buildOrUpdateMemoryGraphIndex(vaultPath)).graph;
-}
-
-// 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: path4.resolve(vaultPath),
-      name: path4.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 (!fs4.existsSync(vaultPath)) {
-      fs4.mkdirSync(vaultPath, { recursive: true });
-    }
-    for (const category of this.config.categories) {
-      const catPath = path4.join(vaultPath, category);
-      if (!fs4.existsSync(catPath)) {
-        fs4.mkdirSync(catPath, { recursive: true });
-      }
-    }
-    const ledgerDirs = ["ledger/raw", "ledger/observations", "ledger/reflections"];
-    for (const dir of ledgerDirs) {
-      const dirPath = path4.join(vaultPath, dir);
-      if (!fs4.existsSync(dirPath)) {
-        fs4.mkdirSync(dirPath, { recursive: true });
-      }
-    }
-    await this.createTemplates();
-    const readmePath = path4.join(vaultPath, "README.md");
-    if (!fs4.existsSync(readmePath)) {
-      fs4.writeFileSync(readmePath, this.generateReadme());
-    }
-    await this.createWelcomeNote();
-    const configPath = path4.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()
-    };
-    fs4.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 = path4.join(vaultPath, filename);
-      if (!fs4.existsSync(filePath)) {
-        fs4.writeFileSync(filePath, content);
-      }
-    }
-  }
-  /**
-   * Load an existing vault
-   */
-  async load() {
-    if (!hasQmd()) {
-      throw new QmdUnavailableError();
-    }
-    const vaultPath = this.config.path;
-    const configPath = path4.join(vaultPath, CONFIG_FILE);
-    if (!fs4.existsSync(configPath)) {
-      throw new Error(`Not a ClawVault: ${vaultPath} (missing ${CONFIG_FILE})`);
-    }
-    const meta = JSON.parse(fs4.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;
-      fs4.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 = path4.join(this.config.path, relativePath);
-      const content = fs4.readFileSync(fullPath, "utf-8");
-      const { data: frontmatter, content: body } = (0, import_gray_matter2.default)(content);
-      const stats = fs4.statSync(fullPath);
-      const parts = relativePath.split(path4.sep);
-      const category = parts.length > 1 ? parts[0] : "root";
-      const filename = path4.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 = path4.join(category, filename);
-    const fullPath = path4.join(this.config.path, relativePath);
-    if (fs4.existsSync(fullPath) && !overwrite) {
-      throw new Error(`Document already exists: ${relativePath}. Use overwrite: true to replace.`);
-    }
-    const categoryPath = path4.join(this.config.path, category);
-    if (!fs4.existsSync(categoryPath)) {
-      fs4.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);
-    fs4.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 && !fs4.existsSync(target)) {
-      fs4.mkdirSync(target, { recursive: true });
-    }
-    for (const file of sourceFiles) {
-      const sourcePath = path4.join(this.config.path, file);
-      const targetPath = path4.join(target, file);
-      try {
-        const sourceStats = fs4.statSync(sourcePath);
-        let shouldCopy = true;
-        if (fs4.existsSync(targetPath)) {
-          const targetStats = fs4.statSync(targetPath);
-          if (sourceStats.mtime <= targetStats.mtime) {
-            result.unchanged.push(file);
-            shouldCopy = false;
-          }
-        }
-        if (shouldCopy) {
-          if (!dryRun) {
-            const targetDir = path4.dirname(targetPath);
-            if (!fs4.existsSync(targetDir)) {
-              fs4.mkdirSync(targetDir, { recursive: true });
-            }
-            fs4.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) {
-            fs4.unlinkSync(path4.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 = path4.join(this.config.path, INDEX_FILE);
-    const data = this.search.export();
-    fs4.writeFileSync(indexPath, JSON.stringify(data, null, 2));
-    const configPath = path4.join(this.config.path, CONFIG_FILE);
-    if (fs4.existsSync(configPath)) {
-      const meta = JSON.parse(fs4.readFileSync(configPath, "utf-8"));
-      meta.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-      meta.documentCount = this.search.size;
-      fs4.writeFileSync(configPath, JSON.stringify(meta, null, 2));
-    }
-  }
-  async createTemplates() {
-    const templatesPath = path4.join(this.config.path, "templates");
-    if (!fs4.existsSync(templatesPath)) {
-      fs4.mkdirSync(templatesPath, { recursive: true });
-    }
-    const moduleDir = path4.dirname((0, import_url.fileURLToPath)(import_meta.url));
-    const candidates = [
-      path4.resolve(moduleDir, "../templates"),
-      path4.resolve(moduleDir, "../../templates")
-    ];
-    const builtinDir = candidates.find((dir) => fs4.existsSync(dir) && fs4.statSync(dir).isDirectory());
-    if (!builtinDir) return;
-    for (const entry of fs4.readdirSync(builtinDir, { withFileTypes: true })) {
-      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      if (entry.name === "daily.md") continue;
-      const sourcePath = path4.join(builtinDir, entry.name);
-      const targetPath = path4.join(templatesPath, entry.name);
-      if (!fs4.existsSync(targetPath)) {
-        fs4.copyFileSync(sourcePath, targetPath);
-      }
-    }
-  }
-  async createWelcomeNote() {
-    if (!this.config.categories.includes("inbox")) return;
-    const inboxPath = path4.join(this.config.path, "inbox", "welcome.md");
-    if (fs4.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.*
-`;
-    fs4.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/observation-reader.ts
-var fs5 = __toESM(require("fs"), 1);
-function readObservations(vaultPath, days = 7) {
-  const normalizedDays = Number.isFinite(days) ? Math.max(0, Math.floor(days)) : 0;
-  if (normalizedDays === 0) {
-    return "";
-  }
-  const files = listObservationFiles(vaultPath, {
-    includeLegacy: true,
-    includeArchive: false,
-    dedupeByDate: true
-  }).sort((left, right) => right.date.localeCompare(left.date)).slice(0, normalizedDays);
-  if (files.length === 0) {
-    return "";
-  }
-  return files.map((entry) => fs5.readFileSync(entry.path, "utf-8").trim()).filter(Boolean).join("\n\n").trim();
-}
-function parseObservationLines(markdown) {
-  return parseObservationMarkdown(markdown).map((record) => ({
-    type: record.type,
-    confidence: record.confidence,
-    importance: record.importance,
-    content: record.content,
-    date: record.date,
-    format: record.format,
-    priority: record.priority
-  }));
-}
-
-// src/lib/token-counter.ts
-function estimateTokens(text) {
-  if (!text) {
-    return 0;
-  }
-  return Math.ceil(text.length / 4);
-}
-function fitWithinBudget(items, budget) {
-  if (!Number.isFinite(budget) || budget <= 0) {
-    return [];
-  }
-  const sorted = items.map((item, index) => ({ ...item, index })).sort((a, b) => {
-    if (a.priority !== b.priority) {
-      return a.priority - b.priority;
-    }
-    return a.index - b.index;
-  });
-  let remaining = Math.floor(budget);
-  const fitted = [];
-  for (const item of sorted) {
-    if (!item.text.trim()) {
-      continue;
-    }
-    const cost = estimateTokens(item.text);
-    if (cost <= remaining) {
-      fitted.push({ text: item.text, source: item.source });
-      remaining -= cost;
-    }
-    if (remaining <= 0) {
-      break;
-    }
-  }
-  return fitted;
-}
-
-// src/lib/context-profile.ts
-var INCIDENT_PROMPT_RE = /\b(outage|incident|sev[1-4]|p[0-3]|broken|failure|urgent|rollback|hotfix|degraded)\b/i;
-var PLANNING_PROMPT_RE = /\b(plan|planning|design|architecture|roadmap|proposal|spec|migrate|migration|approach)\b/i;
-var HANDOFF_PROMPT_RE = /\b(resume|continue|handoff|pick up|where (did|was) i|last session)\b/i;
-function inferContextProfile(task) {
-  const normalizedTask = task.trim();
-  if (!normalizedTask) {
-    return "default";
-  }
-  if (INCIDENT_PROMPT_RE.test(normalizedTask)) return "incident";
-  if (HANDOFF_PROMPT_RE.test(normalizedTask)) return "handoff";
-  if (PLANNING_PROMPT_RE.test(normalizedTask)) return "planning";
-  return "default";
-}
-function normalizeContextProfileInput(profile) {
-  if (profile === "planning" || profile === "incident" || profile === "handoff" || profile === "auto") {
-    return profile;
-  }
-  return "default";
-}
-function resolveContextProfile(profile, task) {
-  const normalized = normalizeContextProfileInput(profile);
-  if (normalized === "auto") {
-    return inferContextProfile(task);
-  }
-  return normalized;
-}
-
-// src/commands/context.ts
-var DEFAULT_LIMIT = 5;
-var MAX_SNIPPET_LENGTH = 320;
-var OBSERVATION_LOOKBACK_DAYS = 7;
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  "a",
-  "an",
-  "and",
-  "are",
-  "as",
-  "at",
-  "be",
-  "by",
-  "for",
-  "from",
-  "how",
-  "in",
-  "is",
-  "it",
-  "of",
-  "on",
-  "or",
-  "that",
-  "the",
-  "this",
-  "to",
-  "was",
-  "were",
-  "what",
-  "when",
-  "where",
-  "who",
-  "why",
-  "with",
-  "you",
-  "your"
-]);
-function formatRelativeAge(date, now = Date.now()) {
-  const ageMs = Math.max(0, now - date.getTime());
-  const days = Math.floor(ageMs / (24 * 60 * 60 * 1e3));
-  if (days === 0) return "today";
-  if (days < 7) return `${days} day${days === 1 ? "" : "s"} ago`;
-  const weeks = Math.floor(days / 7);
-  if (weeks < 5) return `${weeks} week${weeks === 1 ? "" : "s"} ago`;
-  const months = Math.floor(days / 30);
-  if (months < 12) return `${months} month${months === 1 ? "" : "s"} ago`;
-  const years = Math.floor(days / 365);
-  return `${years} year${years === 1 ? "" : "s"} ago`;
-}
-function normalizeSnippet(result) {
-  const source = (result.snippet || result.document.content || "").trim();
-  if (!source) return "No snippet available.";
-  return source.replace(/\s+/g, " ").slice(0, MAX_SNIPPET_LENGTH);
-}
-function formatContextMarkdown(task, entries) {
-  let output = `## Relevant Context for: ${task}
-
-`;
-  if (entries.length === 0) {
-    output += "_No relevant context found._\n";
-    return output;
-  }
-  for (const entry of entries) {
-    output += `### ${entry.title} (${entry.source}, score: ${entry.score.toFixed(2)}, ${entry.age})
-`;
-    output += `${entry.snippet}
-
-`;
-  }
-  return output.trimEnd();
-}
-var PROFILE_ORDERING = {
-  default: {
-    order: ["structural", "daily", "search", "graph", "potential", "contextual"],
-    caps: {}
-  },
-  planning: {
-    order: ["search", "graph", "structural", "potential", "daily", "contextual"],
-    caps: { observation: 12, graph: 12 }
-  },
-  incident: {
-    order: ["structural", "search", "potential", "daily", "graph", "contextual"],
-    caps: { observation: 20, graph: 8 }
-  },
-  handoff: {
-    order: ["daily", "structural", "potential", "search", "graph", "contextual"],
-    caps: { "daily-note": 2, observation: 15 }
-  }
-};
-function extractKeywords(text) {
-  const raw = text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
-  const seen = /* @__PURE__ */ new Set();
-  const keywords = [];
-  for (const token of raw) {
-    if (token.length < 2 || STOP_WORDS.has(token) || seen.has(token)) {
-      continue;
-    }
-    seen.add(token);
-    keywords.push(token);
-  }
-  return keywords;
-}
-function computeKeywordOverlapScore(queryKeywords, text) {
-  if (queryKeywords.length === 0) {
-    return 1;
-  }
-  const haystack = new Set(extractKeywords(text));
-  let matches = 0;
-  for (const keyword of queryKeywords) {
-    if (haystack.has(keyword)) {
-      matches += 1;
-    }
-  }
-  if (matches === 0) {
-    return 0.1;
-  }
-  return matches / queryKeywords.length;
-}
-function estimateSnippet(source) {
-  const normalized = source.replace(/\s+/g, " ").trim();
-  if (!normalized) {
-    return "No snippet available.";
-  }
-  return normalized.slice(0, MAX_SNIPPET_LENGTH);
-}
-function parseIsoDate(value) {
-  if (typeof value === "string") {
-    const trimmed = value.trim();
-    if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
-      return trimmed;
-    }
-    if (/^\d{4}-\d{2}-\d{2}T/.test(trimmed)) {
-      return trimmed.slice(0, 10);
-    }
-  }
-  if (value instanceof Date) {
-    const time = value.getTime();
-    if (!Number.isNaN(time)) {
-      return value.toISOString().slice(0, 10);
-    }
-  }
-  return null;
-}
-function asDate(value, fallback = /* @__PURE__ */ new Date(0)) {
-  if (!value) {
-    return fallback;
-  }
-  const parsed = /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`);
-  return Number.isNaN(parsed.getTime()) ? fallback : parsed;
-}
-function observationImportanceToRank(importance) {
-  if (importance >= 0.8) return 1;
-  if (importance >= 0.4) return 4;
-  return 5;
-}
-function toLedgerObservationPath(date) {
-  if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
-    return `ledger/observations/${date}.md`;
-  }
-  const [year, month, day] = date.split("-");
-  return `ledger/observations/${year}/${month}/${day}.md`;
-}
-function isLikelyDailyNote(document) {
-  const normalizedPath = document.path.split(path5.sep).join("/").toLowerCase();
-  if (normalizedPath.includes("/daily/")) {
-    return true;
-  }
-  const category = document.category.toLowerCase();
-  if (category.includes("daily")) {
-    return true;
-  }
-  const type = typeof document.frontmatter.type === "string" ? document.frontmatter.type.toLowerCase() : "";
-  return type === "daily";
-}
-function findDailyDate(document, targetDates) {
-  const frontmatterDate = parseIsoDate(document.frontmatter.date);
-  const titleDate = parseIsoDate(document.title);
-  const fileDate = parseIsoDate(path5.basename(document.path, ".md"));
-  const candidates = [frontmatterDate, titleDate, fileDate].filter((value) => Boolean(value));
-  for (const candidate of candidates) {
-    if (!targetDates.has(candidate)) {
-      continue;
-    }
-    if (isLikelyDailyNote(document) || titleDate === candidate || fileDate === candidate) {
-      return candidate;
-    }
-  }
-  return null;
-}
-function getTargetDailyDates(now = /* @__PURE__ */ new Date()) {
-  const today = now.toISOString().slice(0, 10);
-  const yesterdayDate = new Date(now);
-  yesterdayDate.setDate(yesterdayDate.getDate() - 1);
-  const yesterday = yesterdayDate.toISOString().slice(0, 10);
-  return [today, yesterday];
-}
-function buildDailyContextItems(vaultPath, allDocuments) {
-  const targetDates = getTargetDailyDates();
-  const targetDateSet = new Set(targetDates);
-  const byDate = /* @__PURE__ */ new Map();
-  for (const document of allDocuments) {
-    const dailyDate = findDailyDate(document, targetDateSet);
-    if (!dailyDate) {
-      continue;
-    }
-    const existing = byDate.get(dailyDate);
-    if (!existing || document.modified.getTime() > existing.modified.getTime()) {
-      byDate.set(dailyDate, document);
-    }
-  }
-  const items = [];
-  for (const date of targetDates) {
-    const document = byDate.get(date);
-    if (!document) {
-      continue;
-    }
-    const relativePath = path5.relative(vaultPath, document.path).split(path5.sep).join("/");
-    const snippet = estimateSnippet(document.content);
-    items.push({
-      priority: 2,
-      entry: {
-        title: `Daily note ${date}`,
-        path: relativePath,
-        category: document.category,
-        score: 0.9,
-        snippet,
-        modified: document.modified.toISOString(),
-        age: formatRelativeAge(document.modified),
-        source: "daily-note",
-        signals: ["daily_recency"],
-        rationale: "Pinned daily note context (today/yesterday)."
-      }
-    });
-  }
-  return items;
-}
-function buildObservationContextItems(vaultPath, queryKeywords) {
-  const observationMarkdown = readObservations(vaultPath, OBSERVATION_LOOKBACK_DAYS);
-  const parsed = parseObservationLines(observationMarkdown);
-  const items = [];
-  for (const [index, observation] of parsed.entries()) {
-    const priority = observationImportanceToRank(observation.importance);
-    const modifiedDate = asDate(observation.date, /* @__PURE__ */ new Date());
-    const date = observation.date || modifiedDate.toISOString().slice(0, 10);
-    const snippet = estimateSnippet(observation.content);
-    items.push({
-      priority,
-      entry: {
-        title: `[${observation.type}|i=${observation.importance.toFixed(2)}] observation (${date}) #${index + 1}`,
-        path: toLedgerObservationPath(date),
-        category: "observations",
-        score: computeKeywordOverlapScore(queryKeywords, observation.content),
-        snippet,
-        modified: modifiedDate.toISOString(),
-        age: formatRelativeAge(modifiedDate),
-        source: "observation",
-        signals: ["observation_importance", `type:${observation.type}`, "keyword_overlap"],
-        rationale: `Observation type ${observation.type} with importance ${observation.importance.toFixed(2)} matched task keywords.`
-      }
-    });
-  }
-  return items;
-}
-function buildSearchContextItems(vault, results) {
-  return results.map((result) => {
-    const relativePath = path5.relative(vault.getPath(), result.document.path).split(path5.sep).join("/");
-    const entry = {
-      title: result.document.title,
-      path: relativePath,
-      category: result.document.category,
-      score: result.score,
-      snippet: normalizeSnippet(result),
-      modified: result.document.modified.toISOString(),
-      age: formatRelativeAge(result.document.modified),
-      source: "search",
-      signals: ["semantic_search"],
-      rationale: "Selected by semantic retrieval."
-    };
-    return {
-      priority: 3,
-      entry
-    };
-  });
-}
-function toNoteNodeId2(vaultPath, absolutePath) {
-  const relativePath = path5.relative(vaultPath, absolutePath).split(path5.sep).join("/");
-  const noteKey = relativePath.toLowerCase().endsWith(".md") ? relativePath.slice(0, -3) : relativePath;
-  return `note:${noteKey}`;
-}
-function buildGraphAdjacency(edges) {
-  const adjacency = /* @__PURE__ */ new Map();
-  for (const edge of edges) {
-    const sourceBucket = adjacency.get(edge.source) ?? [];
-    sourceBucket.push(edge);
-    adjacency.set(edge.source, sourceBucket);
-    const targetBucket = adjacency.get(edge.target) ?? [];
-    targetBucket.push(edge);
-    adjacency.set(edge.target, targetBucket);
-  }
-  return adjacency;
-}
-function edgeWeight(edge) {
-  if (edge.type === "frontmatter_relation") return 0.95;
-  if (edge.type === "wiki_link") return 0.8;
-  return 0.6;
-}
-function buildGraphContextItems(params) {
-  const { graph, vaultPath, documents, searchItems, limit, maxHops } = params;
-  if (searchItems.length === 0 || graph.nodes.length === 0 || graph.edges.length === 0 || maxHops <= 0) {
-    return [];
-  }
-  const graphNodeById = new Map(graph.nodes.map((node) => [node.id, node]));
-  const adjacency = buildGraphAdjacency(graph.edges);
-  const docByNodeId = /* @__PURE__ */ new Map();
-  for (const document of documents) {
-    docByNodeId.set(toNoteNodeId2(vaultPath, document.path), document);
-  }
-  const anchors = searchItems.map((item) => ({
-    item,
-    nodeId: toNoteNodeId2(vaultPath, path5.join(vaultPath, item.entry.path))
-  })).filter((anchor) => graphNodeById.has(anchor.nodeId));
-  const candidates = /* @__PURE__ */ new Map();
-  for (const anchor of anchors) {
-    const visited = /* @__PURE__ */ new Set([anchor.nodeId]);
-    const queue = [{ nodeId: anchor.nodeId, hop: 0 }];
-    while (queue.length > 0) {
-      const current = queue.shift();
-      if (current.hop >= maxHops) {
-        continue;
-      }
-      const connectedEdges = adjacency.get(current.nodeId) ?? [];
-      for (const edge of connectedEdges) {
-        const neighborId = edge.source === current.nodeId ? edge.target : edge.source;
-        if (visited.has(neighborId)) {
-          continue;
-        }
-        visited.add(neighborId);
-        queue.push({ nodeId: neighborId, hop: current.hop + 1 });
-        if (neighborId === anchor.nodeId) continue;
-        const neighborNode = graphNodeById.get(neighborId);
-        if (!neighborNode || neighborNode.type === "tag" || neighborNode.type === "unresolved" || neighborNode.missing === true) {
-          continue;
-        }
-        const neighborDoc = docByNodeId.get(neighborId);
-        if (!neighborDoc) {
-          continue;
-        }
-        const neighborPath = path5.relative(vaultPath, neighborDoc.path).split(path5.sep).join("/");
-        const modifiedAt = neighborDoc.modified;
-        const snippet = estimateSnippet(neighborDoc.content);
-        const hopPenalty = Math.pow(0.85, Math.max(0, current.hop));
-        const score = Math.max(0.05, Math.min(1, anchor.item.entry.score * edgeWeight(edge) * hopPenalty));
-        const key = neighborId;
-        const existing = candidates.get(key);
-        const candidate = {
-          priority: 3,
-          entry: {
-            title: neighborDoc.title,
-            path: neighborPath,
-            category: neighborDoc.category,
-            score,
-            snippet,
-            modified: modifiedAt.toISOString(),
-            age: formatRelativeAge(modifiedAt),
-            source: "graph",
-            signals: ["graph_neighbor", `edge:${edge.type}`, `hop:${current.hop + 1}`],
-            rationale: `Connected to "${anchor.item.entry.title}" within ${current.hop + 1} hop(s) via ${edge.type}${edge.label ? ` (${edge.label})` : ""}.`
-          }
-        };
-        if (!existing || existing.entry.score < candidate.entry.score) {
-          candidates.set(key, candidate);
-        }
-      }
-    }
-  }
-  return [...candidates.values()].sort((left, right) => right.entry.score - left.entry.score).slice(0, Math.max(limit, 1));
-}
-function dedupeContextItems(items) {
-  const deduped = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const key = `${item.entry.path}|${item.entry.source}|${item.entry.title}`;
-    const existing = deduped.get(key);
-    if (!existing || existing.entry.score < item.entry.score) {
-      deduped.set(key, item);
-    }
-  }
-  return [...deduped.values()];
-}
-function applySourceCaps(items, caps) {
-  const counts = {};
-  const capped = [];
-  for (const item of items) {
-    const source = item.entry.source;
-    const limit = caps[source];
-    if (limit !== void 0) {
-      const current = counts[source] ?? 0;
-      if (current >= limit) {
-        continue;
-      }
-      counts[source] = current + 1;
-    }
-    capped.push(item);
-  }
-  return capped;
-}
-function renderEntryBlock(entry) {
-  return `### ${entry.title} (${entry.source}, score: ${entry.score.toFixed(2)}, ${entry.age})
-${entry.snippet}
-
-`;
-}
-function truncateToBudget(text, budget) {
-  if (!Number.isFinite(budget) || budget <= 0) {
-    return "";
-  }
-  const maxChars = Math.max(0, Math.floor(budget) * 4);
-  if (text.length <= maxChars) {
-    return text;
-  }
-  return text.slice(0, maxChars).trimEnd();
-}
-function applyTokenBudget(items, task, budget) {
-  const fullContext = items.map((item) => item.entry);
-  const fullMarkdown = formatContextMarkdown(task, fullContext);
-  if (budget === void 0) {
-    return { context: fullContext, markdown: fullMarkdown };
-  }
-  const normalizedBudget = Math.max(1, Math.floor(budget));
-  if (estimateTokens(fullMarkdown) <= normalizedBudget) {
-    return { context: fullContext, markdown: fullMarkdown };
-  }
-  const header = `## Relevant Context for: ${task}
-
-`;
-  const headerCost = estimateTokens(header);
-  if (headerCost >= normalizedBudget) {
-    return {
-      context: [],
-      markdown: truncateToBudget(header.trimEnd(), normalizedBudget)
-    };
-  }
-  const fitted = fitWithinBudget(
-    items.map((item, index) => ({
-      text: renderEntryBlock(item.entry),
-      priority: item.priority,
-      source: String(index)
-    })),
-    normalizedBudget - headerCost
-  );
-  const selectedEntries = fitted.map((item) => {
-    const index = Number.parseInt(item.source, 10);
-    return Number.isNaN(index) ? null : items[index]?.entry ?? null;
-  }).filter((entry) => Boolean(entry));
-  if (selectedEntries.length === 0 && items.length > 0) {
-    const topEntry = items[0].entry;
-    return {
-      context: [topEntry],
-      markdown: truncateToBudget(formatContextMarkdown(task, [topEntry]), normalizedBudget)
-    };
-  }
-  const markdown = truncateToBudget(formatContextMarkdown(task, selectedEntries), normalizedBudget);
-  return {
-    context: selectedEntries,
-    markdown
-  };
-}
-async function buildContext(task, options) {
-  const normalizedTask = task.trim();
-  if (!normalizedTask) {
-    throw new Error("Task description is required.");
-  }
-  const vault = new ClawVault(path5.resolve(options.vaultPath));
-  await vault.load();
-  const limit = Math.max(1, options.limit ?? DEFAULT_LIMIT);
-  const recent = options.recent ?? true;
-  const includeObservations = options.includeObservations ?? true;
-  const maxHops = Math.max(1, Math.floor(options.maxHops ?? 2));
-  const profile = resolveContextProfile(options.profile, normalizedTask);
-  const queryKeywords = extractKeywords(normalizedTask);
-  const allDocuments = await vault.list();
-  const searchResults = await vault.vsearch(normalizedTask, {
-    limit,
-    temporalBoost: recent
-  });
-  const searchItems = buildSearchContextItems(vault, searchResults);
-  const dailyItems = buildDailyContextItems(vault.getPath(), allDocuments);
-  const observationItems = includeObservations ? buildObservationContextItems(vault.getPath(), queryKeywords) : [];
-  const graph = await getMemoryGraph(vault.getPath());
-  const graphItems = buildGraphContextItems({
-    graph,
-    vaultPath: vault.getPath(),
-    documents: allDocuments,
-    searchItems,
-    limit,
-    maxHops
-  });
-  const byScoreDesc = (left, right) => right.entry.score - left.entry.score;
-  const structuralObservations = observationItems.filter((item) => item.priority === 1).sort(byScoreDesc);
-  const potentialObservations = observationItems.filter((item) => item.priority === 4).sort(byScoreDesc);
-  const contextualObservations = observationItems.filter((item) => item.priority === 5).sort(byScoreDesc);
-  const sortedDailyItems = [...dailyItems].sort(byScoreDesc);
-  const sortedSearchItems = [...searchItems].sort(byScoreDesc);
-  const sortedGraphItems = [...graphItems].sort(byScoreDesc);
-  const grouped = {
-    structural: structuralObservations,
-    daily: sortedDailyItems,
-    search: sortedSearchItems,
-    graph: sortedGraphItems,
-    potential: potentialObservations,
-    contextual: contextualObservations
-  };
-  const ordering = PROFILE_ORDERING[profile];
-  const ordered = dedupeContextItems(
-    applySourceCaps(
-      ordering.order.flatMap((group) => grouped[group]),
-      ordering.caps
-    )
-  );
-  const { context, markdown } = applyTokenBudget(ordered, normalizedTask, options.budget);
-  return {
-    task: normalizedTask,
-    profile,
-    generated: (/* @__PURE__ */ new Date()).toISOString(),
-    context,
-    markdown
-  };
-}
-async function contextCommand(task, options) {
-  const result = await buildContext(task, options);
-  const format = options.format ?? "markdown";
-  if (format === "json") {
-    const context = result.context.map((entry) => ({
-      ...entry,
-      explain: {
-        signals: entry.signals ?? [],
-        rationale: entry.rationale ?? ""
-      }
-    }));
-    console.log(JSON.stringify({
-      task: result.task,
-      profile: result.profile,
-      generated: result.generated,
-      count: context.length,
-      context
-    }, null, 2));
-    return;
-  }
-  console.log(result.markdown);
-}
-function parsePositiveInteger(raw, label) {
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new Error(`Invalid ${label}: ${raw}`);
-  }
-  return parsed;
-}
-function registerContextCommand(program) {
-  program.command("context <task>").description("Generate task-relevant context for prompt injection").option("-n, --limit <n>", "Max results", "5").option("--format <format>", "Output format (markdown|json)", "markdown").option("--recent", "Boost recent documents (enabled by default)", true).option("--include-observations", "Include observation memories in output", true).option("--budget <number>", "Optional token budget for assembled context").option("--profile <profile>", "Context profile (default|planning|incident|handoff|auto)", "default").option("--max-hops <n>", "Maximum graph expansion hops", "2").option("-v, --vault <path>", "Vault path").action(async (task, rawOptions) => {
-    const format = rawOptions.format === "json" ? "json" : "markdown";
-    const budget = rawOptions.budget ? parsePositiveInteger(rawOptions.budget, "budget") : void 0;
-    const limit = parsePositiveInteger(rawOptions.limit, "limit");
-    const maxHops = parsePositiveInteger(rawOptions.maxHops, "max-hops");
-    const vaultPath = rawOptions.vault ?? process.env.CLAWVAULT_PATH ?? process.cwd();
-    await contextCommand(task, {
-      vaultPath,
-      limit,
-      format,
-      recent: rawOptions.recent ?? true,
-      includeObservations: rawOptions.includeObservations ?? true,
-      budget,
-      profile: normalizeContextProfileInput(rawOptions.profile),
-      maxHops
-    });
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  buildContext,
-  contextCommand,
-  formatContextMarkdown,
-  registerContextCommand
-});