clawvault 3.0.0 → 3.2.0

package/dist/plugin/index.cjs

@@ -1,1907 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/plugin/index.ts
-var plugin_exports = {};
-__export(plugin_exports, {
-  appendToLedger: () => appendToLedger,
-  batchWriteObservations: () => batchWriteObservations,
-  buildFullContext: () => buildFullContext,
-  buildPreferenceContext: () => buildPreferenceContext,
-  buildSessionRecap: () => buildSessionRecap,
-  classifyText: () => classifyText,
-  default: () => plugin_default,
-  detectCategory: () => detectCategory,
-  ensureVaultStructure: () => ensureVaultStructure,
-  extractObservations: () => extractObservations,
-  extractSearchTerms: () => extractSearchTerms,
-  formatMemoriesForContext: () => formatMemoriesForContext,
-  formatSearchResults: () => formatSearchResults,
-  getAllSchemas: () => getAllSchemas,
-  getSchema: () => getSchema,
-  getSchemaNames: () => getSchemaNames,
-  getTemplateRegistry: () => getTemplateRegistry2,
-  initializeTemplateRegistry: () => initializeTemplateRegistry,
-  isObservable: () => isObservable,
-  processMessageForObservations: () => processMessageForObservations,
-  scanVaultFiles: () => scanVaultFiles,
-  writeObservation: () => writeObservation,
-  writeVaultFile: () => writeVaultFile
-});
-module.exports = __toCommonJS(plugin_exports);
-var import_node_child_process = require("child_process");
-var import_node_fs4 = require("fs");
-var import_node_path4 = require("path");
-var import_typebox = require("@sinclair/typebox");
-
-// src/plugin/templates.ts
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-var DEFAULT_SCHEMAS = [
-  {
-    primitive: "memory_event",
-    description: "General memory event for observations",
-    fields: {
-      type: { type: "string", required: true, default: "memory_event" },
-      status: { type: "string", required: true, default: "recorded", enum: ["recorded", "superseded", "corrected"] },
-      created: { type: "datetime", required: true, default: "{{datetime}}" },
-      observed_at: { type: "datetime", required: true },
-      source: { type: "string", required: true, enum: ["openclaw", "claude-code", "replay", "manual-correction"] },
-      summary: { type: "string", required: true },
-      confidence: { type: "number" },
-      importance: { type: "number" }
-    },
-    keywords: ["preference", "like", "hate", "want", "need", "always", "never", "remember", "note"]
-  },
-  {
-    primitive: "person",
-    description: "People and relationship notes",
-    fields: {
-      title: { type: "string", required: true, default: "{{title}}" },
-      date: { type: "date", required: true, default: "{{date}}" },
-      type: { type: "string", required: true, default: "person" },
-      relationship: { type: "string", default: "contact" }
-    },
-    keywords: ["person", "contact", "colleague", "friend", "works at", "lives in", "email", "phone", "name is"]
-  },
-  {
-    primitive: "decision",
-    description: "Decision records",
-    fields: {
-      title: { type: "string", required: true, default: "{{title}}" },
-      date: { type: "date", required: true, default: "{{date}}" },
-      type: { type: "string", required: true, default: "decision" },
-      status: { type: "string", default: "decided", enum: ["proposed", "decided", "superseded"] }
-    },
-    keywords: ["decided", "decision", "chose", "will use", "go with", "ship", "approved", "rejected"]
-  },
-  {
-    primitive: "task",
-    description: "Task primitives",
-    fields: {
-      status: { type: "string", required: true, default: "open", enum: ["open", "in-progress", "blocked", "done"] },
-      created: { type: "datetime", required: true, default: "{{datetime}}" },
-      updated: { type: "datetime", required: true, default: "{{datetime}}" },
-      priority: { type: "string", enum: ["critical", "high", "medium", "low"] },
-      due: { type: "date" }
-    },
-    keywords: ["task", "todo", "need to", "should", "must", "deadline", "due", "by tomorrow", "by tonight"]
-  },
-  {
-    primitive: "project",
-    description: "Project definition documents",
-    fields: {
-      type: { type: "string", required: true, default: "project" },
-      status: { type: "string", required: true, default: "active", enum: ["active", "paused", "completed", "archived"] },
-      created: { type: "datetime", required: true, default: "{{datetime}}" },
-      updated: { type: "datetime", required: true, default: "{{datetime}}" }
-    },
-    keywords: ["project", "initiative", "working on", "building", "developing"]
-  },
-  {
-    primitive: "lesson",
-    description: "Lessons learned",
-    fields: {
-      title: { type: "string", required: true, default: "{{title}}" },
-      date: { type: "date", required: true, default: "{{date}}" },
-      type: { type: "string", required: true, default: "lesson" }
-    },
-    keywords: ["learned", "lesson", "insight", "realized", "discovered", "found out"]
-  }
-];
-function parseYamlFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  if (!match) return null;
-  const yamlContent = match[1];
-  const body = match[2];
-  try {
-    const frontmatter = parseSimpleYaml(yamlContent);
-    return { frontmatter, body };
-  } catch {
-    return null;
-  }
-}
-function parseSimpleYaml(yaml) {
-  const result = {};
-  const lines = yaml.split("\n");
-  let currentKey = "";
-  let currentIndent = 0;
-  let nestedObject = null;
-  let nestedKey = "";
-  for (const line of lines) {
-    if (!line.trim() || line.trim().startsWith("#")) continue;
-    const indent = line.search(/\S/);
-    const trimmed = line.trim();
-    if (trimmed.startsWith("- ")) {
-      const value = trimmed.slice(2).trim();
-      if (nestedObject && nestedKey) {
-        const arr = nestedObject[nestedKey];
-        if (Array.isArray(arr)) {
-          arr.push(parseYamlValue(value));
-        }
-      } else if (currentKey && result[currentKey]) {
-        const arr = result[currentKey];
-        if (Array.isArray(arr)) {
-          arr.push(parseYamlValue(value));
-        }
-      }
-      continue;
-    }
-    const colonIndex = trimmed.indexOf(":");
-    if (colonIndex === -1) continue;
-    const key = trimmed.slice(0, colonIndex).trim();
-    const valueStr = trimmed.slice(colonIndex + 1).trim();
-    if (indent === 0) {
-      if (valueStr === "" || valueStr === "|" || valueStr === ">") {
-        if (key === "fields") {
-          result[key] = {};
-          nestedObject = result[key];
-          nestedKey = "";
-        } else {
-          result[key] = {};
-          nestedObject = null;
-        }
-      } else {
-        result[key] = parseYamlValue(valueStr);
-        nestedObject = null;
-      }
-      currentKey = key;
-      currentIndent = indent;
-    } else if (nestedObject && indent > 0) {
-      if (valueStr === "" || valueStr === "|" || valueStr === ">") {
-        nestedObject[key] = {};
-        nestedKey = key;
-      } else if (nestedKey && indent > 2) {
-        const fieldObj = nestedObject[nestedKey];
-        if (fieldObj) {
-          if (key === "enum") {
-            fieldObj[key] = [];
-          } else {
-            fieldObj[key] = parseYamlValue(valueStr);
-          }
-        }
-      } else {
-        nestedObject[key] = parseYamlValue(valueStr);
-        nestedKey = key;
-      }
-    }
-  }
-  return result;
-}
-function parseYamlValue(value) {
-  if (value === "" || value === "null" || value === "~") return null;
-  if (value === "true") return true;
-  if (value === "false") return false;
-  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
-  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-var registry = null;
-function getTemplateRegistry() {
-  if (!registry) {
-    registry = {
-      schemas: /* @__PURE__ */ new Map(),
-      keywordIndex: /* @__PURE__ */ new Map(),
-      initialized: false
-    };
-  }
-  return registry;
-}
-function initializeTemplateRegistry(templatesDir) {
-  const reg = getTemplateRegistry();
-  if (reg.initialized) {
-    return reg;
-  }
-  const dirsToTry = templatesDir ? [templatesDir] : [
-    (0, import_node_path.join)(process.cwd(), "templates"),
-    (0, import_node_path.join)(process.cwd(), "..", "..", "templates"),
-    (0, import_node_path.join)(process.env.HOME ?? ".", "clawvault", "templates"),
-    (0, import_node_path.join)(process.env.HOME ?? ".", ".clawvault", "templates")
-  ];
-  let loaded = false;
-  for (const dir of dirsToTry) {
-    if ((0, import_node_fs.existsSync)(dir)) {
-      try {
-        loadTemplatesFromDirectory(dir, reg);
-        loaded = true;
-        break;
-      } catch {
-      }
-    }
-  }
-  if (!loaded || reg.schemas.size === 0) {
-    loadDefaultSchemas(reg);
-  }
-  buildKeywordIndex(reg);
-  reg.initialized = true;
-  return reg;
-}
-function loadTemplatesFromDirectory(dir, reg) {
-  const files = (0, import_node_fs.readdirSync)(dir).filter((f) => f.endsWith(".md"));
-  for (const file of files) {
-    const filePath = (0, import_node_path.join)(dir, file);
-    const content = (0, import_node_fs.readFileSync)(filePath, "utf-8");
-    const parsed = parseYamlFrontmatter(content);
-    if (!parsed?.frontmatter?.primitive) continue;
-    const schema = convertFrontmatterToSchema(parsed.frontmatter, parsed.body);
-    if (schema) {
-      reg.schemas.set(schema.primitive, schema);
-    }
-  }
-}
-function convertFrontmatterToSchema(fm, body) {
-  const primitive = fm.primitive;
-  if (!primitive) return null;
-  const fields = {};
-  const fmFields = fm.fields;
-  if (fmFields) {
-    for (const [fieldName, fieldDef] of Object.entries(fmFields)) {
-      if (typeof fieldDef === "object" && fieldDef !== null) {
-        const def = fieldDef;
-        fields[fieldName] = {
-          type: def.type || "string",
-          required: def.required,
-          default: def.default,
-          enum: def.enum,
-          description: def.description
-        };
-      }
-    }
-  }
-  const keywords = extractKeywordsFromSchema(primitive, fm.description, fields);
-  return {
-    primitive,
-    description: fm.description,
-    fields,
-    bodyTemplate: body,
-    keywords
-  };
-}
-function extractKeywordsFromSchema(primitive, description, fields) {
-  const keywords = [primitive];
-  keywords.push(primitive.replace(/-/g, " "));
-  keywords.push(primitive.replace(/_/g, " "));
-  switch (primitive) {
-    case "memory_event":
-      keywords.push("preference", "like", "hate", "want", "need", "always", "never", "remember", "note");
-      break;
-    case "person":
-      keywords.push("person", "contact", "colleague", "friend", "works at", "lives in", "email", "phone", "name is");
-      break;
-    case "decision":
-      keywords.push("decided", "decision", "chose", "will use", "go with", "ship", "approved", "rejected");
-      break;
-    case "task":
-      keywords.push("task", "todo", "need to", "should", "must", "deadline", "due", "by tomorrow", "by tonight");
-      break;
-    case "project":
-      keywords.push("project", "initiative", "working on", "building", "developing");
-      break;
-    case "lesson":
-      keywords.push("learned", "lesson", "insight", "realized", "discovered", "found out");
-      break;
-    case "trigger":
-      keywords.push("trigger", "schedule", "cron", "automated", "recurring");
-      break;
-    case "run":
-      keywords.push("run", "execution", "job", "started", "finished", "failed");
-      break;
-    case "checkpoint":
-      keywords.push("checkpoint", "snapshot", "state", "progress");
-      break;
-    case "handoff":
-      keywords.push("handoff", "transition", "context", "resume");
-      break;
-    case "daily-note":
-    case "daily":
-      keywords.push("daily", "today", "journal", "log");
-      break;
-    case "party":
-      keywords.push("party", "agent", "human", "runtime", "service");
-      break;
-    case "workspace":
-      keywords.push("workspace", "shared", "collaboration");
-      break;
-  }
-  if (fields.status?.enum) {
-    keywords.push(...fields.status.enum);
-  }
-  return [...new Set(keywords)];
-}
-function loadDefaultSchemas(reg) {
-  for (const schema of DEFAULT_SCHEMAS) {
-    reg.schemas.set(schema.primitive, schema);
-  }
-}
-function buildKeywordIndex(reg) {
-  reg.keywordIndex.clear();
-  for (const [primitive, schema] of reg.schemas) {
-    const keywords = schema.keywords ?? [primitive];
-    for (const keyword of keywords) {
-      const lower = keyword.toLowerCase();
-      const existing = reg.keywordIndex.get(lower) ?? [];
-      if (!existing.includes(primitive)) {
-        existing.push(primitive);
-      }
-      reg.keywordIndex.set(lower, existing);
-    }
-  }
-}
-function classifyText(text) {
-  const reg = getTemplateRegistry();
-  if (!reg.initialized) {
-    initializeTemplateRegistry();
-  }
-  const lower = text.toLowerCase();
-  const scores = /* @__PURE__ */ new Map();
-  for (const [keyword, primitives] of reg.keywordIndex) {
-    if (lower.includes(keyword)) {
-      for (const primitive of primitives) {
-        const existing = scores.get(primitive) ?? { score: 0, keywords: [] };
-        existing.score += getKeywordWeight(keyword, primitive);
-        existing.keywords.push(keyword);
-        scores.set(primitive, existing);
-      }
-    }
-  }
-  applyPatternScoring(lower, scores);
-  let bestPrimitive = "memory_event";
-  let bestScore = 0;
-  let bestKeywords = [];
-  for (const [primitive, data] of scores) {
-    if (data.score > bestScore) {
-      bestScore = data.score;
-      bestPrimitive = primitive;
-      bestKeywords = data.keywords;
-    }
-  }
-  const confidence = Math.min(1, bestScore / 5);
-  return {
-    primitiveType: bestPrimitive,
-    confidence,
-    matchedKeywords: [...new Set(bestKeywords)]
-  };
-}
-function getKeywordWeight(keyword, primitive) {
-  if (keyword === primitive || keyword === primitive.replace(/-/g, " ")) {
-    return 3;
-  }
-  const strongIndicators = {
-    person: ["works at", "lives in", "email", "phone", "name is"],
-    decision: ["decided", "chose", "will use", "go with"],
-    task: ["deadline", "due", "by tomorrow", "by tonight"],
-    memory_event: ["preference", "remember", "note"]
-  };
-  if (strongIndicators[primitive]?.includes(keyword)) {
-    return 2;
-  }
-  return 1;
-}
-function applyPatternScoring(text, scores) {
-  if (/\b(my .+ is|his .+ is|her .+ is|their .+ is)\b/i.test(text)) {
-    const existing = scores.get("person") ?? { score: 0, keywords: [] };
-    existing.score += 2;
-    existing.keywords.push("possessive pattern");
-    scores.set("person", existing);
-  }
-  if (/[\w.-]+@[\w.-]+\.\w+|\+\d{10,}/.test(text)) {
-    const existing = scores.get("person") ?? { score: 0, keywords: [] };
-    existing.score += 3;
-    existing.keywords.push("contact info");
-    scores.set("person", existing);
-  }
-  if (/\b(i prefer|i like|i hate|i love|i want|i need|i always|i never|don't like|dont like)\b/i.test(text)) {
-    const existing = scores.get("memory_event") ?? { score: 0, keywords: [] };
-    existing.score += 3;
-    existing.keywords.push("preference pattern");
-    scores.set("memory_event", existing);
-  }
-  if (/\b(we decided|let's go with|we're going|i chose|we'll use|ship it|do it)\b/i.test(text)) {
-    const existing = scores.get("decision") ?? { score: 0, keywords: [] };
-    existing.score += 3;
-    existing.keywords.push("decision pattern");
-    scores.set("decision", existing);
-  }
-  if (/\b(by tonight|by tomorrow|deadline|due date|by end of|ship by|ready by)\b/i.test(text)) {
-    const existing = scores.get("task") ?? { score: 0, keywords: [] };
-    existing.score += 2;
-    existing.keywords.push("deadline pattern");
-    scores.set("task", existing);
-  }
-}
-function getSchema(primitiveType) {
-  const reg = getTemplateRegistry();
-  if (!reg.initialized) {
-    initializeTemplateRegistry();
-  }
-  return reg.schemas.get(primitiveType);
-}
-function getAllSchemas() {
-  const reg = getTemplateRegistry();
-  if (!reg.initialized) {
-    initializeTemplateRegistry();
-  }
-  return Array.from(reg.schemas.values());
-}
-function getSchemaNames() {
-  const reg = getTemplateRegistry();
-  if (!reg.initialized) {
-    initializeTemplateRegistry();
-  }
-  return Array.from(reg.schemas.keys());
-}
-function generateFrontmatter(primitiveType, options = {}) {
-  const schema = getSchema(primitiveType);
-  if (!schema) {
-    return {
-      type: primitiveType,
-      created: (/* @__PURE__ */ new Date()).toISOString(),
-      updated: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  const frontmatter = {};
-  const now = /* @__PURE__ */ new Date();
-  const dateStr = now.toISOString().split("T")[0];
-  const datetimeStr = now.toISOString();
-  for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
-    if (options.extraFields?.[fieldName] !== void 0) {
-      const value = options.extraFields[fieldName];
-      if (fieldDef.enum && !fieldDef.enum.includes(String(value))) {
-        frontmatter[fieldName] = fieldDef.default ?? fieldDef.enum[0];
-      } else {
-        frontmatter[fieldName] = value;
-      }
-      continue;
-    }
-    if (fieldDef.default !== void 0) {
-      let defaultValue = fieldDef.default;
-      if (typeof defaultValue === "string") {
-        defaultValue = defaultValue.replace("{{datetime}}", datetimeStr).replace("{{date}}", dateStr).replace("{{title}}", options.title ?? "Untitled");
-      }
-      frontmatter[fieldName] = defaultValue;
-    } else if (fieldDef.required) {
-      switch (fieldDef.type) {
-        case "datetime":
-          frontmatter[fieldName] = datetimeStr;
-          break;
-        case "date":
-          frontmatter[fieldName] = dateStr;
-          break;
-        case "string":
-          if (fieldDef.enum?.length) {
-            frontmatter[fieldName] = fieldDef.enum[0];
-          } else {
-            frontmatter[fieldName] = "";
-          }
-          break;
-        case "number":
-          frontmatter[fieldName] = 0;
-          break;
-        case "boolean":
-          frontmatter[fieldName] = false;
-          break;
-      }
-    }
-  }
-  if (options.source && schema.fields.source) {
-    frontmatter.source = options.source;
-  }
-  if (options.sessionId && schema.fields.session_id) {
-    frontmatter.session_id = options.sessionId;
-  }
-  return frontmatter;
-}
-function validateFrontmatter(primitiveType, frontmatter) {
-  const schema = getSchema(primitiveType);
-  if (!schema) {
-    return { valid: true, errors: [] };
-  }
-  const errors = [];
-  for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
-    const value = frontmatter[fieldName];
-    if (fieldDef.required && (value === void 0 || value === null || value === "")) {
-      errors.push(`Missing required field: ${fieldName}`);
-      continue;
-    }
-    if (value === void 0 || value === null) continue;
-    if (fieldDef.enum && !fieldDef.enum.includes(String(value))) {
-      errors.push(`Invalid value for ${fieldName}: "${value}". Must be one of: ${fieldDef.enum.join(", ")}`);
-    }
-    switch (fieldDef.type) {
-      case "number":
-        if (typeof value !== "number" && isNaN(Number(value))) {
-          errors.push(`Field ${fieldName} must be a number`);
-        }
-        break;
-      case "boolean":
-        if (typeof value !== "boolean" && value !== "true" && value !== "false") {
-          errors.push(`Field ${fieldName} must be a boolean`);
-        }
-        break;
-      case "datetime":
-        if (typeof value === "string" && isNaN(Date.parse(value))) {
-          errors.push(`Field ${fieldName} must be a valid datetime`);
-        }
-        break;
-      case "date":
-        if (typeof value === "string" && !/^\d{4}-\d{2}-\d{2}$/.test(value)) {
-          errors.push(`Field ${fieldName} must be a valid date (YYYY-MM-DD)`);
-        }
-        break;
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-function serializeFrontmatter(frontmatter) {
-  const lines = ["---"];
-  for (const [key, value] of Object.entries(frontmatter)) {
-    if (value === void 0 || value === null) continue;
-    if (Array.isArray(value)) {
-      lines.push(`${key}:`);
-      for (const item of value) {
-        lines.push(`  - ${item}`);
-      }
-    } else if (typeof value === "object") {
-      lines.push(`${key}: ${JSON.stringify(value)}`);
-    } else if (typeof value === "string" && value.includes("\n")) {
-      lines.push(`${key}: |`);
-      for (const line of value.split("\n")) {
-        lines.push(`  ${line}`);
-      }
-    } else {
-      lines.push(`${key}: ${value}`);
-    }
-  }
-  lines.push("---");
-  return lines.join("\n");
-}
-
-// src/plugin/observe.ts
-function isObservable(text) {
-  if (!text || text.length < 20 || text.length > 5e3) return false;
-  if (text.includes("<relevant-memories>")) return false;
-  if (text.startsWith("[System")) return false;
-  if (text.includes("HEARTBEAT")) return false;
-  if (text.startsWith("NO_REPLY")) return false;
-  if (text.startsWith("{") && text.includes('"')) return false;
-  const markdownDensity = (text.match(/[#*`\-|>]/g) || []).length / text.length;
-  if (markdownDensity > 0.15) return false;
-  return true;
-}
-var OBSERVATION_PATTERNS = [
-  // Preferences
-  { pattern: /\b(i prefer|i like|i hate|i love|i want|i need|i always|i never|don't like|dont like)\b/i, weight: 2 },
-  // Decisions
-  { pattern: /\b(we decided|let's go with|we're going|i chose|we'll use|ship it|do it|go with)\b/i, weight: 2 },
-  // Facts about people/things
-  { pattern: /\b(my .+ is|his .+ is|her .+ is|their .+ is|works at|lives in|born in)\b/i, weight: 1.5 },
-  // Contact info
-  { pattern: /[\w.-]+@[\w.-]+\.\w+|\+\d{10,}/i, weight: 2 },
-  // Explicit memory request
-  { pattern: /\b(remember|don't forget|keep in mind|note that|important:)\b/i, weight: 2.5 },
-  // Deadlines/dates
-  { pattern: /\b(by tonight|by tomorrow|deadline|due date|by end of|ship by|ready by)\b/i, weight: 1.5 },
-  // Lessons learned
-  { pattern: /\b(i learned|we learned|lesson|realized|discovered|found out)\b/i, weight: 1.5 },
-  // Tasks
-  { pattern: /\b(need to|should|must|have to|todo|task)\b/i, weight: 1 },
-  // Projects
-  { pattern: /\b(working on|building|developing|project|initiative)\b/i, weight: 1 }
-];
-function extractObservations(text) {
-  const observations = [];
-  const sentences = splitIntoSentences(text);
-  const now = /* @__PURE__ */ new Date();
-  for (const sentence of sentences) {
-    if (sentence.length < 15) continue;
-    let totalWeight = 0;
-    for (const { pattern, weight } of OBSERVATION_PATTERNS) {
-      if (pattern.test(sentence)) {
-        totalWeight += weight;
-      }
-    }
-    if (totalWeight < 1) continue;
-    const classification = classifyText(sentence);
-    const category = deriveCategoryFromPrimitive(classification.primitiveType, sentence);
-    const tags = generateTags(classification, sentence);
-    observations.push({
-      text: sentence.trim(),
-      primitiveType: classification.primitiveType,
-      confidence: classification.confidence,
-      matchedKeywords: classification.matchedKeywords,
-      category,
-      tags,
-      extractedAt: now
-    });
-  }
-  return observations;
-}
-function splitIntoSentences(text) {
-  const raw = text.split(/(?<=[.!?\n])\s+/);
-  const sentences = [];
-  for (const s of raw) {
-    const trimmed = s.trim();
-    if (trimmed.length > 0) {
-      sentences.push(trimmed);
-    }
-  }
-  return sentences;
-}
-function deriveCategoryFromPrimitive(primitiveType, text) {
-  const lower = text.toLowerCase();
-  if (primitiveType === "memory_event") {
-    if (/prefer|like|love|hate|want|need|always|never/i.test(lower)) {
-      return "preference";
-    }
-    if (/remember|don't forget|keep in mind|note that/i.test(lower)) {
-      return "note";
-    }
-    return "fact";
-  }
-  const categoryMap = {
-    person: "entity",
-    decision: "decision",
-    task: "task",
-    project: "project",
-    lesson: "lesson",
-    trigger: "automation",
-    run: "execution",
-    checkpoint: "checkpoint",
-    handoff: "handoff",
-    "daily-note": "daily",
-    daily: "daily",
-    party: "entity",
-    workspace: "workspace"
-  };
-  return categoryMap[primitiveType] ?? "fact";
-}
-function generateTags(classification, text) {
-  const tags = [classification.primitiveType];
-  const lower = text.toLowerCase();
-  if (/prefer|like|love/i.test(lower)) tags.push("positive");
-  if (/hate|dislike|don't like/i.test(lower)) tags.push("negative");
-  if (/deadline|due|by tomorrow|by tonight/i.test(lower)) tags.push("time-sensitive");
-  if (/important|critical|urgent/i.test(lower)) tags.push("high-priority");
-  if (/email|phone|contact/i.test(lower)) tags.push("contact-info");
-  if (/decided|chose|approved/i.test(lower)) tags.push("finalized");
-  if (/proposed|considering|might/i.test(lower)) tags.push("tentative");
-  return [...new Set(tags)];
-}
-function processMessageForObservations(content, options = {}) {
-  if (!isObservable(content)) {
-    return {
-      observations: [],
-      skipped: 1,
-      reason: "Content not observable"
-    };
-  }
-  const observations = extractObservations(content);
-  const maxObservations = 5;
-  const limited = observations.slice(0, maxObservations);
-  const skipped = observations.length - limited.length;
-  return {
-    observations: limited,
-    skipped,
-    reason: skipped > 0 ? `Limited to ${maxObservations} observations` : void 0
-  };
-}
-function detectCategory(text) {
-  const classification = classifyText(text);
-  return deriveCategoryFromPrimitive(classification.primitiveType, text);
-}
-function extractSearchTerms(input) {
-  const noise = /\b(hey|hi|hello|um|uh|like|just|so|well|you know|i mean|basically|actually|really|very|pretty|quite|how does it feel|how do you|can you|could you|would you|do you|what do you think|tell me about)\b/gi;
-  let cleaned = input.replace(noise, " ").replace(/\s+/g, " ").trim();
-  if (cleaned.length < 5) cleaned = input.trim();
-  return cleaned;
-}
-
-// src/plugin/inject.ts
-var import_node_fs2 = require("fs");
-var import_node_path2 = require("path");
-function parseYamlFrontmatter2(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  if (!match) return null;
-  const yamlContent = match[1];
-  const body = match[2];
-  try {
-    const frontmatter = parseSimpleYaml2(yamlContent);
-    return { frontmatter, body };
-  } catch {
-    return null;
-  }
-}
-function parseSimpleYaml2(yaml) {
-  const result = {};
-  const lines = yaml.split("\n");
-  for (const line of lines) {
-    if (!line.trim() || line.trim().startsWith("#")) continue;
-    const colonIndex = line.indexOf(":");
-    if (colonIndex === -1) continue;
-    const key = line.slice(0, colonIndex).trim();
-    const valueStr = line.slice(colonIndex + 1).trim();
-    if (valueStr === "" || valueStr.startsWith("|") || valueStr.startsWith(">")) continue;
-    result[key] = parseYamlValue2(valueStr);
-  }
-  return result;
-}
-function parseYamlValue2(value) {
-  if (value === "" || value === "null" || value === "~") return null;
-  if (value === "true") return true;
-  if (value === "false") return false;
-  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
-  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-function scanVaultFiles(vaultPath, options = {}) {
-  const files = [];
-  const maxAge = options.maxAge ?? 7 * 24 * 60 * 60 * 1e3;
-  const limit = options.limit ?? 100;
-  const now = Date.now();
-  const cutoff = now - maxAge;
-  const dirsToScan = findVaultDirectories(vaultPath);
-  for (const dir of dirsToScan) {
-    if (!(0, import_node_fs2.existsSync)(dir)) continue;
-    try {
-      scanDirectory(dir, vaultPath, files, cutoff, options.primitiveTypes);
-    } catch {
-    }
-  }
-  files.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
-  return files.slice(0, limit);
-}
-function findVaultDirectories(vaultPath) {
-  const dirs = [];
-  dirs.push(vaultPath);
-  const commonDirs = [
-    "tasks",
-    "projects",
-    "decisions",
-    "people",
-    "persons",
-    "notes",
-    "daily",
-    "journal",
-    "ledger",
-    "memory",
-    "memories",
-    "observations",
-    "lessons",
-    "triggers",
-    "runs",
-    "checkpoints",
-    "handoffs",
-    "workspaces",
-    "parties"
-  ];
-  for (const subdir of commonDirs) {
-    const fullPath = (0, import_node_path2.join)(vaultPath, subdir);
-    if ((0, import_node_fs2.existsSync)(fullPath)) {
-      dirs.push(fullPath);
-    }
-  }
-  try {
-    const entries = (0, import_node_fs2.readdirSync)(vaultPath, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.startsWith("_")) {
-        const fullPath = (0, import_node_path2.join)(vaultPath, entry.name);
-        if (!dirs.includes(fullPath)) {
-          dirs.push(fullPath);
-        }
-      }
-    }
-  } catch {
-  }
-  return dirs;
-}
-function scanDirectory(dir, vaultPath, files, cutoff, primitiveTypes) {
-  const entries = (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
-    const fullPath = (0, import_node_path2.join)(dir, entry.name);
-    if (entry.isDirectory()) {
-      const depth = fullPath.replace(vaultPath, "").split("/").length;
-      if (depth <= 3) {
-        scanDirectory(fullPath, vaultPath, files, cutoff, primitiveTypes);
-      }
-    } else if (entry.name.endsWith(".md")) {
-      try {
-        const stat = (0, import_node_fs2.statSync)(fullPath);
-        if (stat.mtimeMs < cutoff) continue;
-        const content = (0, import_node_fs2.readFileSync)(fullPath, "utf-8");
-        const parsed = parseYamlFrontmatter2(content);
-        if (!parsed) continue;
-        const primitiveType = detectPrimitiveType(parsed.frontmatter, fullPath);
-        if (primitiveTypes && !primitiveTypes.includes(primitiveType)) continue;
-        files.push({
-          path: fullPath,
-          relativePath: (0, import_node_path2.relative)(vaultPath, fullPath),
-          primitiveType,
-          frontmatter: parsed.frontmatter,
-          content: parsed.body,
-          modifiedAt: stat.mtime,
-          createdAt: stat.birthtime
-        });
-      } catch {
-      }
-    }
-  }
-}
-function detectPrimitiveType(frontmatter, filePath) {
-  if (frontmatter.primitive) return String(frontmatter.primitive);
-  if (frontmatter.type) return String(frontmatter.type);
-  const pathLower = filePath.toLowerCase();
-  if (pathLower.includes("/tasks/")) return "task";
-  if (pathLower.includes("/projects/")) return "project";
-  if (pathLower.includes("/decisions/")) return "decision";
-  if (pathLower.includes("/people/") || pathLower.includes("/persons/")) return "person";
-  if (pathLower.includes("/daily/") || pathLower.includes("/journal/")) return "daily-note";
-  if (pathLower.includes("/lessons/")) return "lesson";
-  if (pathLower.includes("/triggers/")) return "trigger";
-  if (pathLower.includes("/runs/")) return "run";
-  if (pathLower.includes("/checkpoints/")) return "checkpoint";
-  if (pathLower.includes("/handoffs/")) return "handoff";
-  if (pathLower.includes("/ledger/")) return "memory_event";
-  if (pathLower.includes("/memory/") || pathLower.includes("/memories/")) return "memory_event";
-  return "unknown";
-}
-function buildSessionRecap(vaultPath, options = {}) {
-  const maxAge = options.maxAge ?? 24 * 60 * 60 * 1e3;
-  const limit = options.limit ?? 20;
-  const includeContent = options.includeContent ?? false;
-  const files = scanVaultFiles(vaultPath, { maxAge, limit });
-  if (files.length === 0) {
-    return {
-      xml: "",
-      fileCount: 0,
-      primitiveGroups: {},
-      timeRange: null
-    };
-  }
-  const groups = {};
-  for (const file of files) {
-    const type = file.primitiveType;
-    if (!groups[type]) groups[type] = [];
-    groups[type].push(file);
-  }
-  const lines = ["<session-recap>"];
-  lines.push(`<summary>Found ${files.length} recent items across ${Object.keys(groups).length} categories</summary>`);
-  for (const [primitiveType, groupFiles] of Object.entries(groups)) {
-    lines.push(`<${primitiveType}-items count="${groupFiles.length}">`);
-    for (const file of groupFiles.slice(0, 5)) {
-      const title = file.frontmatter.title || file.frontmatter.summary || file.relativePath;
-      const status = file.frontmatter.status || "";
-      const modified = file.modifiedAt.toISOString().slice(0, 16).replace("T", " ");
-      lines.push(`  <item path="${file.relativePath}" modified="${modified}"${status ? ` status="${status}"` : ""}>`);
-      lines.push(`    <title>${escapeXml(String(title))}</title>`);
-      if (includeContent && file.content) {
-        const snippet = file.content.slice(0, 200).replace(/\n/g, " ").trim();
-        if (snippet) {
-          lines.push(`    <snippet>${escapeXml(snippet)}</snippet>`);
-        }
-      }
-      lines.push("  </item>");
-    }
-    if (groupFiles.length > 5) {
-      lines.push(`  <more count="${groupFiles.length - 5}" />`);
-    }
-    lines.push(`</${primitiveType}-items>`);
-  }
-  lines.push("</session-recap>");
-  const sortedByTime = [...files].sort((a, b) => a.modifiedAt.getTime() - b.modifiedAt.getTime());
-  const timeRange = {
-    oldest: sortedByTime[0].modifiedAt,
-    newest: sortedByTime[sortedByTime.length - 1].modifiedAt
-  };
-  const primitiveGroups = {};
-  for (const [type, groupFiles] of Object.entries(groups)) {
-    primitiveGroups[type] = groupFiles.length;
-  }
-  return {
-    xml: lines.join("\n"),
-    fileCount: files.length,
-    primitiveGroups,
-    timeRange
-  };
-}
-function buildPreferenceContext(vaultPath, options = {}) {
-  const maxAge = options.maxAge ?? 30 * 24 * 60 * 60 * 1e3;
-  const limit = options.limit ?? 50;
-  const files = scanVaultFiles(vaultPath, { maxAge, limit: limit * 2 });
-  const preferenceFiles = files.filter((file) => {
-    if (file.frontmatter.type === "preference") return true;
-    if (file.primitiveType === "memory_event" && file.frontmatter.type === "preference") return true;
-    const content = (file.content || "").toLowerCase();
-    if (/\b(prefer|like|love|hate|dislike|want|need|always|never)\b/.test(content)) {
-      return true;
-    }
-    return false;
-  }).slice(0, limit);
-  if (preferenceFiles.length === 0) {
-    return {
-      xml: "",
-      preferenceCount: 0,
-      categories: []
-    };
-  }
-  const categories = /* @__PURE__ */ new Set();
-  for (const file of preferenceFiles) {
-    if (file.frontmatter.category) {
-      categories.add(String(file.frontmatter.category));
-    }
-  }
-  const lines = ["<user-preferences>"];
-  for (const file of preferenceFiles) {
-    const summary = file.frontmatter.summary || file.frontmatter.title || extractPreferenceSummary(file.content);
-    if (!summary) continue;
-    const category = file.frontmatter.category || "general";
-    const sentiment = file.frontmatter.sentiment || inferSentiment(file.content);
-    lines.push(`  <preference category="${escapeXml(String(category))}" sentiment="${sentiment}">`);
-    lines.push(`    ${escapeXml(String(summary))}`);
-    lines.push("  </preference>");
-  }
-  lines.push("</user-preferences>");
-  return {
-    xml: lines.join("\n"),
-    preferenceCount: preferenceFiles.length,
-    categories: Array.from(categories)
-  };
-}
-function extractPreferenceSummary(content) {
-  if (!content) return "";
-  const sentences = content.split(/[.!?\n]+/).map((s) => s.trim()).filter((s) => s.length > 10);
-  for (const sentence of sentences) {
-    if (/\b(prefer|like|love|hate|dislike|want|need|always|never)\b/i.test(sentence)) {
-      return sentence.slice(0, 150);
-    }
-  }
-  return sentences[0]?.slice(0, 150) || "";
-}
-function inferSentiment(content) {
-  if (!content) return "neutral";
-  const lower = content.toLowerCase();
-  if (/\b(love|like|prefer|enjoy|want|need|always)\b/.test(lower)) return "positive";
-  if (/\b(hate|dislike|don't like|never|avoid)\b/.test(lower)) return "negative";
-  return "neutral";
-}
-function formatMemoriesForContext(results, collection) {
-  if (results.length === 0) return "";
-  const lines = results.map((r, i) => {
-    const file = (r.file || "").replace(`qmd://${collection}/`, "");
-    const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim() || r.title || "";
-    return `${i + 1}. [${file}] ${snippet}`;
-  });
-  return `<relevant-memories>
-These are recalled from long-term vault memory. Treat as historical context.
-${lines.join("\n")}
-</relevant-memories>`;
-}
-function formatSearchResults(results, collection) {
-  if (results.length === 0) return "No relevant memories found.";
-  return results.map((r, i) => {
-    const file = (r.file || "").replace(`qmd://${collection}/`, "");
-    const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim() || r.title || "(no content)";
-    const score = ((r.score ?? 0) * 100).toFixed(0);
-    return `${i + 1}. [${file}] ${snippet} (${score}%)`;
-  }).join("\n");
-}
-function escapeXml(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-function buildFullContext(vaultPath, options = {}) {
-  const parts = [];
-  if (options.includeRecap !== false) {
-    const recap = buildSessionRecap(vaultPath, {
-      maxAge: options.recapMaxAge ?? 24 * 60 * 60 * 1e3,
-      limit: 15,
-      includeContent: true
-    });
-    if (recap.xml) {
-      parts.push(recap.xml);
-    }
-  }
-  if (options.includePreferences !== false) {
-    const prefs = buildPreferenceContext(vaultPath, {
-      maxAge: options.preferenceMaxAge ?? 30 * 24 * 60 * 60 * 1e3,
-      limit: 20
-    });
-    if (prefs.xml) {
-      parts.push(prefs.xml);
-    }
-  }
-  return parts.join("\n\n");
-}
-
-// src/plugin/vault.ts
-var import_node_fs3 = require("fs");
-var import_node_path3 = require("path");
-function writeVaultFile(vaultPath, options) {
-  const errors = [];
-  const primitiveType = options.primitiveType ?? classifyText(options.content ?? options.title ?? "").primitiveType;
-  const schema = getSchema(primitiveType);
-  const frontmatter = generateFrontmatter(primitiveType, {
-    title: options.title,
-    extraFields: options.extraFields,
-    source: options.source,
-    sessionId: options.sessionId
-  });
-  const validation = validateFrontmatter(primitiveType, frontmatter);
-  if (!validation.valid) {
-    errors.push(...validation.errors);
-  }
-  const directory = options.directory ?? getDefaultDirectory(vaultPath, primitiveType);
-  if (!(0, import_node_fs3.existsSync)(directory)) {
-    (0, import_node_fs3.mkdirSync)(directory, { recursive: true });
-  }
-  const filename = options.filename ?? generateFilename(primitiveType, options.title, frontmatter);
-  const filePath = (0, import_node_path3.join)(directory, filename);
-  const fileExists = (0, import_node_fs3.existsSync)(filePath);
-  if (fileExists && !options.overwrite) {
-    return updateVaultFile(filePath, frontmatter, options.content, primitiveType, errors);
-  }
-  const fileContent = buildFileContent(frontmatter, options.content, schema);
-  try {
-    (0, import_node_fs3.writeFileSync)(filePath, fileContent, "utf-8");
-    return {
-      success: errors.length === 0,
-      path: filePath,
-      primitiveType,
-      errors,
-      created: true,
-      updated: false
-    };
-  } catch (err) {
-    errors.push(`Failed to write file: ${String(err)}`);
-    return {
-      success: false,
-      path: filePath,
-      primitiveType,
-      errors,
-      created: false,
-      updated: false
-    };
-  }
-}
-function updateVaultFile(filePath, newFrontmatter, newContent, primitiveType, errors) {
-  try {
-    const existingContent = (0, import_node_fs3.readFileSync)(filePath, "utf-8");
-    const parsed = parseExistingFile(existingContent);
-    if (!parsed) {
-      errors.push("Failed to parse existing file");
-      return {
-        success: false,
-        path: filePath,
-        primitiveType,
-        errors,
-        created: false,
-        updated: false
-      };
-    }
-    const mergedFrontmatter = {
-      ...parsed.frontmatter,
-      ...newFrontmatter,
-      updated: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    if (parsed.frontmatter.created) {
-      mergedFrontmatter.created = parsed.frontmatter.created;
-    }
-    const content = newContent ?? parsed.body;
-    const schema = getSchema(primitiveType);
-    const fileContent = buildFileContent(mergedFrontmatter, content, schema);
-    (0, import_node_fs3.writeFileSync)(filePath, fileContent, "utf-8");
-    return {
-      success: errors.length === 0,
-      path: filePath,
-      primitiveType,
-      errors,
-      created: false,
-      updated: true
-    };
-  } catch (err) {
-    errors.push(`Failed to update file: ${String(err)}`);
-    return {
-      success: false,
-      path: filePath,
-      primitiveType,
-      errors,
-      created: false,
-      updated: false
-    };
-  }
-}
-function parseExistingFile(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  if (!match) return null;
-  try {
-    const frontmatter = parseSimpleYaml3(match[1]);
-    return { frontmatter, body: match[2] };
-  } catch {
-    return null;
-  }
-}
-function parseSimpleYaml3(yaml) {
-  const result = {};
-  const lines = yaml.split("\n");
-  for (const line of lines) {
-    if (!line.trim() || line.trim().startsWith("#")) continue;
-    const colonIndex = line.indexOf(":");
-    if (colonIndex === -1) continue;
-    const key = line.slice(0, colonIndex).trim();
-    const valueStr = line.slice(colonIndex + 1).trim();
-    if (valueStr === "" || valueStr.startsWith("|") || valueStr.startsWith(">")) continue;
-    result[key] = parseYamlValue3(valueStr);
-  }
-  return result;
-}
-function parseYamlValue3(value) {
-  if (value === "" || value === "null" || value === "~") return null;
-  if (value === "true") return true;
-  if (value === "false") return false;
-  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
-  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-function getDefaultDirectory(vaultPath, primitiveType) {
-  const directoryMap = {
-    task: "tasks",
-    project: "projects",
-    decision: "decisions",
-    person: "people",
-    lesson: "lessons",
-    trigger: "triggers",
-    run: "runs",
-    checkpoint: "checkpoints",
-    handoff: "handoffs",
-    "daily-note": "daily",
-    daily: "daily",
-    party: "parties",
-    workspace: "workspaces",
-    memory_event: "memory"
-  };
-  const subdir = directoryMap[primitiveType] ?? "notes";
-  return (0, import_node_path3.join)(vaultPath, subdir);
-}
-function generateFilename(primitiveType, title, frontmatter) {
-  const now = /* @__PURE__ */ new Date();
-  const dateStr = now.toISOString().split("T")[0];
-  const timeStr = now.toISOString().slice(11, 19).replace(/:/g, "");
-  if (title) {
-    const slug = slugify(title);
-    return `${dateStr}-${slug}.md`;
-  }
-  switch (primitiveType) {
-    case "daily-note":
-    case "daily":
-      return `${dateStr}.md`;
-    case "memory_event":
-      return `${dateStr}-${timeStr}.md`;
-    case "run":
-      return `run-${dateStr}-${timeStr}.md`;
-    case "checkpoint":
-      return `checkpoint-${dateStr}-${timeStr}.md`;
-    case "handoff":
-      return `handoff-${dateStr}-${timeStr}.md`;
-    default:
-      return `${primitiveType}-${dateStr}-${timeStr}.md`;
-  }
-}
-function slugify(text) {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
-}
-function buildFileContent(frontmatter, content, schema) {
-  const parts = [];
-  parts.push(serializeFrontmatter(frontmatter));
-  parts.push("");
-  const title = frontmatter.title || frontmatter.summary;
-  if (title) {
-    parts.push(`# ${title}`);
-    parts.push("");
-  }
-  if (content) {
-    parts.push(content);
-  } else if (schema?.bodyTemplate) {
-    let body = schema.bodyTemplate;
-    body = body.replace(/\{\{title\}\}/g, String(title || "Untitled"));
-    body = body.replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
-    body = body.replace(/\{\{datetime\}\}/g, (/* @__PURE__ */ new Date()).toISOString());
-    body = body.replace(/\{\{links_line\}\}/g, "");
-    body = body.replace(/\{\{content\}\}/g, "");
-    parts.push(body.trim());
-  }
-  return parts.join("\n");
-}
-function writeObservation(vaultPath, observation, options = {}) {
-  return writeVaultFile(vaultPath, {
-    primitiveType: observation.primitiveType,
-    title: observation.text.slice(0, 80),
-    content: observation.text,
-    extraFields: {
-      type: observation.primitiveType === "memory_event" ? observation.category : observation.primitiveType,
-      confidence: observation.confidence,
-      tags: observation.tags,
-      observed_at: observation.extractedAt.toISOString()
-    },
-    source: options.source ?? "openclaw",
-    sessionId: options.sessionId
-  });
-}
-function appendToLedger(vaultPath, entry) {
-  const dateStr = entry.timestamp.toISOString().slice(0, 10);
-  const ledgerDir = (0, import_node_path3.join)(vaultPath, "ledger");
-  if (!(0, import_node_fs3.existsSync)(ledgerDir)) {
-    (0, import_node_fs3.mkdirSync)(ledgerDir, { recursive: true });
-  }
-  const ledgerFile = (0, import_node_path3.join)(ledgerDir, `${dateStr}.md`);
-  const timeStr = entry.timestamp.toISOString().slice(11, 19);
-  const parts = [`[${timeStr}]`];
-  if (entry.category) parts.push(`[${entry.category}]`);
-  if (entry.actor) parts.push(`(${entry.actor})`);
-  parts.push(entry.content);
-  const line = `
-- ${parts.join(" ")}`;
-  if (!(0, import_node_fs3.existsSync)(ledgerFile)) {
-    const frontmatter = serializeFrontmatter({
-      type: "ledger",
-      date: dateStr,
-      created: entry.timestamp.toISOString()
-    });
-    (0, import_node_fs3.writeFileSync)(ledgerFile, `${frontmatter}
-
-# Observation Ledger \u2014 ${dateStr}
-${line}`, "utf-8");
-  } else {
-    (0, import_node_fs3.appendFileSync)(ledgerFile, line, "utf-8");
-  }
-}
-function appendObservationToLedger(vaultPath, observation, actor) {
-  appendToLedger(vaultPath, {
-    timestamp: observation.extractedAt,
-    category: observation.category,
-    actor,
-    content: observation.text,
-    primitiveType: observation.primitiveType,
-    tags: observation.tags
-  });
-}
-function batchWriteObservations(vaultPath, observations, options = {}) {
-  const results = [];
-  let successful = 0;
-  let failed = 0;
-  const writeLedger = options.writeLedger ?? true;
-  const writeFiles = options.writeFiles ?? false;
-  for (const observation of observations) {
-    if (writeLedger) {
-      try {
-        appendObservationToLedger(vaultPath, observation, options.actor);
-      } catch {
-      }
-    }
-    if (writeFiles) {
-      const result = writeObservation(vaultPath, observation, {
-        source: options.source,
-        sessionId: options.sessionId
-      });
-      results.push(result);
-      if (result.success) {
-        successful++;
-      } else {
-        failed++;
-      }
-    } else {
-      successful++;
-      results.push({
-        success: true,
-        path: (0, import_node_path3.join)(vaultPath, "ledger", `${observation.extractedAt.toISOString().slice(0, 10)}.md`),
-        primitiveType: observation.primitiveType,
-        errors: [],
-        created: false,
-        updated: true
-      });
-    }
-  }
-  return {
-    total: observations.length,
-    successful,
-    failed,
-    results
-  };
-}
-function ensureVaultStructure(vaultPath) {
-  const directories = [
-    "tasks",
-    "projects",
-    "decisions",
-    "people",
-    "lessons",
-    "memory",
-    "ledger",
-    "daily"
-  ];
-  for (const dir of directories) {
-    const fullPath = (0, import_node_path3.join)(vaultPath, dir);
-    if (!(0, import_node_fs3.existsSync)(fullPath)) {
-      (0, import_node_fs3.mkdirSync)(fullPath, { recursive: true });
-    }
-  }
-}
-
-// src/plugin/index.ts
-function resolveVaultPath(cfg) {
-  if (cfg?.vaultPath) return cfg.vaultPath;
-  if (process.env.CLAWVAULT_PATH) return process.env.CLAWVAULT_PATH;
-  const home = process.env.HOME ?? process.env.USERPROFILE ?? ".";
-  for (const candidate of [`${home}/clawvault`, `${home}/.clawvault`]) {
-    if ((0, import_node_fs4.existsSync)((0, import_node_path4.join)(candidate, ".clawvault.json"))) return candidate;
-  }
-  return `${home}/.clawvault`;
-}
-function getVaultConfig(vaultPath) {
-  const configPath = (0, import_node_path4.join)(vaultPath, ".clawvault.json");
-  if (!(0, import_node_fs4.existsSync)(configPath)) return null;
-  try {
-    return JSON.parse((0, import_node_fs4.readFileSync)(configPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function qmdHybridSearch(query, collection, limit = 10) {
-  const sanitized = query.replace(/['']/g, " ").replace(/[^\w\s\-.,?!]/g, " ").trim();
-  if (!sanitized) return [];
-  try {
-    const result = (0, import_node_child_process.execFileSync)("qmd", [
-      "query",
-      sanitized,
-      "-n",
-      String(limit),
-      "--json",
-      "-c",
-      collection
-    ], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 10 * 1024 * 1024, timeout: 3e4 });
-    const parsed = JSON.parse(result);
-    if (Array.isArray(parsed) && parsed.length > 0) return parsed;
-  } catch (err) {
-    if (err?.stdout) {
-      try {
-        const parsed = JSON.parse(err.stdout);
-        if (Array.isArray(parsed) && parsed.length > 0) return parsed;
-      } catch {
-      }
-    }
-  }
-  try {
-    const result = (0, import_node_child_process.execFileSync)("qmd", [
-      "search",
-      sanitized,
-      "-n",
-      String(limit),
-      "--json",
-      "-c",
-      collection
-    ], { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 10 * 1024 * 1024, timeout: 15e3 });
-    return JSON.parse(result);
-  } catch (err) {
-    if (err?.stdout) {
-      try {
-        return JSON.parse(err.stdout);
-      } catch {
-      }
-    }
-    return [];
-  }
-}
-function observe(vaultPath, content, meta = {}) {
-  try {
-    const args = ["observe", "--content", content];
-    if (meta.tags?.length) args.push("--tags", meta.tags.join(","));
-    (0, import_node_child_process.execFile)("clawvault", args, { cwd: vaultPath, timeout: 15e3 }, () => {
-    });
-  } catch {
-  }
-}
-function qmdUpdateAsync(collection) {
-  try {
-    (0, import_node_child_process.execFile)("qmd", ["update", "-c", collection], { timeout: 3e4 }, () => {
-    });
-    (0, import_node_child_process.execFile)("qmd", ["embed", "-c", collection], { timeout: 6e4 }, () => {
-    });
-  } catch {
-  }
-}
-var templateRegistry = null;
-function getTemplateRegistry2() {
-  return templateRegistry;
-}
-var clawvaultPlugin = {
-  id: "clawvault",
-  name: "ClawVault Memory",
-  description: "Template-driven observational memory with hybrid search. Memories are captured automatically from conversations and classified against template schemas.",
-  version: "2.2.0",
-  kind: "memory",
-  register(api) {
-    const vaultPath = resolveVaultPath(api.pluginConfig);
-    const collection = api.pluginConfig?.collection || "clawvault";
-    const autoRecall = api.pluginConfig?.autoRecall !== false;
-    const autoCapture = api.pluginConfig?.autoCapture !== false;
-    const recallLimit = api.pluginConfig?.recallLimit || 5;
-    const templatesDir = api.pluginConfig?.templatesDir ?? (0, import_node_path4.join)(vaultPath, "..", "..", "templates");
-    templateRegistry = initializeTemplateRegistry(templatesDir);
-    api.logger.info(`[clawvault] Template registry initialized with ${templateRegistry.schemas.size} schemas`);
-    if (!(0, import_node_fs4.existsSync)((0, import_node_path4.join)(vaultPath, ".clawvault.json"))) {
-      api.logger.warn(`[clawvault] Vault not found at ${vaultPath}`);
-      return;
-    }
-    ensureVaultStructure(vaultPath);
-    api.logger.info(`[clawvault] v2.2.0 vault=${vaultPath} collection=${collection} recall=${autoRecall} capture=${autoCapture}`);
-    api.registerTool({
-      name: "memory_search",
-      label: "Memory Search",
-      description: "Search through long-term memories using ClawVault. Supports preferences, temporal queries, and multi-session knowledge retrieval.",
-      parameters: import_typebox.Type.Object({
-        query: import_typebox.Type.String({ description: "Search query \u2014 natural language question or keyword search" }),
-        limit: import_typebox.Type.Optional(import_typebox.Type.Number({ description: "Max results (default: 10)" })),
-        queryType: import_typebox.Type.Optional(import_typebox.Type.Union([
-          import_typebox.Type.Literal("preference"),
-          import_typebox.Type.Literal("temporal"),
-          import_typebox.Type.Literal("knowledge"),
-          import_typebox.Type.Literal("general")
-        ], { description: "Force query type (auto-detected if omitted)" }))
-      }),
-      async execute(_id, params) {
-        try {
-          let searchQuery = params.query;
-          if (params.queryType === "preference") searchQuery = `preference: ${searchQuery}`;
-          else if (params.queryType === "temporal") searchQuery = `when: ${searchQuery}`;
-          const limit = params.limit || 10;
-          const results = qmdHybridSearch(searchQuery, collection, limit);
-          if (results.length === 0) {
-            return {
-              content: [{ type: "text", text: "No relevant memories found." }],
-              details: { count: 0, provider: "clawvault" }
-            };
-          }
-          return {
-            content: [{ type: "text", text: formatSearchResults(results, collection) }],
-            details: { count: results.length, provider: "clawvault" }
-          };
-        } catch (err) {
-          return {
-            content: [{ type: "text", text: `Memory search error: ${String(err)}` }],
-            isError: true
-          };
-        }
-      }
-    });
-    api.registerTool({
-      name: "memory_get",
-      label: "Memory Get",
-      description: "Get vault status or stored preferences.",
-      parameters: import_typebox.Type.Object({
-        action: import_typebox.Type.Union([
-          import_typebox.Type.Literal("status"),
-          import_typebox.Type.Literal("preferences")
-        ], { description: "What to retrieve" })
-      }),
-      async execute(_id, params) {
-        try {
-          if (params.action === "status") {
-            const config = getVaultConfig(vaultPath);
-            let docCount = 0;
-            let vectorCount = 0;
-            try {
-              const stats = (0, import_node_child_process.execFileSync)("qmd", ["status", "--json", "-c", collection], {
-                encoding: "utf-8",
-                timeout: 5e3,
-                stdio: ["ignore", "pipe", "pipe"]
-              });
-              const parsed = JSON.parse(stats);
-              docCount = parsed.documents ?? parsed.doc_count ?? 0;
-              vectorCount = parsed.vectors ?? parsed.vector_count ?? 0;
-            } catch {
-            }
-            return {
-              content: [{ type: "text", text: JSON.stringify({
-                vault: vaultPath,
-                name: config?.name || "clawvault",
-                collection,
-                documents: docCount,
-                vectors: vectorCount,
-                autoRecall,
-                autoCapture,
-                version: "2.2.0",
-                templateSchemas: templateRegistry?.schemas.size ?? 0
-              }, null, 2) }]
-            };
-          }
-          const prefContext = buildPreferenceContext(vaultPath, { limit: 20 });
-          if (prefContext.preferenceCount === 0) {
-            const results = qmdHybridSearch("user preference likes dislikes prefers wants", collection, 20);
-            const prefResults = results.filter(
-              (r) => r.file?.includes("preference") || r.snippet?.toLowerCase().match(/prefer|like|want|hate|love|always|never/)
-            );
-            if (prefResults.length === 0) {
-              return { content: [{ type: "text", text: "No preferences found in vault." }] };
-            }
-            const text = prefResults.map((r, i) => {
-              const file = (r.file || "").replace(`qmd://${collection}/`, "");
-              const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim() || r.title;
-              return `${i + 1}. [${file}] ${snippet}`;
-            }).join("\n");
-            return { content: [{ type: "text", text }] };
-          }
-          return { content: [{ type: "text", text: prefContext.xml }] };
-        } catch (err) {
-          return {
-            content: [{ type: "text", text: `Memory get error: ${String(err)}` }],
-            isError: true
-          };
-        }
-      }
-    });
-    api.registerTool({
-      name: "memory_store",
-      label: "Memory Store",
-      description: "Save important information in long-term memory. Use for preferences, facts, decisions, or anything worth remembering.",
-      parameters: import_typebox.Type.Object({
-        text: import_typebox.Type.String({ description: "Information to remember" }),
-        category: import_typebox.Type.Optional(import_typebox.Type.Union([
-          import_typebox.Type.Literal("preference"),
-          import_typebox.Type.Literal("fact"),
-          import_typebox.Type.Literal("decision"),
-          import_typebox.Type.Literal("entity"),
-          import_typebox.Type.Literal("event"),
-          import_typebox.Type.Literal("other")
-        ], { description: "Memory category (auto-detected if omitted)" })),
-        tags: import_typebox.Type.Optional(import_typebox.Type.Array(import_typebox.Type.String(), { description: "Tags for organization" }))
-      }),
-      async execute(_id, params) {
-        try {
-          const classification = classifyText(params.text);
-          const category = params.category || detectCategory(params.text);
-          const tags = params.tags || [category, ...classification.matchedKeywords.slice(0, 3)];
-          const result = writeVaultFile(vaultPath, {
-            primitiveType: classification.primitiveType,
-            title: params.text.slice(0, 80),
-            content: params.text,
-            extraFields: {
-              type: category,
-              confidence: classification.confidence,
-              tags
-            },
-            source: "openclaw"
-          });
-          appendToLedger(vaultPath, {
-            timestamp: /* @__PURE__ */ new Date(),
-            category,
-            content: params.text,
-            primitiveType: classification.primitiveType,
-            tags
-          });
-          qmdUpdateAsync(collection);
-          return {
-            content: [{ type: "text", text: `Stored: "${params.text.slice(0, 100)}${params.text.length > 100 ? "..." : ""}" [${classification.primitiveType}/${category}]` }],
-            details: {
-              action: result.created ? "created" : "updated",
-              category,
-              primitiveType: classification.primitiveType,
-              path: result.path
-            }
-          };
-        } catch (err) {
-          return {
-            content: [{ type: "text", text: `Memory store error: ${String(err)}` }],
-            isError: true
-          };
-        }
-      }
-    });
-    api.registerTool({
-      name: "memory_forget",
-      label: "Memory Forget",
-      description: "Delete specific memories from the vault.",
-      parameters: import_typebox.Type.Object({
-        query: import_typebox.Type.String({ description: "Search query to find the memory to delete" }),
-        confirm: import_typebox.Type.Optional(import_typebox.Type.Boolean({ description: "Set true to confirm deletion of first match" }))
-      }),
-      async execute(_id, params) {
-        try {
-          const results = qmdHybridSearch(params.query, collection, 5);
-          if (results.length === 0) {
-            return {
-              content: [{ type: "text", text: "No matching memories found." }],
-              details: { found: 0 }
-            };
-          }
-          if (!params.confirm) {
-            const list = results.map((r, i) => {
-              const file2 = (r.file || "").replace(`qmd://${collection}/`, "");
-              const snippet = (r.snippet || "").replace(/@@ .+? @@\s*\(.+?\)\n?/g, "").trim().slice(0, 80);
-              return `${i + 1}. [${file2}] ${snippet}`;
-            }).join("\n");
-            return {
-              content: [{ type: "text", text: `Found ${results.length} candidates:
-${list}
-
-Call again with confirm=true to delete the top match.` }],
-              details: { action: "candidates", count: results.length }
-            };
-          }
-          const target = results[0];
-          const file = (target.file || "").replace(`qmd://${collection}/`, "");
-          const fullPath = (0, import_node_path4.join)(vaultPath, file);
-          if ((0, import_node_fs4.existsSync)(fullPath)) {
-            const trashDir = (0, import_node_path4.join)(vaultPath, ".trash");
-            if (!(0, import_node_fs4.existsSync)(trashDir)) (0, import_node_fs4.mkdirSync)(trashDir, { recursive: true });
-            const trashPath = (0, import_node_path4.join)(trashDir, `${Date.now()}-${(0, import_node_path4.basename)(file)}`);
-            const { renameSync } = require("fs");
-            renameSync(fullPath, trashPath);
-            qmdUpdateAsync(collection);
-            return {
-              content: [{ type: "text", text: `Forgotten: [${file}] (moved to .trash)` }],
-              details: { action: "deleted", file, trashPath }
-            };
-          }
-          return {
-            content: [{ type: "text", text: `File not found on disk: ${file}` }],
-            details: { action: "not_found", file }
-          };
-        } catch (err) {
-          return {
-            content: [{ type: "text", text: `Memory forget error: ${String(err)}` }],
-            isError: true
-          };
-        }
-      }
-    });
-    if (autoRecall) {
-      api.on("before_agent_start", async (event) => {
-        if (!event.prompt || event.prompt.length < 10) return;
-        if (event.prompt.includes("HEARTBEAT") || event.prompt.startsWith("[System")) return;
-        try {
-          const contextParts = [];
-          const recap = buildSessionRecap(vaultPath, {
-            maxAge: 24 * 60 * 60 * 1e3,
-            // 24 hours
-            limit: 10,
-            includeContent: true
-          });
-          if (recap.xml) {
-            contextParts.push(recap.xml);
-          }
-          const searchTerms = extractSearchTerms(event.prompt);
-          const results = qmdHybridSearch(searchTerms, collection, recallLimit);
-          if (results.length > 0) {
-            const topScore = results[0]?.score ?? 0;
-            if (topScore >= 0.25) {
-              contextParts.push(formatMemoriesForContext(results, collection));
-              api.logger.info(`[clawvault] auto-recall: ${results.length} memories (top: ${(topScore * 100).toFixed(0)}%, query: "${searchTerms.slice(0, 60)}")`);
-            }
-          }
-          if (contextParts.length === 0) return;
-          return {
-            prependContext: contextParts.join("\n\n")
-          };
-        } catch (err) {
-          api.logger.warn(`[clawvault] auto-recall failed: ${String(err)}`);
-        }
-      }, { priority: 10 });
-    }
-    if (autoCapture) {
-      api.on("message_received", async (event) => {
-        if (!event.content || !isObservable(event.content)) return;
-        try {
-          const result = processMessageForObservations(event.content, {
-            from: event.from,
-            sessionId: event.sessionId
-          });
-          if (result.observations.length === 0) return;
-          const writeResult = batchWriteObservations(vaultPath, result.observations, {
-            source: "openclaw",
-            sessionId: event.sessionId,
-            actor: event.from || "user",
-            writeLedger: true,
-            writeFiles: false
-            // Only write to ledger for speed
-          });
-          api.logger.info(`[clawvault] auto-captured ${writeResult.successful} observations from incoming message`);
-        } catch (err) {
-          api.logger.warn(`[clawvault] message capture failed: ${String(err)}`);
-        }
-      });
-      api.on("agent_end", async (event) => {
-        if (!event.success || !event.messages?.length) return;
-        try {
-          let captured = 0;
-          for (const msg of event.messages) {
-            if (!msg || typeof msg !== "object") continue;
-            if (msg.role === "user") {
-              const content = typeof msg.content === "string" ? msg.content : Array.isArray(msg.content) ? msg.content.filter((b) => b?.type === "text").map((b) => b.text).join(" ") : "";
-              if (isObservable(content)) {
-                const result = processMessageForObservations(content);
-                for (const obs of result.observations) {
-                  observe(vaultPath, obs.text, { tags: obs.tags });
-                  captured++;
-                }
-              }
-            }
-          }
-          if (captured > 0) {
-            api.logger.info(`[clawvault] agent_end: captured ${captured} observations`);
-            qmdUpdateAsync(collection);
-          }
-        } catch (err) {
-          api.logger.warn(`[clawvault] agent_end capture failed: ${String(err)}`);
-        }
-      });
-    }
-    api.on("before_compaction", async () => {
-      try {
-        (0, import_node_child_process.execFileSync)("qmd", ["update", "-c", collection], {
-          timeout: 15e3,
-          encoding: "utf-8",
-          stdio: ["ignore", "pipe", "pipe"]
-        });
-        api.logger.info("[clawvault] pre-compaction index update complete");
-      } catch (err) {
-        api.logger.warn(`[clawvault] pre-compaction update failed: ${String(err)}`);
-      }
-    });
-    api.registerService({
-      id: "clawvault",
-      start: () => {
-        api.logger.info(`[clawvault] service started \u2014 vault=${vaultPath}`);
-        qmdUpdateAsync(collection);
-      },
-      stop: () => {
-        api.logger.info("[clawvault] service stopped");
-      }
-    });
-    api.registerCli(
-      ({ program }) => {
-        const cmd = program.command("vault").description("ClawVault memory commands");
-        cmd.command("status").action(() => {
-          const config = getVaultConfig(vaultPath);
-          console.log(JSON.stringify({
-            vault: vaultPath,
-            version: "2.2.0",
-            templateSchemas: templateRegistry?.schemas.size ?? 0,
-            ...config
-          }, null, 2));
-        });
-        cmd.command("search <query>").option("-n, --limit <n>", "Max results", "10").action((query, opts) => {
-          const results = qmdHybridSearch(query, collection, parseInt(opts.limit));
-          console.log(formatSearchResults(results, collection));
-        });
-        cmd.command("templates").action(() => {
-          const schemas = getAllSchemas();
-          console.log("Registered template schemas:");
-          for (const schema of schemas) {
-            console.log(`  - ${schema.primitive}: ${schema.description || "(no description)"}`);
-            console.log(`    Fields: ${Object.keys(schema.fields).join(", ")}`);
-          }
-        });
-        cmd.command("classify <text>").action((text) => {
-          const result = classifyText(text);
-          console.log(JSON.stringify(result, null, 2));
-        });
-      },
-      { commands: ["vault"] }
-    );
-    api.registerCommand({
-      name: "vault",
-      description: "ClawVault status and quick search",
-      acceptsArgs: true,
-      requireAuth: true,
-      handler: (ctx) => {
-        const args = (ctx.args || "").trim();
-        if (!args || args === "status") {
-          const config = getVaultConfig(vaultPath);
-          let docCount = 0, vectorCount = 0;
-          try {
-            const stats = (0, import_node_child_process.execFileSync)("qmd", ["status", "--json", "-c", collection], {
-              encoding: "utf-8",
-              timeout: 5e3,
-              stdio: ["ignore", "pipe", "pipe"]
-            });
-            const p = JSON.parse(stats);
-            docCount = p.documents ?? p.doc_count ?? 0;
-            vectorCount = p.vectors ?? p.vector_count ?? 0;
-          } catch {
-          }
-          return {
-            text: `\u{1F9E0} ClawVault v2.2.0
-Vault: ${vaultPath}
-Docs: ${docCount} | Vectors: ${vectorCount}
-Recall: ${autoRecall ? "\u2705" : "\u274C"} | Capture: ${autoCapture ? "\u2705" : "\u274C"}
-Templates: ${templateRegistry?.schemas.size ?? 0} schemas`
-          };
-        }
-        if (args.startsWith("search ")) {
-          const query = args.slice(7).trim();
-          const results = qmdHybridSearch(query, collection, 5);
-          return { text: formatSearchResults(results, collection) };
-        }
-        if (args === "templates") {
-          const names = getSchemaNames();
-          return { text: `Template schemas: ${names.join(", ")}` };
-        }
-        if (args === "recap") {
-          const recap = buildSessionRecap(vaultPath, { limit: 10, includeContent: true });
-          return { text: recap.xml || "No recent activity found." };
-        }
-        return { text: "Usage: /vault [status|search <query>|templates|recap]" };
-      }
-    });
-    console.log(`[clawvault] v2.2.0 registered \u2014 vault=${vaultPath} templates=${templateRegistry?.schemas.size ?? 0}`);
-  }
-};
-var plugin_default = clawvaultPlugin;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  appendToLedger,
-  batchWriteObservations,
-  buildFullContext,
-  buildPreferenceContext,
-  buildSessionRecap,
-  classifyText,
-  detectCategory,
-  ensureVaultStructure,
-  extractObservations,
-  extractSearchTerms,
-  formatMemoriesForContext,
-  formatSearchResults,
-  getAllSchemas,
-  getSchema,
-  getSchemaNames,
-  getTemplateRegistry,
-  initializeTemplateRegistry,
-  isObservable,
-  processMessageForObservations,
-  scanVaultFiles,
-  writeObservation,
-  writeVaultFile
-});