clawvault 2.6.0 → 3.0.0

package/dist/{chunk-IEVLHNLU.js → chunk-LNJA2UGL.js}

@@ -1,9 +1,9 @@
+import {
+  Observer
+} from "./chunk-3NSBOUT3.js";
 import {
   getSessionsDir
 } from "./chunk-HRLWZGMA.js";
-import {
-  Observer
-} from "./chunk-Q2J5YTUF.js";
 
 // src/observer/active-session-observer.ts
 import * as fs from "fs";
@@ -18,6 +18,11 @@ var AGENT_ID_RE = /^[a-zA-Z0-9_-]{1,100}$/;
 var SESSION_ID_RE = /^[a-zA-Z0-9._-]{1,200}$/;
 var CURSOR_FILE_NAME = "observe-cursors.json";
 var STALE_CURSOR_THRESHOLD_MS = 12 * 60 * 60 * 1e3;
+function formatBytes(bytes) {
+  if (bytes >= ONE_MIB) return `${(bytes / ONE_MIB).toFixed(1)}MB`;
+  if (bytes >= ONE_KIB) return `${Math.round(bytes / ONE_KIB)}KB`;
+  return `${bytes}B`;
+}
 function isFiniteNonNegative(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
@@ -153,7 +158,12 @@ function getObserverStaleness(vaultPath, options = {}) {
     if (!sessionStat.isFile()) {
       continue;
     }
-    if (cursor.lastFileSize >= sessionStat.size) {
+    const newBytes = sessionStat.size - cursor.lastFileSize;
+    if (newBytes <= 0) {
+      continue;
+    }
+    const processThreshold = getScaledObservationThresholdBytes(sessionStat.size);
+    if (newBytes < processThreshold) {
       continue;
     }
     staleCount += 1;
@@ -181,8 +191,32 @@ function loadSessionIndex(sessionsDir) {
     return {};
   }
 }
+function findMostRecentResetFile(sessionsDir, sessionId) {
+  const prefix = `${sessionId}.jsonl.reset.`;
+  try {
+    const files = fs.readdirSync(sessionsDir).filter((f) => f.startsWith(prefix)).sort().reverse();
+    return files.length > 0 ? path.join(sessionsDir, files[0]) : null;
+  } catch {
+    return null;
+  }
+}
 function resolveTranscriptPath(sessionsDir, sessionId) {
-  return path.join(sessionsDir, `${sessionId}.jsonl`);
+  const mainPath = path.join(sessionsDir, `${sessionId}.jsonl`);
+  try {
+    const stat = fs.statSync(mainPath);
+    if (stat.size < 100) {
+      const resetFile = findMostRecentResetFile(sessionsDir, sessionId);
+      if (resetFile) {
+        return resetFile;
+      }
+    }
+  } catch {
+    const resetFile = findMostRecentResetFile(sessionsDir, sessionId);
+    if (resetFile) {
+      return resetFile;
+    }
+  }
+  return mainPath;
 }
 function discoverSessionDescriptors(sessionsDir, fallbackAgentId) {
   const descriptors = [];
@@ -259,6 +293,21 @@ function normalizeRole(role) {
   }
   return role.trim().toLowerCase();
 }
+function summarizeContentArray(content) {
+  const parts = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const b = block;
+    if (b.type === "text" && typeof b.text === "string") {
+      const text = normalizeWhitespace(b.text);
+      if (text) parts.push(text);
+    } else if (b.type === "toolCall") {
+      const toolName = typeof b.name === "string" ? b.name : "tool";
+      parts.push(`[tool: ${toolName}]`);
+    }
+  }
+  return parts.join(" ");
+}
 function parseOpenClawJsonLine(line) {
   if (!line.trim()) {
     return "";
@@ -275,14 +324,38 @@ function parseOpenClawJsonLine(line) {
   const entry = parsed;
   if ("role" in entry && "content" in entry) {
     const role = normalizeRole(entry.role);
-    const content = extractContentText(entry.content);
+    if (role === "system") return "";
+    if (role === "toolresult") {
+      const output = extractContentText(entry.content);
+      const preview = output.slice(0, 80) || "ok";
+      return `[tool_result \u2192 ${preview}]`;
+    }
+    const raw = entry.content;
+    let content;
+    if (Array.isArray(raw)) {
+      content = summarizeContentArray(raw);
+    } else {
+      content = extractContentText(raw);
+    }
     if (!content) return "";
     return role ? `${role}: ${content}` : content;
   }
   if (entry.type === "message" && entry.message && typeof entry.message === "object") {
     const message = entry.message;
     const role = normalizeRole(message.role);
-    const content = extractContentText(message.content);
+    if (role === "system") return "";
+    if (role === "toolresult") {
+      const output = extractContentText(message.content);
+      const preview = output.slice(0, 80) || "ok";
+      return `[tool_result \u2192 ${preview}]`;
+    }
+    const raw = message.content;
+    let content;
+    if (Array.isArray(raw)) {
+      content = summarizeContentArray(raw);
+    } else {
+      content = extractContentText(raw);
+    }
     if (!content) return "";
     return role ? `${role}: ${content}` : content;
   }
@@ -445,7 +518,9 @@ async function observeActiveSessions(options, dependencies = {}) {
   const now = dependencies.now ?? (() => /* @__PURE__ */ new Date());
   const cursors = loadObserveCursorStore(vaultPath);
   const descriptors = discoverSessionDescriptors(sessionsDir, agentId);
-  const candidates = selectCandidates(descriptors, cursors, options.minNewBytes);
+  const allCandidates = selectCandidates(descriptors, cursors, options.minNewBytes);
+  allCandidates.sort((a, b) => b.newBytes - a.newBytes);
+  const candidates = options.maxSessions != null && options.maxSessions > 0 ? allCandidates.slice(0, options.maxSessions) : allCandidates;
   if (dryRun || candidates.length === 0) {
     return {
       agentId,
@@ -475,7 +550,9 @@ async function observeActiveSessions(options, dependencies = {}) {
   let observedNewBytes = 0;
   const routedCounts = {};
   const failedSessions = [];
-  for (const candidate of candidates) {
+  for (let i = 0; i < candidates.length; i += 1) {
+    const candidate = candidates[i];
+    console.log(`[observer] processing session ${i + 1}/${candidates.length}: ${candidate.sessionKey} (${formatBytes(candidate.newBytes)} new)`);
     try {
       const observer = observerFactory(vaultPath, observerOptions);
       const { messages, nextOffset } = await readIncrementalMessages(candidate.filePath, candidate.startOffset);

package/dist/{chunk-MFAWT5O5.js → chunk-LYHGEHXG.js}

@@ -295,6 +295,7 @@ export {
   normalizeTemplateName,
   buildTemplateIndex,
   parseTemplateDefinition,
+  loadTemplateDefinition,
   loadSchemaTemplateDefinition,
   listTemplateDefinitions,
   renderDocumentFromTemplate

package/dist/chunk-MFM6K7PU.js

@@ -0,0 +1,374 @@
+import {
+  classifyText,
+  generateFrontmatter,
+  getSchema,
+  serializeFrontmatter,
+  validateFrontmatter
+} from "./chunk-GQSLDZTS.js";
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
+
+// src/plugin/vault.ts
+import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from "fs";
+import { join } from "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 (!existsSync(directory)) {
+    mkdirSync(directory, { recursive: true });
+  }
+  const filename = options.filename ?? generateFilename(primitiveType, options.title, frontmatter);
+  const filePath = join(directory, filename);
+  const fileExists = existsSync(filePath);
+  if (fileExists && !options.overwrite) {
+    return updateVaultFile(filePath, frontmatter, options.content, primitiveType, errors);
+  }
+  const fileContent = buildFileContent(frontmatter, options.content, schema);
+  try {
+    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 = 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);
+    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 = parseSimpleYaml(match[1]);
+    return { frontmatter, body: match[2] };
+  } catch {
+    return null;
+  }
+}
+function parseSimpleYaml(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] = parseYamlValue(valueStr);
+  }
+  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;
+}
+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 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 writeObservations(vaultPath, observations, options = {}) {
+  return observations.map((obs) => writeObservation(vaultPath, obs, options));
+}
+function appendToLedger(vaultPath, entry) {
+  const dateStr = entry.timestamp.toISOString().slice(0, 10);
+  const ledgerDir = join(vaultPath, "ledger");
+  if (!existsSync(ledgerDir)) {
+    mkdirSync(ledgerDir, { recursive: true });
+  }
+  const ledgerFile = 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 (!existsSync(ledgerFile)) {
+    const frontmatter = serializeFrontmatter({
+      type: "ledger",
+      date: dateStr,
+      created: entry.timestamp.toISOString()
+    });
+    writeFileSync(ledgerFile, `${frontmatter}
+
+# Observation Ledger \u2014 ${dateStr}
+${line}`, "utf-8");
+  } else {
+    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: 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 = join(vaultPath, dir);
+    if (!existsSync(fullPath)) {
+      mkdirSync(fullPath, { recursive: true });
+    }
+  }
+}
+function getVaultStats(vaultPath) {
+  const directories = [];
+  const primitiveTypes = {};
+  let fileCount = 0;
+  const { readdirSync, statSync } = __require("fs");
+  function scanDir(dir, depth = 0) {
+    if (depth > 2) return;
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          directories.push(fullPath.replace(vaultPath + "/", ""));
+          scanDir(fullPath, depth + 1);
+        } else if (entry.name.endsWith(".md")) {
+          fileCount++;
+          try {
+            const content = readFileSync(fullPath, "utf-8");
+            const match = content.match(/^---\n[\s\S]*?type:\s*(\S+)/);
+            if (match) {
+              const type = match[1];
+              primitiveTypes[type] = (primitiveTypes[type] ?? 0) + 1;
+            }
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  scanDir(vaultPath);
+  return { directories, fileCount, primitiveTypes };
+}
+
+export {
+  writeVaultFile,
+  writeObservation,
+  writeObservations,
+  appendToLedger,
+  appendObservationToLedger,
+  batchWriteObservations,
+  ensureVaultStructure,
+  getVaultStats
+};

package/dist/{chunk-QWQ3TIKS.js → chunk-N2AXRYLC.js}

@@ -1,7 +1,7 @@
 import {
   loadSchemaTemplateDefinition,
   renderDocumentFromTemplate
-} from "./chunk-MFAWT5O5.js";
+} from "./chunk-LYHGEHXG.js";
 
 // src/lib/task-utils.ts
 import * as fs2 from "fs";

package/dist/chunk-PAH27GSN.js

@@ -0,0 +1,108 @@
+// src/lib/claude-credentials.ts
+import { execFileSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CLAUDE_CODE_SERVICE = "Claude Code-credentials";
+var CLAUDE_CODE_ACCOUNT = "Claude Code";
+var OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+var TOKEN_REFRESH_URL = "https://console.anthropic.com/v1/oauth/token";
+var EXPIRY_BUFFER_MS = 5 * 60 * 1e3;
+function readClaudeCliCredentials(opts) {
+  if (process.platform === "darwin") {
+    try {
+      const raw = execFileSync(
+        "security",
+        ["find-generic-password", "-s", CLAUDE_CODE_SERVICE, "-w"],
+        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+      ).trim();
+      const parsed = parseCredentialsJson(raw);
+      if (parsed) return parsed;
+    } catch {
+    }
+  }
+  const home = opts?.homeDir ?? homedir();
+  const credFile = join(home, ".claude", ".credentials.json");
+  if (!existsSync(credFile)) {
+    return null;
+  }
+  try {
+    const raw = readFileSync(credFile, "utf8");
+    return parseCredentialsJson(raw);
+  } catch {
+    return null;
+  }
+}
+function parseCredentialsJson(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    const oauth = parsed.claudeAiOauth;
+    if (oauth && typeof oauth.accessToken === "string" && typeof oauth.refreshToken === "string" && typeof oauth.expiresAt === "number") {
+      return {
+        accessToken: oauth.accessToken,
+        refreshToken: oauth.refreshToken,
+        expiresAt: oauth.expiresAt
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+async function refreshClaudeOAuthToken(refreshToken, fetchImpl) {
+  const f = fetchImpl ?? fetch;
+  const response = await f(TOKEN_REFRESH_URL, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      grant_type: "refresh_token",
+      client_id: OAUTH_CLIENT_ID,
+      refresh_token: refreshToken
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`OAuth token refresh failed (${response.status})`);
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: Date.now() + data.expires_in * 1e3
+  };
+}
+function writeClaudeCliCredentials(cred, opts) {
+  const payload = JSON.stringify({ claudeAiOauth: cred });
+  if (process.platform === "darwin") {
+    try {
+      execFileSync(
+        "security",
+        ["add-generic-password", "-U", "-s", CLAUDE_CODE_SERVICE, "-a", CLAUDE_CODE_ACCOUNT, "-w", payload],
+        { stdio: "ignore" }
+      );
+      return;
+    } catch {
+    }
+  }
+  const home = opts?.homeDir ?? homedir();
+  const credFile = join(home, ".claude", ".credentials.json");
+  writeFileSync(credFile, payload, "utf8");
+}
+async function resolveClaudeOAuthToken(opts) {
+  const cred = readClaudeCliCredentials(opts);
+  if (!cred) {
+    return null;
+  }
+  if (cred.expiresAt < Date.now() + EXPIRY_BUFFER_MS) {
+    try {
+      const refreshed = await refreshClaudeOAuthToken(cred.refreshToken, opts?.fetchImpl);
+      writeClaudeCliCredentials(refreshed, opts);
+      return refreshed.accessToken;
+    } catch {
+      return cred.accessToken;
+    }
+  }
+  return cred.accessToken;
+}
+
+export {
+  resolveClaudeOAuthToken
+};

package/dist/{chunk-OIWVQYQF.js → chunk-QBLMXKF2.js}

@@ -4,7 +4,7 @@ import {
 import {
   checkDirtyDeath,
   clearDirtyFlag
-} from "./chunk-F55HGNU4.js";
+} from "./chunk-WAZ3NLWL.js";
 
 // src/commands/recover.ts
 import * as fs from "fs";

package/dist/{chunk-FHFUXL6G.js → chunk-QK3UCXWL.js}

@@ -3,7 +3,7 @@ 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)\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;
@@ -33,10 +33,10 @@ 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 (PREFERENCE_RE.test(content)) return "preference";
   if (LESSON_RE.test(content)) return "lesson";
   if (RELATIONSHIP_RE.test(content)) return "relationship";
   if (PROJECT_RE.test(content)) return "project";

package/dist/{chunk-2YDBJS7M.js → chunk-SJSFRIYS.js}

@@ -1,6 +1,6 @@
 import {
   runReflection
-} from "./chunk-YOSEUUNB.js";
+} from "./chunk-H34S76MB.js";
 import {
   resolveVaultPath
 } from "./chunk-MXSSG3QU.js";