clawvault 2.6.1 → 3.0.0

package/dist/commands/wake.cjs

@@ -0,0 +1,2626 @@
+"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/wake.ts
+var wake_exports = {};
+__export(wake_exports, {
+  buildWakeSummary: () => buildWakeSummary,
+  wake: () => wake
+});
+module.exports = __toCommonJS(wake_exports);
+var fs7 = __toESM(require("fs"), 1);
+var path7 = __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;
+}
+
+// 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/commands/checkpoint.ts
+var fs5 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
+var CLAWVAULT_DIR = ".clawvault";
+var CHECKPOINT_FILE = "last-checkpoint.json";
+var DIRTY_DEATH_FLAG = "dirty-death.flag";
+var CHECKPOINT_RETENTION_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+async function clearDirtyFlag(vaultPath) {
+  const flagPath = path5.join(vaultPath, CLAWVAULT_DIR, DIRTY_DEATH_FLAG);
+  if (fs5.existsSync(flagPath)) {
+    fs5.unlinkSync(flagPath);
+  }
+}
+async function checkDirtyDeath(vaultPath) {
+  const dir = path5.join(vaultPath, CLAWVAULT_DIR);
+  const flagPath = path5.join(dir, DIRTY_DEATH_FLAG);
+  const checkpointPath = path5.join(dir, CHECKPOINT_FILE);
+  if (!fs5.existsSync(flagPath)) {
+    return { died: false, checkpoint: null, deathTime: null };
+  }
+  const deathTime = fs5.readFileSync(flagPath, "utf-8").trim();
+  let checkpoint = null;
+  if (fs5.existsSync(checkpointPath)) {
+    try {
+      checkpoint = JSON.parse(fs5.readFileSync(checkpointPath, "utf-8"));
+    } catch {
+    }
+  }
+  return { died: true, checkpoint, deathTime };
+}
+
+// src/commands/recover.ts
+var fs6 = __toESM(require("fs"), 1);
+var path6 = __toESM(require("path"), 1);
+async function checkRecoveryStatus(vaultPath) {
+  const { died, checkpoint, deathTime } = await checkDirtyDeath(vaultPath);
+  return { died, checkpoint, deathTime };
+}
+async function recover(vaultPath, options = {}) {
+  const { clearFlag = false } = options;
+  const { died, checkpoint, deathTime } = await checkRecoveryStatus(vaultPath);
+  if (!died) {
+    return {
+      died: false,
+      deathTime: null,
+      checkpoint: null,
+      handoffPath: null,
+      handoffContent: null,
+      recoveryMessage: "No context death detected. Clean startup."
+    };
+  }
+  const handoffsDir = path6.join(vaultPath, "handoffs");
+  let handoffPath = null;
+  let handoffContent = null;
+  if (fs6.existsSync(handoffsDir)) {
+    const files = fs6.readdirSync(handoffsDir).filter((f) => f.startsWith("handoff-") && f.endsWith(".md")).sort().reverse();
+    if (files.length > 0) {
+      handoffPath = path6.join(handoffsDir, files[0]);
+      handoffContent = fs6.readFileSync(handoffPath, "utf-8");
+    }
+  }
+  let message = "\u26A0\uFE0F **CONTEXT DEATH DETECTED**\n\n";
+  message += `Your previous session died at ${deathTime}.
+
+`;
+  if (checkpoint) {
+    message += "**Last known state:**\n";
+    if (checkpoint.workingOn) {
+      message += `- Working on: ${checkpoint.workingOn}
+`;
+    }
+    if (checkpoint.focus) {
+      message += `- Focus: ${checkpoint.focus}
+`;
+    }
+    if (checkpoint.blocked) {
+      message += `- Blocked: ${checkpoint.blocked}
+`;
+    }
+    message += "\n";
+  }
+  if (handoffPath) {
+    message += `**Last handoff:** ${path6.basename(handoffPath)}
+`;
+    message += "Review and resume from where you left off.\n";
+  } else {
+    message += "**No handoff found.** You may have lost context.\n";
+  }
+  if (clearFlag) {
+    await clearDirtyFlag(vaultPath);
+  }
+  return {
+    died: true,
+    deathTime,
+    checkpoint,
+    handoffPath,
+    handoffContent,
+    recoveryMessage: message
+  };
+}
+
+// src/commands/wake.ts
+var DEFAULT_HANDOFF_LIMIT = 3;
+var MAX_WAKE_RED_OBSERVATIONS = 20;
+var MAX_WAKE_YELLOW_OBSERVATIONS = 10;
+var MAX_WAKE_OUTPUT_LINES = 100;
+function formatSummaryItems(items, maxItems = 2) {
+  const cleaned = items.map((item) => item.trim()).filter(Boolean);
+  if (cleaned.length === 0) return "";
+  if (cleaned.length <= maxItems) return cleaned.join(", ");
+  return `${cleaned.slice(0, maxItems).join(", ")} +${cleaned.length - maxItems} more`;
+}
+function buildWakeSummary(recovery, recap) {
+  let workSummary = "";
+  if (recovery.checkpoint?.workingOn) {
+    workSummary = recovery.checkpoint.workingOn;
+  } else {
+    const latestHandoff = recap.recentHandoffs[0];
+    if (latestHandoff?.workingOn?.length) {
+      workSummary = formatSummaryItems(latestHandoff.workingOn);
+    } else if (recap.activeProjects.length > 0) {
+      workSummary = formatSummaryItems(recap.activeProjects);
+    }
+  }
+  return workSummary || "No recent work summary found.";
+}
+function readRecentObservationHighlights(vaultPath) {
+  const now = /* @__PURE__ */ new Date();
+  const today = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+  const fileByDate = new Map(
+    listObservationFiles(vaultPath, {
+      includeLegacy: true,
+      includeArchive: false,
+      dedupeByDate: true
+    }).map((entry) => [entry.date, entry.path])
+  );
+  const highlights = [];
+  for (let daysAgo = 0; daysAgo < 7; daysAgo++) {
+    const date = new Date(today);
+    date.setUTCDate(today.getUTCDate() - daysAgo);
+    const dateKey = date.toISOString().slice(0, 10);
+    const filePath = fileByDate.get(dateKey);
+    if (!filePath || !fs7.existsSync(filePath)) continue;
+    const content = fs7.readFileSync(filePath, "utf-8");
+    const parsed = parseObservationMarkdown(content).filter((record) => record.importance >= 0.4);
+    const dayStructural = [];
+    const dayPotential = [];
+    for (const record of parsed) {
+      const item = {
+        date: dateKey,
+        type: record.type,
+        importance: record.importance,
+        text: record.content.trim()
+      };
+      if (record.importance >= 0.8) {
+        dayStructural.push(item);
+      } else {
+        dayPotential.push(item);
+      }
+    }
+    if (daysAgo === 0) {
+      highlights.push(...dayStructural, ...dayPotential);
+    } else if (daysAgo === 1) {
+      highlights.push(...dayStructural, ...dayPotential.slice(0, 5));
+    } else if (daysAgo <= 3) {
+      highlights.push(...dayStructural);
+    } else {
+      highlights.push(...dayStructural.slice(0, 3));
+    }
+  }
+  return highlights;
+}
+function timeFromObservationText(text) {
+  const match = text.match(/^([01]\d|2[0-3]):([0-5]\d)\b/);
+  if (!match) {
+    return -1;
+  }
+  return Number.parseInt(match[1], 10) * 60 + Number.parseInt(match[2], 10);
+}
+function compareByRecency(left, right) {
+  if (left.date !== right.date) {
+    return right.date.localeCompare(left.date);
+  }
+  if (left.importance !== right.importance) {
+    return right.importance - left.importance;
+  }
+  return timeFromObservationText(right.text) - timeFromObservationText(left.text);
+}
+function formatRecentObservations(highlights) {
+  if (highlights.length === 0) {
+    return "_No structural or potentially important observations from the recent window._";
+  }
+  const sorted = [...highlights].sort(compareByRecency);
+  const structural = sorted.filter((item) => item.importance >= 0.8).slice(0, MAX_WAKE_RED_OBSERVATIONS);
+  const potential = sorted.filter((item) => item.importance >= 0.4 && item.importance < 0.8).slice(0, MAX_WAKE_YELLOW_OBSERVATIONS);
+  const visible = [...structural, ...potential].sort(compareByRecency);
+  const omittedCount = Math.max(0, highlights.length - visible.length);
+  const byDate = /* @__PURE__ */ new Map();
+  for (const item of visible) {
+    const bucket = byDate.get(item.date) ?? [];
+    bucket.push(item);
+    byDate.set(item.date, bucket);
+  }
+  const lines = [];
+  const bodyLineBudget = Math.max(1, MAX_WAKE_OUTPUT_LINES - (omittedCount > 0 ? 1 : 0));
+  for (const [date, items] of byDate.entries()) {
+    if (lines.length >= bodyLineBudget) {
+      break;
+    }
+    lines.push(`### ${date}`);
+    for (const item of items) {
+      if (lines.length >= bodyLineBudget) {
+        break;
+      }
+      lines.push(`- [${item.type}|i=${item.importance.toFixed(2)}] ${item.text}`);
+    }
+    if (lines.length < bodyLineBudget) {
+      lines.push("");
+    }
+  }
+  if (omittedCount > 0) {
+    lines.push(`... and ${omittedCount} more observations (use \`clawvault context\` to query)`);
+  }
+  return lines.join("\n").trim();
+}
+async function generateExecutiveSummary(recovery, recap, highlights) {
+  if (process.env.CLAWVAULT_NO_LLM || process.env.VITEST) return null;
+  const apiKey = process.env.GEMINI_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+  if (!apiKey) return null;
+  const structuralItems = highlights.filter((h) => h.importance >= 0.8).map((h) => h.text).slice(0, 10);
+  const potentialItems = highlights.filter((h) => h.importance >= 0.4 && h.importance < 0.8).map((h) => h.text).slice(0, 5);
+  const projects = recap.activeProjects.slice(0, 8);
+  const commitments = recap.pendingCommitments.slice(0, 5);
+  const lastWork = recovery.checkpoint?.workingOn || recap.recentHandoffs[0]?.workingOn?.join(", ") || "";
+  const blockers = recovery.checkpoint?.blocked || recap.recentHandoffs[0]?.blocked?.join(", ") || "";
+  const nextSteps = recap.recentHandoffs[0]?.nextSteps?.join(", ") || "";
+  const prompt = [
+    "You are a chief of staff briefing an AI agent waking up for a new session.",
+    "Write a 3-5 sentence executive summary answering: What matters RIGHT NOW?",
+    "Be direct and specific. No headers, no bullets \u2014 just a tight paragraph.",
+    "Mention the most urgent item first. Include deadlines if any.",
+    "",
+    `Last working on: ${lastWork || "(unknown)"}`,
+    `Blockers: ${blockers || "(none)"}`,
+    `Next steps: ${nextSteps || "(none)"}`,
+    `Active projects (${projects.length}): ${projects.join(", ") || "(none)"}`,
+    `Pending commitments: ${commitments.join(", ") || "(none)"}`,
+    `Structural observations: ${structuralItems.join(" | ") || "(none)"}`,
+    `Potential observations: ${potentialItems.join(" | ") || "(none)"}`,
+    "",
+    "Write the briefing now. Be concise."
+  ].join("\n");
+  try {
+    if (process.env.GEMINI_API_KEY) {
+      const model = "gemini-2.0-flash";
+      const resp = await fetch(
+        `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json", "x-goog-api-key": process.env.GEMINI_API_KEY },
+          body: JSON.stringify({
+            contents: [{ parts: [{ text: prompt }] }],
+            generationConfig: { temperature: 0.3, maxOutputTokens: 300 }
+          })
+        }
+      );
+      if (!resp.ok) return null;
+      const data = await resp.json();
+      return data.candidates?.[0]?.content?.parts?.[0]?.text?.trim() || null;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function wake(options) {
+  const vaultPath = path7.resolve(options.vaultPath);
+  const recovery = await recover(vaultPath, { clearFlag: true });
+  await clearDirtyFlag(vaultPath);
+  const vault = new ClawVault(vaultPath);
+  await vault.load();
+  const recap = await vault.generateRecap({
+    handoffLimit: options.handoffLimit ?? DEFAULT_HANDOFF_LIMIT,
+    brief: options.brief ?? true
+  });
+  const highlights = readRecentObservationHighlights(vaultPath);
+  const observations = formatRecentObservations(highlights);
+  const execSummary = options.noSummary ? null : await generateExecutiveSummary(recovery, recap, highlights);
+  const highlightSummaryItems = highlights.map(
+    (item) => `[${item.type}|i=${item.importance.toFixed(2)}] ${item.text}`
+  );
+  const wakeSummary = formatSummaryItems(highlightSummaryItems);
+  const baseSummary = buildWakeSummary(recovery, recap);
+  const fullBaseSummary = wakeSummary ? `${baseSummary} | ${wakeSummary}` : baseSummary;
+  const summary = execSummary || fullBaseSummary;
+  const baseRecapMarkdown = vault.formatRecap(recap, { brief: options.brief ?? true }).trimEnd();
+  const execSection = execSummary ? `## \u{1F4CB} Executive Summary
+
+${execSummary}
+
+` : "";
+  const recapMarkdown = `${execSection}${baseRecapMarkdown}
+
+## Recent Observations
+${observations}`;
+  return {
+    recovery,
+    recap,
+    recapMarkdown,
+    summary,
+    observations
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildWakeSummary,
+  wake
+});