clawvault 2.6.1 → 2.6.4

package/dist/{chunk-Q2J5YTUF.js → chunk-OQGYFZ4A.js}

@@ -14,7 +14,11 @@ import {
   listConfig,
   listRouteRules,
   matchRouteRule
-} from "./chunk-ITPEXLHA.js";
+} from "./chunk-URXDAUVH.js";
+import {
+  requestLlmCompletion,
+  resolveLlmProvider
+} from "./chunk-YXQCA6B7.js";
 import {
   ensureLedgerStructure,
   ensureParentDir,
@@ -33,13 +37,17 @@ import {
 
 // 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-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;
@@ -72,7 +80,7 @@ var Compressor = class {
     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);
@@ -130,6 +138,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,
@@ -164,6 +184,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) {
@@ -184,6 +213,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) {
@@ -316,6 +348,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), {
@@ -691,13 +726,496 @@ var Reflector = class {
   }
 };
 
-// src/observer/observer.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+// src/lib/fact-extractor.ts
+function normalizeEntity(name) {
+  return name.toLowerCase().replace(/[^a-z0-9\s]/g, "").replace(/\s+/g, " ").trim();
+}
+function factId(entity, relation, value) {
+  const key = `${normalizeEntity(entity)}::${relation.toLowerCase()}::${value.toLowerCase().trim()}`;
+  let hash = 0;
+  for (let i = 0; i < key.length; i++) {
+    const char = key.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+var PREFERENCE_PATTERNS = [
+  {
+    // "I prefer X" / "I like X" / "I love X" / "I enjoy X"
+    pattern: /\b(?:i|user|they)\s+(?:prefer|like|love|enjoy|want|favor)s?\s+(.+?)(?:\.|,|$)/i,
+    extract: (m) => ({
+      entity: "user",
+      relation: "prefers",
+      value: m[1].trim(),
+      category: "preference"
+    })
+  },
+  {
+    // "my favorite X is Y"
+    pattern: /\bmy\s+(?:favorite|favourite|preferred)\s+(\w+)\s+(?:is|are)\s+(.+?)(?:\.|,|$)/i,
+    extract: (m) => ({
+      entity: "user",
+      relation: `favorite_${m[1].toLowerCase()}`,
+      value: m[2].trim(),
+      category: "preference"
+    })
+  },
+  {
+    // "I don't like X" / "I hate X" / "I dislike X"
+    pattern: /\b(?:i|user)\s+(?:don'?t\s+like|hate|dislike|avoid)s?\s+(.+?)(?:\.|,|$)/i,
+    extract: (m) => ({
+      entity: "user",
+      relation: "dislikes",
+      value: m[1].trim(),
+      category: "preference"
+    })
+  },
+  {
+    // "I'm allergic to X" / "I have an allergy to X"
+    pattern: /\b(?:i'?m|i\s+am|i\s+have)\s+(?:an?\s+)?allerg(?:ic|y)\s+(?:to\s+)?(.+?)(?:\.|,|$)/i,
+    extract: (m) => ({
+      entity: "user",
+      relation: "allergic_to",
+      value: m[1].trim(),
+      category: "preference"
+    })
+  }
+];
+var FACT_PATTERNS = [
+  {
+    // "X works at Y" / "X is employed at Y"
+    pattern: /\b(\w+(?:\s+\w+)?)\s+(?:works?\s+(?:at|for)|is\s+employed\s+(?:at|by))\s+(.+?)(?:\.|,|$)/i,
+    extract: (m) => ({
+      entity: m[1].trim(),
+      relation: "works_at",
+      value: m[2].trim(),
+      category: "fact"
+    })
+  },
+  {
+    // "X lives in Y" / "X moved to Y"
+    pattern: /\b(\w+(?:\s+\w+)?)\s+(?:live[sd]?\s+in|moved?\s+to|relocated?\s+to)\s+(.+?)(?:\.|,|$)/i,
+    extract: (m) => ({
+      entity: m[1].trim(),
+      relation: "lives_in",
+      value: m[2].trim(),
+      category: "fact"
+    })
+  },
+  {
+    // "X is Y years old" / "X's age is Y"
+    pattern: /\b(\w+(?:\s+\w+)?)\s+(?:is|turned)\s+(\d+)\s+years?\s+old/i,
+    extract: (m) => ({
+      entity: m[1].trim(),
+      relation: "age",
+      value: m[2],
+      category: "fact"
+    })
+  },
+  {
+    // "X bought Y" / "X purchased Y"
+    pattern: /\b(\w+(?:\s+\w+)?)\s+(?:bought|purchased|got|acquired)\s+(?:a\s+|an\s+|the\s+)?(.+?)(?:\s+for\s+\$?([\d,.]+))?(?:\.|,|$)/i,
+    extract: (m) => ({
+      entity: m[1].trim(),
+      relation: "bought",
+      value: m[3] ? `${m[2].trim()} ($${m[3]})` : m[2].trim(),
+      category: "event"
+    })
+  },
+  {
+    // "X spent $Y on Z"
+    pattern: /\b(\w+(?:\s+\w+)?)\s+spent\s+\$?([\d,.]+)\s+on\s+(.+?)(?:\.|,|$)/i,
+    extract: (m) => ({
+      entity: m[1].trim(),
+      relation: "spent_on",
+      value: `$${m[2]} on ${m[3].trim()}`,
+      category: "event"
+    })
+  }
+];
+var DECISION_PATTERNS = [
+  {
+    // "decided to X" / "we decided X"
+    pattern: /\b(?:i|we|user)\s+decided\s+(?:to\s+)?(.+?)(?:\.|,|$)/i,
+    extract: (m) => ({
+      entity: "user",
+      relation: "decided",
+      value: m[1].trim(),
+      category: "decision"
+    })
+  },
+  {
+    // "chose X over Y"
+    pattern: /\b(?:i|we|user)\s+chose\s+(.+?)\s+over\s+(.+?)(?:\.|,|$)/i,
+    extract: (m) => ({
+      entity: "user",
+      relation: "chose",
+      value: `${m[1].trim()} (over ${m[2].trim()})`,
+      category: "decision"
+    })
+  }
+];
+var ALL_PATTERNS = [...PREFERENCE_PATTERNS, ...FACT_PATTERNS, ...DECISION_PATTERNS];
+function extractFactsRuleBased(text, source, timestamp) {
+  const facts = [];
+  const now = timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  const sentences = text.split(/[.!?\n]+/).filter((s) => s.trim().length > 5);
+  for (const sentence of sentences) {
+    const trimmed = sentence.trim();
+    for (const rule of ALL_PATTERNS) {
+      const match = trimmed.match(rule.pattern);
+      if (match) {
+        const extracted = rule.extract(match);
+        if (extracted && extracted.value.length > 1 && extracted.value.length < 200) {
+          facts.push({
+            id: factId(extracted.entity, extracted.relation, extracted.value),
+            entity: extracted.entity,
+            entityNorm: normalizeEntity(extracted.entity),
+            relation: extracted.relation,
+            value: extracted.value,
+            validFrom: now,
+            validUntil: null,
+            confidence: 0.7,
+            // Rule-based gets moderate confidence
+            category: extracted.category,
+            source,
+            rawText: trimmed
+          });
+        }
+      }
+    }
+  }
+  return facts;
+}
+var EXTRACTION_PROMPT = `Extract structured facts from the following text. Return a JSON array of objects with these fields:
+- entity: the subject (person, place, thing, or "user" for the speaker)
+- relation: the relationship type (e.g., "prefers", "works_at", "lives_in", "bought", "spent_on", "age", "decided", "allergic_to")
+- value: the object of the relation
+- category: one of "preference", "fact", "decision", "entity", "event"
+- confidence: 0.0 to 1.0
 
-// src/observer/router.ts
+Rules:
+- Extract ALL facts, preferences, decisions, and events
+- For preferences, use "user" as entity
+- For monetary amounts, include the dollar sign
+- Be precise \u2014 only extract what's explicitly stated
+- Return empty array [] if no facts found
+
+Text:
+`;
+async function extractFactsLlm(text, source, timestamp, llmFn) {
+  if (!llmFn) {
+    return extractFactsRuleBased(text, source, timestamp);
+  }
+  const now = timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const response = await llmFn(EXTRACTION_PROMPT + text);
+    const jsonMatch = response.match(/\[[\s\S]*?\]/);
+    if (!jsonMatch) {
+      return extractFactsRuleBased(text, source, timestamp);
+    }
+    const parsed = JSON.parse(jsonMatch[0]);
+    return parsed.map((f) => ({
+      id: factId(f.entity, f.relation, f.value),
+      entity: f.entity,
+      entityNorm: normalizeEntity(f.entity),
+      relation: f.relation,
+      value: f.value,
+      validFrom: now,
+      validUntil: null,
+      confidence: Math.min(1, Math.max(0, f.confidence || 0.8)),
+      category: f.category || "fact",
+      source,
+      rawText: text.substring(0, 500)
+    }));
+  } catch {
+    return extractFactsRuleBased(text, source, timestamp);
+  }
+}
+
+// src/lib/fact-store.ts
 import * as fs from "fs";
 import * as path from "path";
+var FactStore = class {
+  facts = /* @__PURE__ */ new Map();
+  byEntity = /* @__PURE__ */ new Map();
+  byRelation = /* @__PURE__ */ new Map();
+  byCategory = /* @__PURE__ */ new Map();
+  factsPath;
+  dirty = false;
+  constructor(vaultPath) {
+    this.factsPath = path.join(vaultPath, ".clawvault", "facts.jsonl");
+  }
+  /** Load facts from disk */
+  load() {
+    this.facts.clear();
+    this.byEntity.clear();
+    this.byRelation.clear();
+    this.byCategory.clear();
+    if (!fs.existsSync(this.factsPath)) return;
+    const lines = fs.readFileSync(this.factsPath, "utf-8").split("\n").filter((l) => l.trim());
+    for (const line of lines) {
+      try {
+        const fact = JSON.parse(line);
+        this.indexFact(fact);
+      } catch {
+      }
+    }
+  }
+  /** Add facts with conflict resolution. Returns number of conflicts resolved. */
+  addFacts(newFacts) {
+    let conflicts = 0;
+    for (const fact of newFacts) {
+      const existing = this.findConflict(fact);
+      if (existing) {
+        existing.validUntil = fact.validFrom;
+        conflicts++;
+      }
+      this.indexFact(fact);
+      this.dirty = true;
+    }
+    return conflicts;
+  }
+  /** Find an existing fact that conflicts with the new one */
+  findConflict(newFact) {
+    const entityFacts = this.byEntity.get(newFact.entityNorm);
+    if (!entityFacts) return null;
+    for (const id of entityFacts) {
+      const existing = this.facts.get(id);
+      if (!existing || existing.validUntil) continue;
+      if (existing.relation === newFact.relation) {
+        if (this.isSimilarValue(existing.value, newFact.value)) {
+          return existing;
+        }
+        if (this.isExclusiveRelation(newFact.relation)) {
+          return existing;
+        }
+      }
+    }
+    return null;
+  }
+  /** Check if two values are similar enough to be considered the same fact */
+  isSimilarValue(a, b) {
+    const na = a.toLowerCase().trim();
+    const nb = b.toLowerCase().trim();
+    if (na === nb) return true;
+    if (na.includes(nb) || nb.includes(na)) return true;
+    return false;
+  }
+  /** Relations where only one value can be active at a time */
+  isExclusiveRelation(relation) {
+    const exclusive = /* @__PURE__ */ new Set([
+      "lives_in",
+      "works_at",
+      "age",
+      "favorite_color",
+      "favorite_food",
+      "favorite_restaurant",
+      "favorite_movie",
+      "favorite_book",
+      "favorite_music",
+      "favorite_sport",
+      "job_title",
+      "employer",
+      "marital_status",
+      "city",
+      "country"
+    ]);
+    return exclusive.has(relation);
+  }
+  /** Index a fact in all lookup maps */
+  indexFact(fact) {
+    this.facts.set(fact.id, fact);
+    if (!this.byEntity.has(fact.entityNorm)) {
+      this.byEntity.set(fact.entityNorm, /* @__PURE__ */ new Set());
+    }
+    this.byEntity.get(fact.entityNorm).add(fact.id);
+    if (!this.byRelation.has(fact.relation)) {
+      this.byRelation.set(fact.relation, /* @__PURE__ */ new Set());
+    }
+    this.byRelation.get(fact.relation).add(fact.id);
+    if (!this.byCategory.has(fact.category)) {
+      this.byCategory.set(fact.category, /* @__PURE__ */ new Set());
+    }
+    this.byCategory.get(fact.category).add(fact.id);
+  }
+  /** Save facts to disk (full rewrite for consistency) */
+  save() {
+    if (!this.dirty && fs.existsSync(this.factsPath)) return;
+    const dir = path.dirname(this.factsPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const lines = Array.from(this.facts.values()).map((f) => JSON.stringify(f)).join("\n");
+    fs.writeFileSync(this.factsPath, lines + "\n", "utf-8");
+    this.dirty = false;
+  }
+  /** Append new facts to disk (faster than full rewrite) */
+  append(facts) {
+    const dir = path.dirname(this.factsPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const lines = facts.map((f) => JSON.stringify(f)).join("\n");
+    fs.appendFileSync(this.factsPath, lines + "\n", "utf-8");
+  }
+  // ─── Query methods ──────────────────────────────────────────────────────
+  /** Get all active facts for an entity */
+  getEntityFacts(entity) {
+    const norm = normalizeEntity(entity);
+    const ids = this.byEntity.get(norm);
+    if (!ids) return [];
+    return Array.from(ids).map((id) => this.facts.get(id)).filter((f) => f && !f.validUntil);
+  }
+  /** Get all active facts for a relation */
+  getRelationFacts(relation) {
+    const ids = this.byRelation.get(relation);
+    if (!ids) return [];
+    return Array.from(ids).map((id) => this.facts.get(id)).filter((f) => f && !f.validUntil);
+  }
+  /** Get all active facts in a category */
+  getCategoryFacts(category) {
+    const ids = this.byCategory.get(category);
+    if (!ids) return [];
+    return Array.from(ids).map((id) => this.facts.get(id)).filter((f) => f && !f.validUntil);
+  }
+  /** Get all active preferences */
+  getPreferences() {
+    return this.getCategoryFacts("preference");
+  }
+  /** Search facts by text query (simple keyword match) */
+  searchFacts(query) {
+    const terms = query.toLowerCase().split(/\s+/);
+    const results = [];
+    for (const fact of this.facts.values()) {
+      if (fact.validUntil) continue;
+      const text = `${fact.entity} ${fact.relation} ${fact.value} ${fact.rawText}`.toLowerCase();
+      const matches = terms.filter((t) => text.includes(t)).length;
+      if (matches >= Math.ceil(terms.length * 0.5)) {
+        results.push(fact);
+      }
+    }
+    return results;
+  }
+  /** Get facts valid at a specific time */
+  getFactsAt(timestamp) {
+    const t = new Date(timestamp).getTime();
+    const results = [];
+    for (const fact of this.facts.values()) {
+      const from = new Date(fact.validFrom).getTime();
+      const until = fact.validUntil ? new Date(fact.validUntil).getTime() : Infinity;
+      if (t >= from && t < until) {
+        results.push(fact);
+      }
+    }
+    return results;
+  }
+  /** Get stats */
+  stats() {
+    const active = Array.from(this.facts.values()).filter((f) => !f.validUntil);
+    return {
+      totalFacts: this.facts.size,
+      activeFacts: active.length,
+      supersededFacts: this.facts.size - active.length,
+      entities: this.byEntity.size,
+      relations: this.byRelation.size
+    };
+  }
+  /** Get all facts (for testing/debugging) */
+  getAllFacts() {
+    return Array.from(this.facts.values());
+  }
+};
+
+// src/lib/llm-adapter.ts
+var GEMINI_FLASH_MODEL = "gemini-2.0-flash";
+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 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;
+  }
+  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 fs3 from "fs";
+import * as path3 from "path";
+
+// src/observer/router.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
 var CATEGORY_PATTERNS = [
   {
     category: "decisions",
@@ -764,17 +1282,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.vaultPath = path2.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 = {}) {
@@ -784,6 +1326,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)) {
@@ -810,8 +1353,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";
@@ -1153,46 +1769,46 @@ var Router = class {
   resolveFilePath(category, item, knownProjectDefinitions) {
     const customEntityPath = this.resolveCustomEntityPath(item.content, category);
     if (customEntityPath) {
-      const customEntityDir = path.join(this.vaultPath, category, customEntityPath);
-      fs.mkdirSync(customEntityDir, { recursive: true });
+      const customEntityDir = path2.join(this.vaultPath, category, customEntityPath);
+      fs2.mkdirSync(customEntityDir, { recursive: true });
       return {
-        filePath: path.join(customEntityDir, `${item.date}.md`),
+        filePath: path2.join(customEntityDir, `${item.date}.md`),
         headerLabel: `${category}/${customEntityPath}`
       };
     }
     if (category === "projects") {
       const matchedProjectSlug = this.matchKnownProjectSlug(item.content, knownProjectDefinitions);
       if (matchedProjectSlug) {
-        const projectDir = path.join(this.vaultPath, category, matchedProjectSlug);
-        fs.mkdirSync(projectDir, { recursive: true });
+        const projectDir = path2.join(this.vaultPath, category, matchedProjectSlug);
+        fs2.mkdirSync(projectDir, { recursive: true });
         return {
-          filePath: path.join(projectDir, `${item.date}.md`),
+          filePath: path2.join(projectDir, `${item.date}.md`),
           headerLabel: `${category}/${matchedProjectSlug}`
         };
       }
     } else {
       const entitySlug = this.extractEntitySlug(item.content, category);
       if (entitySlug) {
-        const entityDir = path.join(this.vaultPath, category, entitySlug);
-        fs.mkdirSync(entityDir, { recursive: true });
+        const entityDir = path2.join(this.vaultPath, category, entitySlug);
+        fs2.mkdirSync(entityDir, { recursive: true });
         return {
-          filePath: path.join(entityDir, `${item.date}.md`),
+          filePath: path2.join(entityDir, `${item.date}.md`),
           headerLabel: `${category}/${entitySlug}`
         };
       }
     }
-    const categoryDir = path.join(this.vaultPath, category);
-    fs.mkdirSync(categoryDir, { recursive: true });
+    const categoryDir = path2.join(this.vaultPath, category);
+    fs2.mkdirSync(categoryDir, { recursive: true });
     return {
-      filePath: path.join(categoryDir, `${item.date}.md`),
+      filePath: path2.join(categoryDir, `${item.date}.md`),
       headerLabel: category
     };
   }
   appendToCategory(category, item, knownProjectDefinitions) {
     const destination = this.resolveFilePath(category, item, knownProjectDefinitions);
     const filePath = destination.filePath;
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf-8").trim() : "";
+    fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+    const existing = fs2.existsSync(filePath) ? fs2.readFileSync(filePath, "utf-8").trim() : "";
     const normalizedNew = this.normalizeForDedup(item.content);
     const existingLines = existing.split(/\r?\n/);
     for (const line of existingLines) {
@@ -1226,7 +1842,7 @@ ${entry}
 ` : `${header}
 ${entry}
 `;
-    fs.writeFileSync(filePath, newContent, "utf-8");
+    fs2.writeFileSync(filePath, newContent, "utf-8");
   }
   /**
    * Auto-link proper nouns and known entities with [[wiki-links]].
@@ -1399,8 +2015,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}).`;
       }
@@ -1411,7 +2027,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}`;
   }
 };
@@ -1479,7 +2105,7 @@ var Observer = class {
   observationsCache = "";
   lastRoutingSummary = "";
   constructor(vaultPath, options = {}) {
-    this.vaultPath = path2.resolve(vaultPath);
+    this.vaultPath = path3.resolve(vaultPath);
     this.tokenThreshold = options.tokenThreshold ?? 3e4;
     this.reflectThreshold = options.reflectThreshold ?? 4e4;
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
@@ -1583,14 +2209,14 @@ var Observer = class {
     return this.readObservationFile(getLegacyObservationPath(this.vaultPath, toDateKey(date)));
   }
   readObservationFile(filePath) {
-    if (!fs2.existsSync(filePath)) {
+    if (!fs3.existsSync(filePath)) {
       return "";
     }
-    return fs2.readFileSync(filePath, "utf-8").trim();
+    return fs3.readFileSync(filePath, "utf-8").trim();
   }
   writeObservationFile(filePath, content) {
     ensureParentDir(filePath);
-    fs2.writeFileSync(filePath, `${content.trim()}
+    fs3.writeFileSync(filePath, `${content.trim()}
 `, "utf-8");
   }
   deduplicateObservationMarkdown(markdown) {
@@ -1638,7 +2264,7 @@ var Observer = class {
       transcriptId: options.transcriptId ?? null,
       message
     }));
-    fs2.appendFileSync(rawPath, `${records.join("\n")}
+    fs3.appendFileSync(rawPath, `${records.join("\n")}
 `, "utf-8");
   }
   sanitizeSource(source) {
@@ -1661,5 +2287,15 @@ var Observer = class {
 export {
   Compressor,
   Reflector,
+  normalizeEntity,
+  factId,
+  extractFactsRuleBased,
+  extractFactsLlm,
+  FactStore,
+  createGeminiFlashAdapter,
+  createDefaultAdapter,
+  createFactExtractionAdapter,
+  createLlmFunction,
+  resolveFactExtractionMode,
   Observer
 };