clawvault 2.6.3 → 2.6.5

package/dist/{chunk-P5EPF6MB.js → chunk-MW5C6ZQA.js}

@@ -4,12 +4,100 @@ import * as path from "path";
 var JSONL_SAMPLE_LIMIT = 20;
 var MARKDOWN_SIGNAL_RE = /^(#{1,6}\s|[-*+]\s|>\s)/;
 var MARKDOWN_INLINE_RE = /(\[[^\]]+\]\([^)]+\)|[*_`~])/;
+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 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 NOISY_PREFIX_RE = /^(?:metadata|system metadata|session metadata)\s*:/i;
+function normalizeToken(value) {
+  return value.trim().toLowerCase().replace(/[\s_-]+/g, "");
+}
 function normalizeText(value) {
   return value.replace(/\s+/g, " ").trim();
 }
+function shouldDropRole(role) {
+  const normalized = normalizeToken(role);
+  if (!normalized) {
+    return false;
+  }
+  if (normalized === "system" || normalized === "developer" || normalized === "metadata") {
+    return true;
+  }
+  return normalized.startsWith("tool");
+}
+function isConversationRolePrefix(role) {
+  const normalized = normalizeToken(role);
+  if (!normalized) {
+    return false;
+  }
+  if (normalized === "user" || normalized === "assistant" || normalized === "system") {
+    return true;
+  }
+  if (normalized === "developer" || normalized === "metadata") {
+    return true;
+  }
+  return normalized.startsWith("tool");
+}
+function isNoisyBlockType(value) {
+  if (typeof value !== "string") {
+    return false;
+  }
+  const normalized = normalizeToken(value);
+  if (!normalized || normalized === "text" || normalized === "markdown") {
+    return false;
+  }
+  return normalized.includes("tool") || normalized.includes("functioncall") || normalized.includes("functionresult") || normalized.includes("thinking") || normalized.includes("reason") || normalized.includes("metadata");
+}
+function stripNoisyData(value) {
+  return normalizeText(
+    value.replace(BASE64_DATA_URI_RE, " ").replace(LONG_BASE64_TOKEN_RE, " ")
+  );
+}
+function isLikelyStructuredNoise(value) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return true;
+  }
+  if (NOISY_PREFIX_RE.test(trimmed)) {
+    return true;
+  }
+  const looksStructured = trimmed.startsWith("{") || trimmed.startsWith("[");
+  if (looksStructured && STRUCTURED_NOISE_MARKER_RE.test(trimmed) && trimmed.length >= 40) {
+    return true;
+  }
+  return false;
+}
+function sanitizeExtractedText(value) {
+  const stripped = stripNoisyData(value);
+  if (!stripped) {
+    return "";
+  }
+  if (isLikelyStructuredNoise(stripped)) {
+    return "";
+  }
+  return stripped;
+}
+function sanitizeParsedMessage(message) {
+  const normalized = normalizeText(message);
+  if (!normalized) {
+    return "";
+  }
+  const roleMatch = /^([a-z][a-z0-9_-]{1,31})\s*:\s*(.+)$/i.exec(normalized);
+  if (roleMatch && isConversationRolePrefix(roleMatch[1])) {
+    const role = normalizeRole(roleMatch[1]);
+    if (shouldDropRole(role)) {
+      return "";
+    }
+    const content = sanitizeExtractedText(roleMatch[2]);
+    if (!content) {
+      return "";
+    }
+    return role ? `${role}: ${content}` : content;
+  }
+  return sanitizeExtractedText(normalized);
+}
 function extractText(value) {
   if (typeof value === "string") {
-    return normalizeText(value);
+    return sanitizeExtractedText(value);
   }
   if (Array.isArray(value)) {
     const parts = [];
@@ -25,11 +113,17 @@ function extractText(value) {
     return "";
   }
   const record = value;
+  if (isNoisyBlockType(record.type)) {
+    return "";
+  }
   if (typeof record.text === "string") {
-    return normalizeText(record.text);
+    return sanitizeExtractedText(record.text);
   }
   if (typeof record.content === "string") {
-    return normalizeText(record.content);
+    return sanitizeExtractedText(record.content);
+  }
+  if (record.content !== void 0) {
+    return extractText(record.content);
   }
   return "";
 }
@@ -69,16 +163,18 @@ function parseJsonLine(line) {
   const entry = parsed;
   if ("role" in entry && "content" in entry) {
     const role = normalizeRole(entry.role);
+    if (shouldDropRole(role)) return "";
     const content = extractText(entry.content);
     if (!content) return "";
-    return role ? `${role}: ${content}` : content;
+    return sanitizeParsedMessage(role ? `${role}: ${content}` : content);
   }
   if (entry.type === "message" && entry.message && typeof entry.message === "object") {
     const message = entry.message;
     const role = normalizeRole(message.role);
+    if (shouldDropRole(role)) return "";
     const content = extractText(message.content);
     if (!content) return "";
-    return role ? `${role}: ${content}` : content;
+    return sanitizeParsedMessage(role ? `${role}: ${content}` : content);
   }
   return "";
 }
@@ -119,17 +215,21 @@ function parseMarkdown(raw) {
     if (roleMatch) {
       const role = normalizeRole(roleMatch[1]);
       const content = normalizeText(roleMatch[2]);
-      if (content) {
-        messages.push(`${role}: ${content}`);
+      const parsed2 = sanitizeParsedMessage(`${role}: ${content}`);
+      if (parsed2) {
+        messages.push(parsed2);
       }
       continue;
     }
-    messages.push(joined);
+    const parsed = sanitizeParsedMessage(joined);
+    if (parsed) {
+      messages.push(parsed);
+    }
   }
   return messages;
 }
 function parsePlainText(raw) {
-  return raw.split(/\r?\n/).map((line) => normalizeText(line)).filter(Boolean);
+  return raw.split(/\r?\n/).map((line) => sanitizeParsedMessage(line)).filter(Boolean);
 }
 function detectSessionFormat(raw, filePath) {
   const nonEmptyLines = raw.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
@@ -163,10 +263,7 @@ function parseSessionFile(filePath) {
   const raw = fs.readFileSync(resolved, "utf-8");
   const format = detectSessionFormat(raw, resolved);
   if (format === "jsonl") {
-    const parsed = parseJsonLines(raw);
-    if (parsed.length > 0) {
-      return parsed;
-    }
+    return parseJsonLines(raw);
   }
   if (format === "markdown") {
     const parsed = parseMarkdown(raw);

package/dist/{chunk-OZ7RIXTO.js → chunk-QSRRMEYM.js}

@@ -1,10 +1,10 @@
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 import {
   buildOrUpdateMemoryGraphIndex,
   loadMemoryGraphIndex
-} from "./chunk-ZZA73MFY.js";
+} from "./chunk-33DOSHTA.js";
 
 // src/commands/graph.ts
 function formatGraphSummary(summary) {

package/dist/chunk-RHISK3SZ.js

@@ -0,0 +1,189 @@
+import {
+  create,
+  read,
+  update
+} from "./chunk-L4HSSQ6T.js";
+import {
+  THREAD_STATUS_TRANSITIONS
+} from "./chunk-WMGIIABP.js";
+import {
+  append,
+  currentOwner
+} from "./chunk-4BQTQMJP.js";
+import {
+  __export
+} from "./chunk-2ZDO52B4.js";
+
+// src/workgraph/thread.ts
+var thread_exports = {};
+__export(thread_exports, {
+  block: () => block,
+  cancel: () => cancel,
+  claim: () => claim,
+  createThread: () => createThread,
+  decompose: () => decompose,
+  done: () => done,
+  release: () => release,
+  unblock: () => unblock
+});
+function createThread(vaultPath, title, goal, actor, opts = {}) {
+  return create(vaultPath, "thread", {
+    title,
+    goal,
+    status: "open",
+    priority: opts.priority ?? "medium",
+    deps: opts.deps ?? [],
+    parent: opts.parent,
+    context_refs: opts.context_refs ?? [],
+    tags: opts.tags ?? []
+  }, `## Goal
+
+${goal}
+`, actor);
+}
+function claim(vaultPath, threadPath, actor) {
+  const thread = read(vaultPath, threadPath);
+  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
+  const status = thread.fields.status;
+  if (status !== "open") {
+    throw new Error(`Cannot claim thread in "${status}" state. Only "open" threads can be claimed.`);
+  }
+  const owner = currentOwner(vaultPath, threadPath);
+  if (owner) {
+    throw new Error(`Thread already claimed by "${owner}". Wait for release or use a different thread.`);
+  }
+  append(vaultPath, actor, "claim", threadPath, "thread");
+  return update(vaultPath, threadPath, {
+    status: "active",
+    owner: actor
+  }, void 0, actor);
+}
+function release(vaultPath, threadPath, actor, reason) {
+  const thread = read(vaultPath, threadPath);
+  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
+  assertOwner(vaultPath, threadPath, actor);
+  append(
+    vaultPath,
+    actor,
+    "release",
+    threadPath,
+    "thread",
+    reason ? { reason } : void 0
+  );
+  return update(vaultPath, threadPath, {
+    status: "open",
+    owner: null
+  }, void 0, actor);
+}
+function block(vaultPath, threadPath, actor, blockedBy, reason) {
+  const thread = read(vaultPath, threadPath);
+  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
+  assertTransition(thread.fields.status, "blocked");
+  append(vaultPath, actor, "block", threadPath, "thread", {
+    blocked_by: blockedBy,
+    ...reason ? { reason } : {}
+  });
+  const currentDeps = thread.fields.deps ?? [];
+  const updatedDeps = currentDeps.includes(blockedBy) ? currentDeps : [...currentDeps, blockedBy];
+  return update(vaultPath, threadPath, {
+    status: "blocked",
+    deps: updatedDeps
+  }, void 0, actor);
+}
+function unblock(vaultPath, threadPath, actor) {
+  const thread = read(vaultPath, threadPath);
+  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
+  assertTransition(thread.fields.status, "active");
+  append(vaultPath, actor, "unblock", threadPath, "thread");
+  return update(vaultPath, threadPath, {
+    status: "active"
+  }, void 0, actor);
+}
+function done(vaultPath, threadPath, actor, output) {
+  const thread = read(vaultPath, threadPath);
+  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
+  assertTransition(thread.fields.status, "done");
+  assertOwner(vaultPath, threadPath, actor);
+  append(
+    vaultPath,
+    actor,
+    "done",
+    threadPath,
+    "thread",
+    output ? { output } : void 0
+  );
+  const newBody = output ? `${thread.body}
+
+## Output
+
+${output}
+` : thread.body;
+  return update(vaultPath, threadPath, {
+    status: "done"
+  }, newBody, actor);
+}
+function cancel(vaultPath, threadPath, actor, reason) {
+  const thread = read(vaultPath, threadPath);
+  if (!thread) throw new Error(`Thread not found: ${threadPath}`);
+  assertTransition(thread.fields.status, "cancelled");
+  append(
+    vaultPath,
+    actor,
+    "cancel",
+    threadPath,
+    "thread",
+    reason ? { reason } : void 0
+  );
+  return update(vaultPath, threadPath, {
+    status: "cancelled",
+    owner: null
+  }, void 0, actor);
+}
+function decompose(vaultPath, parentPath, subthreads, actor) {
+  const parent = read(vaultPath, parentPath);
+  if (!parent) throw new Error(`Thread not found: ${parentPath}`);
+  const created = [];
+  for (const sub of subthreads) {
+    const inst = createThread(vaultPath, sub.title, sub.goal, actor, {
+      parent: parentPath,
+      deps: sub.deps
+    });
+    created.push(inst);
+  }
+  const childRefs = created.map((c) => `[[${c.path}]]`);
+  const decomposeNote = `
+
+## Sub-threads
+
+${childRefs.map((r) => `- ${r}`).join("\n")}
+`;
+  update(vaultPath, parentPath, {}, parent.body + decomposeNote, actor);
+  append(vaultPath, actor, "decompose", parentPath, "thread", {
+    children: created.map((c) => c.path)
+  });
+  return created;
+}
+function assertTransition(from, to) {
+  const allowed = THREAD_STATUS_TRANSITIONS[from];
+  if (!allowed?.includes(to)) {
+    throw new Error(`Invalid transition: "${from}" \u2192 "${to}". Allowed: ${allowed?.join(", ") ?? "none"}`);
+  }
+}
+function assertOwner(vaultPath, threadPath, actor) {
+  const owner = currentOwner(vaultPath, threadPath);
+  if (owner && owner !== actor) {
+    throw new Error(`Thread is owned by "${owner}", not "${actor}". Only the owner can perform this action.`);
+  }
+}
+
+export {
+  createThread,
+  claim,
+  release,
+  block,
+  unblock,
+  done,
+  cancel,
+  decompose,
+  thread_exports
+};

package/dist/{chunk-3BTHWPMB.js → chunk-S5OJEGFG.js}

@@ -1,9 +1,9 @@
 import {
   runReflection
-} from "./chunk-T76H47ZS.js";
+} from "./chunk-MNPUYCHQ.js";
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 
 // src/commands/reflect.ts
 function parsePositiveInteger(raw, label) {

package/dist/{chunk-MGDEINGP.js → chunk-SS4B7P7V.js}

@@ -1,6 +1,6 @@
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 
 // src/commands/sync-bd.ts
 import * as fs from "fs";

package/dist/{chunk-ME37YNW3.js → chunk-SV7T4HRE.js}

@@ -1,15 +1,15 @@
 import {
   parseSessionFile
-} from "./chunk-P5EPF6MB.js";
+} from "./chunk-MW5C6ZQA.js";
 import {
   observeActiveSessions
-} from "./chunk-IEVLHNLU.js";
+} from "./chunk-T3FKSZSN.js";
 import {
   Observer
-} from "./chunk-Q2J5YTUF.js";
+} from "./chunk-FUSLEY6L.js";
 import {
   resolveVaultPath
-} from "./chunk-MXSSG3QU.js";
+} from "./chunk-GNJL4YGR.js";
 import {
   getObservationPath
 } from "./chunk-Z2XBWN7A.js";

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

@@ -1,9 +1,9 @@
+import {
+  Observer
+} from "./chunk-FUSLEY6L.js";
 import {
   getSessionsDir
 } from "./chunk-HRLWZGMA.js";
-import {
-  Observer
-} from "./chunk-Q2J5YTUF.js";
 
 // src/observer/active-session-observer.ts
 import * as fs from "fs";

package/dist/{chunk-DTEHFAL7.js → chunk-TS6NDVOU.js}

@@ -1,12 +1,12 @@
 import {
   ClawVault
-} from "./chunk-RCBMXTWS.js";
+} from "./chunk-YD7SVXTF.js";
 import {
   parseObservationMarkdown
 } from "./chunk-FHFUXL6G.js";
 import {
   getMemoryGraph
-} from "./chunk-ZZA73MFY.js";
+} from "./chunk-33DOSHTA.js";
 import {
   listObservationFiles
 } from "./chunk-Z2XBWN7A.js";

package/dist/chunk-U4O6C46S.js

@@ -0,0 +1,154 @@
+// src/lib/hybrid-search.ts
+import * as fs from "fs";
+import * as path from "path";
+var embeddingPipeline = null;
+var pipelineLoading = null;
+async function getEmbeddingPipeline() {
+  if (embeddingPipeline) return embeddingPipeline;
+  if (pipelineLoading) return pipelineLoading;
+  pipelineLoading = (async () => {
+    const { pipeline } = await import("./transformers.node-A2ZRORSQ.js");
+    embeddingPipeline = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2", {
+      dtype: "fp32"
+    });
+    return embeddingPipeline;
+  })();
+  return pipelineLoading;
+}
+async function embed(text) {
+  const pipe = await getEmbeddingPipeline();
+  const result = await pipe(text, { pooling: "mean", normalize: true });
+  return new Float32Array(result.data);
+}
+async function embedBatch(texts) {
+  const pipe = await getEmbeddingPipeline();
+  const results = [];
+  const batchSize = 32;
+  for (let i = 0; i < texts.length; i += batchSize) {
+    const batch = texts.slice(i, i + batchSize);
+    for (const text of batch) {
+      const result = await pipe(text, { pooling: "mean", normalize: true });
+      results.push(new Float32Array(result.data));
+    }
+  }
+  return results;
+}
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+  }
+  return dot;
+}
+var EmbeddingCache = class {
+  cachePath;
+  cache = /* @__PURE__ */ new Map();
+  dirty = false;
+  constructor(vaultPath) {
+    this.cachePath = path.join(vaultPath, ".clawvault", "embeddings.bin");
+  }
+  /**
+   * Load cache from disk
+   */
+  load() {
+    try {
+      if (!fs.existsSync(this.cachePath)) return;
+      const data = JSON.parse(fs.readFileSync(this.cachePath + ".json", "utf-8"));
+      for (const [key, arr] of Object.entries(data)) {
+        this.cache.set(key, new Float32Array(arr));
+      }
+    } catch {
+    }
+  }
+  /**
+   * Save cache to disk
+   */
+  save() {
+    if (!this.dirty) return;
+    const dir = path.dirname(this.cachePath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const data = {};
+    for (const [key, arr] of this.cache.entries()) {
+      data[key] = Array.from(arr);
+    }
+    fs.writeFileSync(this.cachePath + ".json", JSON.stringify(data));
+    this.dirty = false;
+  }
+  get(key) {
+    return this.cache.get(key);
+  }
+  set(key, embedding) {
+    this.cache.set(key, embedding);
+    this.dirty = true;
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  entries() {
+    return this.cache.entries();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+function reciprocalRankFusion(list1, list2, k = 60) {
+  const scores = /* @__PURE__ */ new Map();
+  for (let rank = 0; rank < list1.length; rank++) {
+    const { id } = list1[rank];
+    scores.set(id, (scores.get(id) || 0) + 1 / (k + rank + 1));
+  }
+  for (let rank = 0; rank < list2.length; rank++) {
+    const { id } = list2[rank];
+    scores.set(id, (scores.get(id) || 0) + 1 / (k + rank + 1));
+  }
+  return Array.from(scores.entries()).map(([id, score]) => ({ id, score })).sort((a, b) => b.score - a.score);
+}
+async function semanticSearch(query, cache, topK = 20) {
+  const queryEmb = await embed(query);
+  const results = [];
+  for (const [id, docEmb] of cache.entries()) {
+    results.push({ id, score: cosineSimilarity(queryEmb, docEmb) });
+  }
+  results.sort((a, b) => b.score - a.score);
+  return results.slice(0, topK);
+}
+async function hybridSearch(query, bm25Results, cache, options = {}) {
+  const { topK = 20, rrfK = 60 } = options;
+  const bm25Ranked = bm25Results.map((r) => ({ id: r.document.path || r.document.id, score: r.score }));
+  const semanticRanked = await semanticSearch(query, cache, topK);
+  const fused = reciprocalRankFusion(bm25Ranked, semanticRanked, rrfK);
+  const bm25Map = new Map(bm25Results.map((r) => [r.document.path || r.document.id, r]));
+  return fused.slice(0, topK).map(({ id, score }) => {
+    const existing = bm25Map.get(id);
+    if (existing) {
+      return { ...existing, score };
+    }
+    const minimalDoc = {
+      id: id.replace(/\.md$/, ""),
+      path: id.endsWith(".md") ? id : id + ".md",
+      title: (id.split("/").pop() || id).replace(/\.md$/, ""),
+      content: "",
+      category: id.split("/")[0] || "root",
+      frontmatter: {},
+      links: [],
+      tags: [],
+      modified: /* @__PURE__ */ new Date()
+    };
+    return {
+      document: minimalDoc,
+      score,
+      snippet: "",
+      matchedTerms: []
+    };
+  });
+}
+
+export {
+  embed,
+  embedBatch,
+  cosineSimilarity,
+  EmbeddingCache,
+  reciprocalRankFusion,
+  semanticSearch,
+  hybridSearch
+};

package/dist/{chunk-ITPEXLHA.js → chunk-URXDAUVH.js}

@@ -6,16 +6,21 @@ import {
 import * as fs from "fs";
 import * as path from "path";
 var CONFIG_FILE = ".clawvault.json";
-var OBSERVE_PROVIDERS = ["anthropic", "openai", "gemini"];
+var OBSERVE_PROVIDERS = ["anthropic", "openai", "gemini", "xai", "openclaw"];
 var OBSERVER_COMPRESSION_PROVIDERS = [
   "anthropic",
   "openai",
   "gemini",
+  "xai",
   "openai-compatible",
-  "ollama"
+  "ollama",
+  "openclaw",
+  "minimax",
+  "zai"
 ];
 var THEMES = ["neural", "minimal", "none"];
 var CONTEXT_PROFILES = ["default", "planning", "incident", "handoff", "auto"];
+var FACT_EXTRACTION_MODES = ["off", "rule", "llm", "hybrid"];
 var SUPPORTED_CONFIG_KEYS = [
   "name",
   "categories",
@@ -26,6 +31,7 @@ var SUPPORTED_CONFIG_KEYS = [
   "observer.compression.model",
   "observer.compression.baseUrl",
   "observer.compression.apiKey",
+  "observer.factExtractionMode",
   "context.maxResults",
   "context.defaultProfile",
   "graph.maxHops",
@@ -36,6 +42,7 @@ var SUPPORTED_CONFIG_KEYS = [
 var DEFAULT_THEME = "none";
 var DEFAULT_OBSERVE_MODEL = "gemini-2.0-flash";
 var DEFAULT_OBSERVE_PROVIDER = "gemini";
+var DEFAULT_FACT_EXTRACTION_MODE = "llm";
 var DEFAULT_CONTEXT_MAX_RESULTS = 5;
 var DEFAULT_CONTEXT_PROFILE = "default";
 var DEFAULT_GRAPH_MAX_HOPS = 2;
@@ -113,6 +120,9 @@ function isTheme(value) {
 function isContextProfile(value) {
   return typeof value === "string" && CONTEXT_PROFILES.includes(value);
 }
+function isFactExtractionMode(value) {
+  return typeof value === "string" && FACT_EXTRACTION_MODES.includes(value);
+}
 function normalizeRouteTarget(target) {
   const trimmed = target.trim().replace(/^\/+/, "").replace(/\/+$/, "");
   if (!trimmed) {
@@ -196,7 +206,8 @@ function withDefaults(vaultPath, config) {
       provider: DEFAULT_OBSERVE_PROVIDER
     },
     observer: {
-      compression: {}
+      compression: {},
+      factExtractionMode: DEFAULT_FACT_EXTRACTION_MODE
     },
     context: {
       maxResults: DEFAULT_CONTEXT_MAX_RESULTS,
@@ -247,7 +258,8 @@ function withDefaults(vaultPath, config) {
     },
     observer: {
       ...observerRecord,
-      compression: normalizedCompression
+      compression: normalizedCompression,
+      factExtractionMode: isFactExtractionMode(observerRecord.factExtractionMode) ? observerRecord.factExtractionMode : defaults.observer.factExtractionMode
     },
     context: {
       ...contextRecord,
@@ -335,6 +347,12 @@ function coerceManagedValue(key, value) {
     }
     return value.trim();
   }
+  if (key === "observer.factExtractionMode") {
+    if (!isFactExtractionMode(value)) {
+      throw new Error(`Config key "observer.factExtractionMode" must be one of: ${FACT_EXTRACTION_MODES.join(", ")}`);
+    }
+    return value;
+  }
   if (key === "context.maxResults") {
     const parsed = asPositiveInteger(value);
     if (parsed === null) {
@@ -424,7 +442,8 @@ function resetConfig(vaultPath) {
   const observerRecord = document.observer && typeof document.observer === "object" && !Array.isArray(document.observer) ? document.observer : {};
   document.observer = {
     ...observerRecord,
-    compression: {}
+    compression: {},
+    factExtractionMode: DEFAULT_FACT_EXTRACTION_MODE
   };
   document.context = {
     maxResults: DEFAULT_CONTEXT_MAX_RESULTS,