clawvault 3.1.0 → 3.2.0

package/dist/{chunk-3NSBOUT3.js → chunk-77Q5CSPJ.js}

@@ -1,21 +1,11 @@
 import {
   listProjects
-} from "./chunk-62YTUT6J.js";
+} from "./chunk-4PY655YM.js";
 import {
-  listConfig,
-  listRouteRules,
-  matchRouteRule
-} from "./chunk-ITPEXLHA.js";
-import {
-  resolveClaudeOAuthToken
-} from "./chunk-PAH27GSN.js";
-import {
-  createBacklogItem,
-  listBacklogItems,
-  listTasks,
-  updateBacklogItem,
-  updateTask
-} from "./chunk-N2AXRYLC.js";
+  FactStore,
+  extractFactsLlm,
+  extractFactsRuleBased
+} from "./chunk-BSJ6RIT7.js";
 import {
   DATE_HEADING_RE,
   inferObservationType,
@@ -24,7 +14,16 @@ import {
   parseObservationMarkdown,
   renderObservationMarkdown,
   renderScoredObservationLine
-} from "./chunk-QK3UCXWL.js";
+} from "./chunk-FHFUXL6G.js";
+import {
+  listConfig,
+  listRouteRules,
+  matchRouteRule
+} from "./chunk-URXDAUVH.js";
+import {
+  requestLlmCompletion,
+  resolveLlmProvider
+} from "./chunk-NCKFNBHJ.js";
 import {
   ensureLedgerStructure,
   ensureParentDir,
@@ -33,16 +32,27 @@ import {
   getRawTranscriptPath,
   toDateKey
 } from "./chunk-Z2XBWN7A.js";
+import {
+  createBacklogItem,
+  listBacklogItems,
+  listTasks,
+  updateBacklogItem,
+  updateTask
+} from "./chunk-QWQ3TIKS.js";
 
 // src/observer/compressor.ts
 var OPENAI_BASE_URL = "https://api.openai.com/v1";
+var XAI_BASE_URL = "https://api.x.ai/v1";
 var OLLAMA_BASE_URL = "http://localhost:11434/v1";
 var DEFAULT_PROVIDER_MODELS = {
-  anthropic: "claude-haiku-4-5",
+  anthropic: "claude-3-5-haiku-latest",
   openai: "gpt-4o-mini",
   gemini: "gemini-2.0-flash",
+  xai: "grok-2-latest",
   "openai-compatible": "gpt-4o-mini",
-  ollama: "llama3.2"
+  ollama: "llama3.2",
+  minimax: "MiniMax-M2.1",
+  zai: "glm-4.5-air"
 };
 var CRITICAL_RE = /(?:\b(?:decision|decided|chose|chosen|selected|picked|opted|switched to)\s*:?|\bdecid(?:e|ed|ing|ion)\b|\berror\b|\bfail(?:ed|ure|ing)?\b|\bblock(?:ed|er)?\b|\bbreaking(?:\s+change)?s?\b|\bcritical\b|\b\w+\s+chosen\s+(?:for|over|as)\b|\bpublish(?:ed)?\b.*@?\d+\.\d+|\bmerge[d]?\s+(?:PR|pull\s+request)\b|\bshipped\b|\breleased?\b.*v?\d+\.\d+|\bsigned\b.*\b(?:contract|agreement|deal)\b|\bpricing\b.*\$|\bdemo\b.*\b(?:completed?|done|finished)\b|\bmeeting\b.*\b(?:completed?|done|finished)\b|\bstrategy\b.*\b(?:pivot|change|shift)\b)/i;
 var DEADLINE_WITH_DATE_RE = /(?:(?:\bdeadline\b|\bdue(?:\s+date)?\b|\bcutoff\b).*(?:\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}(?:\/\d{2,4})?|(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\s+\d{1,2})|(?:\d{4}-\d{2}-\d{2}|\d{1,2}\/\d{1,2}(?:\/\d{2,4})?|(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\s+\d{1,2}).*(?:\bdeadline\b|\bdue(?:\s+date)?\b|\bcutoff\b))/i;
@@ -51,6 +61,11 @@ var TODO_SIGNAL_RE = /(?:\btodo:\s*|\bwe need to\b|\bdon't forget(?: to)?\b|\bre
 var COMMITMENT_TASK_SIGNAL_RE = /\b(?:i'?ll|i will|let me|(?:i'?m\s+)?going to|plan to|should)\b/i;
 var UNRESOLVED_COMMITMENT_RE = /\b(?:need to figure out|tbd|to be determined)\b/i;
 var DEADLINE_SIGNAL_RE = /\b(?:by\s+(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday|tomorrow)|before\s+the\s+\w+|deadline is)\b/i;
+var ROLE_PREFIX_RE = /^([a-z][a-z0-9_-]{1,31})\s*:\s*(.+)$/i;
+var BASE64_DATA_URI_RE = /\bdata:[^;\s]+;base64,[A-Za-z0-9+/=]{24,}\b/gi;
+var LONG_BASE64_TOKEN_RE = /\b[A-Za-z0-9+/]{80,}={0,2}\b/g;
+var NOISE_PREFIX_RE = /^(?:metadata|system metadata|session metadata|tool[_-]?result|toolresult)\s*:/i;
+var STRUCTURED_NOISE_MARKER_RE = /\b(?:tool[_-]?result|tool[_-]?use|toolcallid|tooluseid|function[_-]?(?:call|result)|stdout|stderr|exitcode|recordedat|trace(?:_|-)?id|parent(?:_|-)?id|session(?:_|-)?id|metadata|base64|mime(?:type)?)\b/i;
 var Compressor = class {
   provider;
   model;
@@ -67,15 +82,15 @@ var Compressor = class {
     this.fetchImpl = options.fetchImpl ?? fetch;
   }
   async compress(messages, existingObservations) {
-    const cleanedMessages = messages.map((message) => message.trim()).filter(Boolean);
+    const cleanedMessages = this.sanitizeIncomingMessages(messages);
     if (cleanedMessages.length === 0) {
       return existingObservations.trim();
     }
     const prompt = this.buildPrompt(cleanedMessages, existingObservations);
-    const backend = await this.resolveProvider();
+    const backend = this.resolveProvider();
     if (backend) {
       try {
-        const llmOutput = backend.provider === "anthropic" ? await this.callAnthropic(prompt, backend) : backend.provider === "gemini" ? await this.callGemini(prompt, backend) : backend.provider === "openai" ? await this.callOpenAI(prompt, backend) : await this.callOpenAICompatible(prompt, backend);
+        const llmOutput = backend.provider === "anthropic" ? await this.callAnthropic(prompt, backend) : backend.provider === "gemini" ? await this.callGemini(prompt, backend) : backend.provider === "openai" ? await this.callOpenAI(prompt, backend) : backend.provider === "xai" ? await this.callXAI(prompt, backend) : await this.callOpenAICompatible(prompt, backend);
         const normalized = this.normalizeLlmOutput(llmOutput);
         if (normalized) {
           return this.mergeObservations(existingObservations, normalized);
@@ -86,16 +101,100 @@ var Compressor = class {
     const fallback = this.fallbackCompression(cleanedMessages);
     return this.mergeObservations(existingObservations, fallback);
   }
-  async resolveProvider() {
+  sanitizeIncomingMessages(messages) {
+    const sanitized = [];
+    for (const message of messages) {
+      const cleaned = this.sanitizeIncomingMessage(message);
+      if (cleaned) {
+        sanitized.push(cleaned);
+      }
+    }
+    return sanitized;
+  }
+  sanitizeIncomingMessage(message) {
+    const normalized = message.replace(/\s+/g, " ").trim();
+    if (!normalized) {
+      return "";
+    }
+    const sourceTagMatch = /^\[[^\]]+\]\s+/.exec(normalized);
+    const sourceTag = sourceTagMatch ? sourceTagMatch[0] : "";
+    const payload = sourceTag ? normalized.slice(sourceTag.length).trimStart() : normalized;
+    const roleMatch = ROLE_PREFIX_RE.exec(payload);
+    if (roleMatch && this.isConversationRolePrefix(roleMatch[1])) {
+      const role = this.normalizeMessageRole(roleMatch[1]);
+      if (this.shouldDropMessageRole(role)) {
+        return "";
+      }
+      const content = this.stripNoisyData(roleMatch[2]);
+      if (!content || this.isLikelyStructuredNoise(content)) {
+        return "";
+      }
+      const cleaned2 = `${role}: ${content}`;
+      return sourceTag ? `${sourceTag}${cleaned2}` : cleaned2;
+    }
+    const cleaned = this.stripNoisyData(payload);
+    if (!cleaned || this.isLikelyStructuredNoise(cleaned)) {
+      return "";
+    }
+    return sourceTag ? `${sourceTag}${cleaned}` : cleaned;
+  }
+  normalizeMessageRole(role) {
+    return role.trim().toLowerCase();
+  }
+  isConversationRolePrefix(role) {
+    const normalized = role.trim().toLowerCase().replace(/[\s_-]+/g, "");
+    if (!normalized) {
+      return false;
+    }
+    if (normalized === "user" || normalized === "assistant" || normalized === "system") {
+      return true;
+    }
+    if (normalized === "developer" || normalized === "metadata") {
+      return true;
+    }
+    return normalized.startsWith("tool");
+  }
+  shouldDropMessageRole(role) {
+    const normalized = role.replace(/[\s_-]+/g, "");
+    if (!normalized) {
+      return false;
+    }
+    if (normalized === "system" || normalized === "developer" || normalized === "metadata") {
+      return true;
+    }
+    return normalized.startsWith("tool");
+  }
+  stripNoisyData(value) {
+    return value.replace(BASE64_DATA_URI_RE, " ").replace(LONG_BASE64_TOKEN_RE, " ").replace(/\s+/g, " ").trim();
+  }
+  isLikelyStructuredNoise(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return true;
+    }
+    if (NOISE_PREFIX_RE.test(trimmed)) {
+      return true;
+    }
+    const afterToolResult = trimmed.match(/^tool[_-]?result\s*:\s*(\{.*|\[.*)/i);
+    if (afterToolResult && STRUCTURED_NOISE_MARKER_RE.test(trimmed) && trimmed.length >= 40) {
+      return true;
+    }
+    const looksStructured = trimmed.startsWith("{") || trimmed.startsWith("[");
+    if (looksStructured && STRUCTURED_NOISE_MARKER_RE.test(trimmed) && trimmed.length >= 40) {
+      return true;
+    }
+    return false;
+  }
+  resolveProvider() {
     if (process.env.CLAWVAULT_NO_LLM) return null;
     if (this.provider) {
       const configured = this.resolveConfiguredProvider(this.provider);
       if (configured) {
         return configured;
       }
-      return await this.resolveProviderFromEnv(false);
+      return this.resolveProviderFromEnv(false);
     }
-    return await this.resolveProviderFromEnv(true);
+    return this.resolveProviderFromEnv(true);
   }
   resolveConfiguredProvider(provider) {
     const model = this.resolveModel(provider);
@@ -133,6 +232,18 @@ var Compressor = class {
         baseUrl: this.resolveBaseUrl(provider)
       };
     }
+    if (provider === "xai") {
+      const apiKey2 = this.resolveApiKey(provider);
+      if (!apiKey2) {
+        return null;
+      }
+      return {
+        provider,
+        model,
+        apiKey: apiKey2,
+        baseUrl: XAI_BASE_URL
+      };
+    }
     const apiKey = this.resolveApiKey(provider) ?? void 0;
     return {
       provider,
@@ -141,21 +252,14 @@ var Compressor = class {
       baseUrl: this.resolveBaseUrl(provider)
     };
   }
-  async resolveProviderFromEnv(allowConfiguredModel) {
-    const anthropicModel = allowConfiguredModel ? this.resolveModel("anthropic") : DEFAULT_PROVIDER_MODELS.anthropic;
-    const oauthEnvToken = this.readEnvValue("ANTHROPIC_OAUTH_TOKEN");
-    if (oauthEnvToken) {
-      return { provider: "anthropic", model: anthropicModel, apiKey: oauthEnvToken, isOAuth: true };
-    }
+  resolveProviderFromEnv(allowConfiguredModel) {
     const anthropicApiKey = this.readEnvValue("ANTHROPIC_API_KEY");
     if (anthropicApiKey) {
-      return { provider: "anthropic", model: anthropicModel, apiKey: anthropicApiKey };
-    }
-    if (this.readEnvValue("CLAWVAULT_CLAUDE_AUTH")) {
-      const oauthToken = await resolveClaudeOAuthToken();
-      if (oauthToken) {
-        return { provider: "anthropic", model: anthropicModel, apiKey: oauthToken, isOAuth: true };
-      }
+      return {
+        provider: "anthropic",
+        model: allowConfiguredModel ? this.resolveModel("anthropic") : DEFAULT_PROVIDER_MODELS.anthropic,
+        apiKey: anthropicApiKey
+      };
     }
     const openAiApiKey = this.readEnvValue("OPENAI_API_KEY");
     if (openAiApiKey) {
@@ -174,6 +278,15 @@ var Compressor = class {
         apiKey: geminiApiKey
       };
     }
+    const xaiApiKey = this.readEnvValue("XAI_API_KEY");
+    if (xaiApiKey) {
+      return {
+        provider: "xai",
+        model: allowConfiguredModel ? this.resolveModel("xai") : DEFAULT_PROVIDER_MODELS.xai,
+        apiKey: xaiApiKey,
+        baseUrl: XAI_BASE_URL
+      };
+    }
     return null;
   }
   resolveModel(provider) {
@@ -194,6 +307,9 @@ var Compressor = class {
     if (provider === "gemini") {
       return this.readEnvValue("GEMINI_API_KEY");
     }
+    if (provider === "xai") {
+      return this.readEnvValue("XAI_API_KEY");
+    }
     return this.readEnvValue("OPENAI_API_KEY");
   }
   resolveBaseUrl(provider) {
@@ -225,17 +341,6 @@ var Compressor = class {
       "- Confidence c reflects extraction certainty, not importance.",
       "- Preserve source tags when present (e.g., [main], [telegram-dm], [discord], [telegram-group]).",
       "",
-      "PREFERENCE & PERSONAL CONTEXT EXTRACTION (critical for personalization):",
-      "- Emit [preference] for ANY personal detail that reveals tastes, habits, equipment, or context:",
-      '  * Explicit: "I prefer X", "I like Y", "I always use Z"',
-      '  * Ownership: "my Sony A7R IV", "I have a...", "I use...", "I own..."',
-      '  * Habits/routines: "I usually...", "every morning I...", "I tend to..."',
-      "  * Interests: topics the user is enthusiastic about, hobbies mentioned in passing",
-      "  * Constraints: dietary restrictions, allergies, phobias, limitations",
-      `  * Goals: "I'm trying to...", "I want to learn..."`,
-      "- These are HIGH VALUE observations (i >= 0.60) \u2014 they enable personalized responses.",
-      "- When in doubt between [preference] and [task], choose [preference] if it describes a lasting trait.",
-      "",
       "TASK EXTRACTION (required):",
       `- Emit [todo] for explicit TODO phrasing: "TODO:", "we need to", "don't forget", "remember to", "make sure to".`,
       `- Emit [task] for commitments/action intent: "I'll", "I will", "let me", "going to", "plan to", "should".`,
@@ -314,35 +419,19 @@ var Compressor = class {
     if (!backend.apiKey) {
       return "";
     }
-    const isOAuth = backend.isOAuth || backend.apiKey.includes("sk-ant-oat");
-    const headers = isOAuth ? {
-      "content-type": "application/json",
-      "authorization": `Bearer ${backend.apiKey}`,
-      "anthropic-version": "2023-06-01",
-      "anthropic-beta": "claude-code-20250219,oauth-2025-04-20",
-      "x-app": "cli",
-      "user-agent": "claude-cli/1.0.0 (external, cli)"
-    } : {
-      "content-type": "application/json",
-      "x-api-key": backend.apiKey,
-      "anthropic-version": "2023-06-01"
-    };
-    const body = isOAuth ? {
-      model: backend.model,
-      temperature: 0.1,
-      max_tokens: 1400,
-      system: [{ type: "text", text: "You are Claude Code, Anthropic's official CLI for Claude." }],
-      messages: [{ role: "user", content: prompt }]
-    } : {
-      model: backend.model,
-      temperature: 0.1,
-      max_tokens: 1400,
-      messages: [{ role: "user", content: prompt }]
-    };
     const response = await this.fetchImpl("https://api.anthropic.com/v1/messages", {
       method: "POST",
-      headers,
-      body: JSON.stringify(body)
+      headers: {
+        "content-type": "application/json",
+        "x-api-key": backend.apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model: backend.model,
+        temperature: 0.1,
+        max_tokens: 1400,
+        messages: [{ role: "user", content: prompt }]
+      })
     });
     if (!response.ok) {
       throw new Error(`Anthropic request failed (${response.status})`);
@@ -353,6 +442,9 @@ var Compressor = class {
   async callOpenAI(prompt, backend) {
     return this.callOpenAICompatible(prompt, backend);
   }
+  async callXAI(prompt, backend) {
+    return this.callOpenAICompatible(prompt, backend);
+  }
   async callOpenAICompatible(prompt, backend) {
     const baseUrl = backend.baseUrl ?? this.resolveBaseUrl(backend.provider);
     const response = await this.fetchImpl(this.buildOpenAICompatibleUrl(baseUrl), {
@@ -728,6 +820,125 @@ var Reflector = class {
   }
 };
 
+// src/lib/llm-adapter.ts
+var GEMINI_FLASH_MODEL = "gemini-2.0-flash";
+var OLLAMA_DEFAULT_MODEL = "llama3.1:8b";
+var OLLAMA_BASE_URL2 = "http://127.0.0.1:11434";
+function createGeminiFlashAdapter(options = {}) {
+  const apiKey = process.env.GEMINI_API_KEY;
+  return {
+    async call(prompt) {
+      if (!apiKey) {
+        return "";
+      }
+      return requestLlmCompletion({
+        prompt,
+        provider: "gemini",
+        model: options.model ?? GEMINI_FLASH_MODEL,
+        temperature: options.temperature ?? 0.1,
+        maxTokens: options.maxTokens ?? 2e3,
+        fetchImpl: options.fetchImpl
+      });
+    },
+    isAvailable() {
+      return Boolean(apiKey);
+    },
+    getProvider() {
+      return apiKey ? "gemini" : null;
+    }
+  };
+}
+function createOllamaAdapter(options = {}) {
+  let _available = null;
+  const fetchFn = options.fetchImpl ?? globalThis.fetch;
+  return {
+    async call(prompt) {
+      const resp = await fetchFn(`${OLLAMA_BASE_URL2}/api/generate`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          model: options.model ?? OLLAMA_DEFAULT_MODEL,
+          prompt,
+          stream: false,
+          options: {
+            temperature: options.temperature ?? 0.1,
+            num_predict: options.maxTokens ?? 2e3
+          }
+        })
+      });
+      if (!resp.ok) return "";
+      const data = await resp.json();
+      return data.response ?? "";
+    },
+    isAvailable() {
+      if (_available !== null) return _available;
+      _available = true;
+      return true;
+    },
+    getProvider() {
+      return null;
+    }
+  };
+}
+function createDefaultAdapter(options = {}) {
+  const resolvedProvider = options.provider !== void 0 ? options.provider : resolveLlmProvider();
+  return {
+    async call(prompt) {
+      if (!resolvedProvider) {
+        return "";
+      }
+      return requestLlmCompletion({
+        prompt,
+        provider: resolvedProvider,
+        model: options.model,
+        temperature: options.temperature ?? 0.1,
+        maxTokens: options.maxTokens ?? 2e3,
+        fetchImpl: options.fetchImpl
+      });
+    },
+    isAvailable() {
+      return resolvedProvider !== null;
+    },
+    getProvider() {
+      return resolvedProvider;
+    }
+  };
+}
+function createFactExtractionAdapter(options = {}) {
+  if (options.provider) {
+    return createDefaultAdapter(options);
+  }
+  const geminiAdapter = createGeminiFlashAdapter(options);
+  if (geminiAdapter.isAvailable()) {
+    return geminiAdapter;
+  }
+  const ollamaAdapter = createOllamaAdapter(options);
+  if (ollamaAdapter.isAvailable()) {
+    return ollamaAdapter;
+  }
+  return createDefaultAdapter(options);
+}
+function createLlmFunction(adapter) {
+  if (!adapter.isAvailable()) {
+    return void 0;
+  }
+  return (prompt) => adapter.call(prompt);
+}
+function resolveFactExtractionMode(configuredMode, adapter) {
+  const mode = configuredMode ?? "llm";
+  if (mode === "off") {
+    return { mode: "off", useLlm: false };
+  }
+  if (mode === "rule") {
+    return { mode: "rule", useLlm: false };
+  }
+  const llmAvailable = adapter?.isAvailable() ?? resolveLlmProvider() !== null;
+  if (mode === "llm" || mode === "hybrid") {
+    return { mode, useLlm: llmAvailable };
+  }
+  return { mode: "rule", useLlm: false };
+}
+
 // src/observer/observer.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
@@ -801,17 +1012,41 @@ var FUTURE_TASK_HINT_RE = /\b(need to|should|todo|must|plan to)\b/i;
 var Router = class {
   vaultPath;
   extractTasks;
+  extractFacts;
+  factExtractionMode;
+  llmAdapter;
+  factStore;
   now;
   customRoutes;
   constructor(vaultPath, options = {}) {
     this.vaultPath = path.resolve(vaultPath);
     this.extractTasks = options.extractTasks ?? true;
+    this.extractFacts = options.extractFacts ?? true;
+    this.factExtractionMode = options.factExtractionMode ?? this.loadFactExtractionMode();
+    this.llmAdapter = options.llmAdapter ?? createFactExtractionAdapter();
+    this.factStore = new FactStore(this.vaultPath);
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
     this.customRoutes = this.loadCustomRoutes();
+    if (this.extractFacts && this.factExtractionMode !== "off") {
+      this.factStore.load();
+    }
+  }
+  loadFactExtractionMode() {
+    try {
+      const config = listConfig(this.vaultPath);
+      const observer = config.observer;
+      const mode = observer?.factExtractionMode;
+      if (mode === "off" || mode === "rule" || mode === "llm" || mode === "hybrid") {
+        return mode;
+      }
+    } catch {
+    }
+    return "llm";
   }
   /**
    * Takes observation markdown and routes items to appropriate vault categories.
    * Routes only items with importance >= 0.4.
+   * Also extracts structured facts from observations when fact extraction is enabled.
    * Returns a summary of what was routed where.
    */
   route(observationMarkdown, context = {}) {
@@ -821,6 +1056,7 @@ var Router = class {
     const knownWorkItems = this.extractTasks ? this.loadExistingWorkItems() : [];
     const knownProjectDefinitions = this.loadKnownProjectDefinitions();
     let dedupHits = 0;
+    let factsExtracted = 0;
     for (const item of items) {
       if (item.importance < 0.4) continue;
       if (this.extractTasks && this.isTaskObservation(item.type)) {
@@ -847,8 +1083,81 @@ var Router = class {
       routed.push(routedItem);
       this.appendToCategory(category, routedItem, knownProjectDefinitions);
     }
-    const summary = this.buildSummary(routed, dedupHits);
-    return { routed, summary };
+    if (this.extractFacts && this.factExtractionMode !== "off") {
+      const extractedCount = this.extractAndStoreFacts(observationMarkdown, context);
+      factsExtracted = extractedCount;
+    }
+    const summary = this.buildSummary(routed, dedupHits, factsExtracted);
+    return { routed, summary, factsExtracted };
+  }
+  /**
+   * Extract facts from observation markdown and store them in the fact store.
+   * Uses the configured extraction mode (rule-based, LLM, or hybrid).
+   */
+  extractAndStoreFacts(observationMarkdown, context) {
+    const { mode, useLlm } = resolveFactExtractionMode(this.factExtractionMode, this.llmAdapter);
+    if (mode === "off") {
+      return 0;
+    }
+    const source = context.source ?? "observer";
+    const timestamp = context.timestamp?.toISOString() ?? this.now().toISOString();
+    let facts = [];
+    if (mode === "rule" || !useLlm) {
+      facts = extractFactsRuleBased(observationMarkdown, source, timestamp);
+    } else if (mode === "llm") {
+      const llmFn = createLlmFunction(this.llmAdapter);
+      extractFactsLlm(observationMarkdown, source, timestamp, llmFn).then((llmFacts) => {
+        if (llmFacts.length > 0) {
+          this.factStore.addFacts(llmFacts);
+          this.factStore.save();
+        }
+      }).catch(() => {
+        const ruleFacts = extractFactsRuleBased(observationMarkdown, source, timestamp);
+        if (ruleFacts.length > 0) {
+          this.factStore.addFacts(ruleFacts);
+          this.factStore.save();
+        }
+      });
+      return 0;
+    } else if (mode === "hybrid") {
+      facts = extractFactsRuleBased(observationMarkdown, source, timestamp);
+      const llmFn = createLlmFunction(this.llmAdapter);
+      extractFactsLlm(observationMarkdown, source, timestamp, llmFn).then((llmFacts) => {
+        const merged = this.mergeFacts(facts, llmFacts);
+        if (merged.length > facts.length) {
+          this.factStore.addFacts(merged.slice(facts.length));
+          this.factStore.save();
+        }
+      }).catch(() => {
+      });
+    }
+    if (facts.length > 0) {
+      this.factStore.addFacts(facts);
+      this.factStore.save();
+    }
+    return facts.length;
+  }
+  /**
+   * Merge facts from rule-based and LLM extraction, deduplicating by entity+relation.
+   */
+  mergeFacts(ruleFacts, llmFacts) {
+    const seen = /* @__PURE__ */ new Set();
+    const merged = [];
+    for (const fact of ruleFacts) {
+      const key = `${fact.entityNorm}::${fact.relation}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        merged.push(fact);
+      }
+    }
+    for (const fact of llmFacts) {
+      const key = `${fact.entityNorm}::${fact.relation}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        merged.push(fact);
+      }
+    }
+    return merged;
   }
   isTaskObservation(type) {
     return type === "task" || type === "todo" || type === "commitment-unresolved";
@@ -1436,8 +1745,8 @@ ${entry}
     for (const bg of setA) if (setB.has(bg)) intersection++;
     return intersection / (setA.size + setB.size - intersection);
   }
-  buildSummary(routed, dedupHits) {
-    if (routed.length === 0) {
+  buildSummary(routed, dedupHits, factsExtracted = 0) {
+    if (routed.length === 0 && factsExtracted === 0) {
       if (dedupHits > 0) {
         return `No items routed to vault categories (dedup hits: ${dedupHits}).`;
       }
@@ -1448,7 +1757,17 @@ ${entry}
       byCat.set(item.category, (byCat.get(item.category) ?? 0) + 1);
     }
     const parts = [...byCat.entries()].map(([cat, count]) => `${cat}: ${count}`);
-    const suffix = dedupHits > 0 ? ` (dedup hits: ${dedupHits})` : "";
+    const suffixParts = [];
+    if (dedupHits > 0) {
+      suffixParts.push(`dedup hits: ${dedupHits}`);
+    }
+    if (factsExtracted > 0) {
+      suffixParts.push(`facts: ${factsExtracted}`);
+    }
+    const suffix = suffixParts.length > 0 ? ` (${suffixParts.join(", ")})` : "";
+    if (routed.length === 0 && factsExtracted > 0) {
+      return `Extracted ${factsExtracted} facts${suffix}`;
+    }
     return `Routed ${routed.length} observations \u2192 ${parts.join(", ")}${suffix}`;
   }
 };
@@ -1698,5 +2017,10 @@ var Observer = class {
 export {
   Compressor,
   Reflector,
+  createGeminiFlashAdapter,
+  createDefaultAdapter,
+  createFactExtractionAdapter,
+  createLlmFunction,
+  resolveFactExtractionMode,
   Observer
 };