clawvault 3.3.0 → 3.4.1

package/dist/chunk-RL2L6I6K.js

@@ -0,0 +1,223 @@
+// src/recall/strategies.ts
+var VERIFICATION_PATTERN = /\b(verify|verification|source|citation|cite|proof|prove|where did|evidence)\b/i;
+var TEMPORAL_PATTERN = /\b(today|yesterday|last\s+(?:day|week|month|year)|this\s+(?:week|month|year)|recent|recently|timeline|when)\b/i;
+var RELATIONSHIP_PATTERN = /\b(relationship|relates?|connected|between|depends on|works with|reports to|interacts? with)\b/i;
+function parseTemporalWindowDays(query) {
+  if (/\byesterday\b/i.test(query)) return 2;
+  if (/\btoday\b/i.test(query)) return 1;
+  if (/\blast\s+day\b/i.test(query)) return 1;
+  if (/\blast\s+week\b/i.test(query)) return 7;
+  if (/\bthis\s+week\b/i.test(query)) return 7;
+  if (/\blast\s+month\b/i.test(query)) return 31;
+  if (/\bthis\s+month\b/i.test(query)) return 31;
+  if (/\blast\s+year\b/i.test(query) || /\bthis\s+year\b/i.test(query)) return 366;
+  return void 0;
+}
+function inferEntityName(query, knownEntityNames) {
+  const wikiLink = query.match(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/);
+  if (wikiLink?.[1]) {
+    return wikiLink[1].trim();
+  }
+  const normalizedQuery = query.toLowerCase();
+  for (const entity of knownEntityNames) {
+    if (!entity.trim()) continue;
+    if (normalizedQuery.includes(entity.toLowerCase())) {
+      return entity;
+    }
+  }
+  const capSequence = query.match(/\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+){0,2})\b/);
+  if (capSequence?.[1]) {
+    return capSequence[1].trim();
+  }
+  return void 0;
+}
+function classifyRecallQuery(query, knownEntityNames = [], forcedStrategy) {
+  if (forcedStrategy) {
+    return {
+      strategy: forcedStrategy,
+      entityName: forcedStrategy === "entity" ? inferEntityName(query, knownEntityNames) : void 0,
+      temporalDays: forcedStrategy === "temporal" ? parseTemporalWindowDays(query) : void 0
+    };
+  }
+  const entityName = inferEntityName(query, knownEntityNames);
+  if (RELATIONSHIP_PATTERN.test(query)) {
+    return { strategy: "relationship", entityName };
+  }
+  if (VERIFICATION_PATTERN.test(query)) {
+    return { strategy: "verification", entityName };
+  }
+  if (TEMPORAL_PATTERN.test(query)) {
+    return {
+      strategy: "temporal",
+      entityName,
+      temporalDays: parseTemporalWindowDays(query)
+    };
+  }
+  if (entityName) {
+    return { strategy: "entity", entityName };
+  }
+  return { strategy: "quick" };
+}
+
+// src/recall/service.ts
+import * as fs from "fs";
+import * as path from "path";
+import matter from "gray-matter";
+var DEFAULT_LIMIT = 6;
+var DEFAULT_MAX_SNIPPET = 220;
+function compactSnippet(value, maxChars = DEFAULT_MAX_SNIPPET) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  if (!normalized) return "No snippet available.";
+  return normalized.slice(0, maxChars);
+}
+function toIso(value) {
+  return value.toISOString();
+}
+function parseFrontmatterDate(raw) {
+  if (typeof raw !== "string" && !(raw instanceof Date)) return null;
+  const date = raw instanceof Date ? raw : new Date(raw);
+  if (Number.isNaN(date.getTime())) return null;
+  return date;
+}
+function formatContextHeader(strategy, query) {
+  return [
+    "[ClawVault memory recall]",
+    `strategy: ${strategy}`,
+    `query: ${query}`
+  ].join(" | ");
+}
+function isRelationshipResult(result) {
+  const memoryType = typeof result.document.frontmatter.memoryType === "string" ? result.document.frontmatter.memoryType.toLowerCase() : "";
+  if (memoryType === "relationship") {
+    return true;
+  }
+  const content = `${result.document.title}
+${result.document.content}`;
+  return /\b(works with|reports to|related to|depends on|collaborates with|partnered with|between)\b/i.test(content) || (result.document.links?.length ?? 0) >= 2;
+}
+function filterTemporalResults(results, days) {
+  if (!days || !Number.isFinite(days) || days <= 0) {
+    return results;
+  }
+  const windowMs = days * 24 * 60 * 60 * 1e3;
+  const cutoff = Date.now() - windowMs;
+  return results.filter((result) => {
+    const fmDate = parseFrontmatterDate(result.document.frontmatter.date);
+    const reference = fmDate ?? result.document.modified;
+    return reference.getTime() >= cutoff;
+  });
+}
+function entityProfilePath(vaultPath, entityName) {
+  const slug = entityName.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim();
+  return path.join(vaultPath, "entities", `${slug}.md`);
+}
+function readEntityBrief(vaultPath, entityName) {
+  const filePath = entityProfilePath(vaultPath, entityName);
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  const parsed = matter(fs.readFileSync(filePath, "utf-8"));
+  const kind = typeof parsed.data.kind === "string" ? parsed.data.kind : "unknown";
+  const summary = parsed.content.split(/\r?\n/).map((line) => line.trim()).find((line) => line && !line.startsWith("#") && !line.startsWith("-")) ?? "";
+  const relationships = Array.isArray(parsed.data.relationships) ? parsed.data.relationships.slice(0, 4).map((entry) => {
+    if (typeof entry === "string") return entry;
+    if (!entry || typeof entry !== "object") return "";
+    const record = entry;
+    return typeof record.target === "string" ? record.target : "";
+  }).filter(Boolean) : [];
+  const relationshipChunk = relationships.length > 0 ? ` Relationships: ${relationships.join(", ")}.` : "";
+  return `Entity brief: ${entityName} (${kind}). ${summary}${relationshipChunk}`.trim();
+}
+function toRecallSource(result) {
+  return {
+    title: result.document.title,
+    path: result.document.id,
+    category: result.document.category,
+    score: Number(result.score.toFixed(4)),
+    snippet: compactSnippet(result.snippet || result.document.content),
+    modified: toIso(result.document.modified)
+  };
+}
+function uniqueEntityNames(results) {
+  const names = /* @__PURE__ */ new Set();
+  for (const result of results) {
+    if (result.document.category === "people" || result.document.category === "projects" || result.document.category === "entities") {
+      names.add(result.document.title);
+    }
+    for (const link of result.document.links) {
+      if (link.trim()) names.add(link.trim());
+    }
+  }
+  return [...names];
+}
+function formatRecallContext(result, includeSources) {
+  const lines = [formatContextHeader(result.strategy, result.query), ""];
+  if (result.sources.length === 0) {
+    lines.push("No relevant memories found.");
+    return lines.join("\n");
+  }
+  if (result.strategy === "verification") {
+    lines.push("Verification-oriented evidence:");
+  } else if (result.strategy === "relationship") {
+    lines.push("Relationship-focused recall:");
+  } else if (result.strategy === "temporal") {
+    lines.push("Time-filtered recall:");
+  } else if (result.strategy === "entity" && result.entityName) {
+    lines.push(`Entity-focused recall for "${result.entityName}":`);
+  } else {
+    lines.push("Relevant recall:");
+  }
+  lines.push("");
+  for (const source of result.sources) {
+    const sourceTail = includeSources || result.strategy === "verification" ? ` [${source.path}]` : "";
+    lines.push(`- (${source.score.toFixed(2)}) ${source.title}${sourceTail}`);
+    lines.push(`  ${source.snippet}`);
+  }
+  return lines.join("\n").trim();
+}
+async function buildRecallResult(vault, query, options = {}) {
+  const limit = options.limit ?? DEFAULT_LIMIT;
+  const broadLimit = Math.max(limit * 4, limit);
+  const seededResults = await vault.find(query, {
+    limit: broadLimit,
+    temporalBoost: true,
+    ...options.searchOptions ?? {}
+  });
+  const knownEntityNames = uniqueEntityNames(seededResults);
+  const classification = classifyRecallQuery(query, knownEntityNames, options.strategy);
+  let scopedResults = seededResults;
+  if (classification.strategy === "entity" && classification.entityName) {
+    scopedResults = await vault.find(`"${classification.entityName}" ${query}`, {
+      limit: broadLimit,
+      temporalBoost: true,
+      ...options.searchOptions ?? {}
+    });
+  } else if (classification.strategy === "temporal") {
+    scopedResults = filterTemporalResults(scopedResults, classification.temporalDays);
+  } else if (classification.strategy === "relationship") {
+    scopedResults = scopedResults.filter((result) => isRelationshipResult(result));
+  } else if (classification.strategy === "verification") {
+    scopedResults = [...scopedResults].sort((left, right) => right.score - left.score);
+  }
+  const selected = scopedResults.slice(0, limit);
+  const sources = selected.map(toRecallSource);
+  const entityBrief = classification.entityName ? readEntityBrief(vault.getPath(), classification.entityName) : null;
+  const provisionalResult = {
+    query,
+    strategy: classification.strategy,
+    entityName: classification.entityName,
+    context: "",
+    sources,
+    rawResults: selected
+  };
+  const baseContext = formatRecallContext(provisionalResult, options.includeSources ?? false);
+  provisionalResult.context = entityBrief ? `${baseContext}
+
+${entityBrief}` : baseContext;
+  return provisionalResult;
+}
+
+export {
+  classifyRecallQuery,
+  buildRecallResult
+};

package/dist/chunk-YTRZNA64.js

@@ -0,0 +1,37 @@
+import {
+  buildRecallResult
+} from "./chunk-RL2L6I6K.js";
+import {
+  ClawVault
+} from "./chunk-ECGJYWNA.js";
+import {
+  resolveVaultPath
+} from "./chunk-GJO3CFUN.js";
+
+// src/commands/recall.ts
+async function recallCommand(query, options) {
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const vault = new ClawVault(vaultPath);
+  await vault.load();
+  const recallOptions = {
+    limit: options.limit,
+    strategy: options.strategy,
+    includeSources: options.includeSources
+  };
+  const result = await buildRecallResult(vault, query, recallOptions);
+  if (options.json) {
+    console.log(JSON.stringify({
+      strategy: result.strategy,
+      query: result.query,
+      sources: result.sources,
+      context: result.context
+    }, null, 2));
+    return result;
+  }
+  console.log(result.context);
+  return result;
+}
+
+export {
+  recallCommand
+};

package/dist/cli/index.js

@@ -1,13 +1,13 @@
 import {
   registerCliCommands
-} from "../chunk-YCUVAOFC.js";
+} from "../chunk-DCF4KMFD.js";
 import "../chunk-KCYWJDDW.js";
 import "../chunk-TIGW564L.js";
 import "../chunk-IVRIKYFE.js";
 import "../chunk-DOIUYIXV.js";
 import "../chunk-TWMI3SNN.js";
 import "../chunk-OFOCU2V4.js";
-import "../chunk-TDWFBDAQ.js";
+import "../chunk-D5U3Q4N5.js";
 import "../chunk-BLQXXX7Q.js";
 import "../chunk-VXAGOLDP.js";
 import "../chunk-7SWP5FKU.js";
@@ -16,15 +16,16 @@ import "../chunk-DVOUSOR3.js";
 import "../chunk-4PY655YM.js";
 import "../chunk-AXSJIFOJ.js";
 import "../chunk-GFCHWMGD.js";
+import "../chunk-T7E764W3.js";
+import "../chunk-HEHO7SMV.js";
+import "../chunk-2PKBIKDH.js";
+import "../chunk-35JCYSRR.js";
 import "../chunk-BSJ6RIT7.js";
 import "../chunk-ECGJYWNA.js";
 import "../chunk-2CDEETQN.js";
-import "../chunk-T7E764W3.js";
 import "../chunk-FZ5I2NF7.js";
 import "../chunk-PTWPPVC7.js";
 import "../chunk-H3JZIB5O.js";
-import "../chunk-HEHO7SMV.js";
-import "../chunk-2PKBIKDH.js";
 import "../chunk-MQUJNOHK.js";
 import "../chunk-GJO3CFUN.js";
 import "../chunk-ZKWPCBYT.js";

package/dist/commands/entities.d.ts

@@ -1,7 +1,14 @@
 interface EntitiesOptions {
     json?: boolean;
     vaultPath?: string;
+    refresh?: boolean;
+}
+interface EntityOptions {
+    json?: boolean;
+    vaultPath?: string;
+    refresh?: boolean;
 }
 declare function entitiesCommand(options: EntitiesOptions): Promise<void>;
+declare function entityCommand(name: string, options: EntityOptions): Promise<void>;
 
-export { entitiesCommand };
+export { entitiesCommand, entityCommand };

package/dist/commands/entities.js

@@ -1,14 +1,27 @@
 import {
   buildEntityIndex
 } from "../chunk-J7ZWCI2C.js";
+import {
+  readEntityProfile,
+  synthesizeEntityProfiles
+} from "../chunk-NSXYM6EZ.js";
+import "../chunk-ECGJYWNA.js";
+import "../chunk-2CDEETQN.js";
+import "../chunk-FZ5I2NF7.js";
+import "../chunk-PTWPPVC7.js";
+import "../chunk-H3JZIB5O.js";
 import {
   resolveVaultPath
 } from "../chunk-GJO3CFUN.js";
+import "../chunk-33DOSHTA.js";
 import "../chunk-2ZDO52B4.js";
 
 // src/commands/entities.ts
 async function entitiesCommand(options) {
   const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  if (options.refresh) {
+    await synthesizeEntityProfiles(vaultPath, { writeFiles: true });
+  }
   const index = buildEntityIndex(vaultPath);
   if (options.json) {
     const output = {};
@@ -40,6 +53,36 @@ async function entitiesCommand(options) {
   }
   console.log(`Total: ${index.byPath.size} entities, ${index.entries.size} linkable aliases`);
 }
+async function entityCommand(name, options) {
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  if (options.refresh) {
+    await synthesizeEntityProfiles(vaultPath, { writeFiles: true });
+  }
+  const profile = await readEntityProfile(vaultPath, name);
+  if (!profile) {
+    throw new Error(`Entity not found: ${name}`);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(profile, null, 2));
+    return;
+  }
+  console.log(`\u{1F4CC} ${profile.name}`);
+  console.log(`Kind: ${profile.kind}`);
+  console.log(`Aliases: ${profile.aliases.join(", ")}`);
+  console.log(`Last mentioned: ${profile.lastMentioned}`);
+  console.log("");
+  console.log(profile.summary);
+  console.log("");
+  console.log("Relationships:");
+  if (profile.relationships.length === 0) {
+    console.log("- none");
+  } else {
+    for (const relationship of profile.relationships) {
+      console.log(`- ${relationship.target} (strength: ${relationship.strength})`);
+    }
+  }
+}
 export {
-  entitiesCommand
+  entitiesCommand,
+  entityCommand
 };

package/dist/commands/link.js

@@ -1,13 +1,13 @@
-import {
-  readBacklinksIndex,
-  rebuildBacklinksIndex,
-  scanVaultLinks
-} from "../chunk-7YZWHM36.js";
 import {
   autoLink,
   dryRunLink,
   findUnlinkedMentions
 } from "../chunk-P62WHA27.js";
+import {
+  readBacklinksIndex,
+  rebuildBacklinksIndex,
+  scanVaultLinks
+} from "../chunk-7YZWHM36.js";
 import {
   buildEntityIndex
 } from "../chunk-J7ZWCI2C.js";

package/dist/commands/maintain.js

@@ -1,9 +1,10 @@
 import {
   maintainCommand,
   registerMaintainCommand
-} from "../chunk-TDWFBDAQ.js";
+} from "../chunk-D5U3Q4N5.js";
 import "../chunk-DVOUSOR3.js";
 import "../chunk-2PKBIKDH.js";
+import "../chunk-35JCYSRR.js";
 import "../chunk-GJO3CFUN.js";
 import "../chunk-2ZDO52B4.js";
 export {

package/dist/commands/recall.d.ts

@@ -0,0 +1,14 @@
+import { R as RecallStrategy, c as RecallResult } from '../types-CbL-wIKi.js';
+import '../types-DslKvCaj.js';
+import '../lib/config.js';
+
+interface RecallCommandOptions {
+    vaultPath?: string;
+    limit?: number;
+    strategy?: RecallStrategy;
+    json?: boolean;
+    includeSources?: boolean;
+}
+declare function recallCommand(query: string, options: RecallCommandOptions): Promise<RecallResult>;
+
+export { type RecallCommandOptions, recallCommand };

package/dist/commands/recall.js

@@ -0,0 +1,15 @@
+import {
+  recallCommand
+} from "../chunk-YTRZNA64.js";
+import "../chunk-RL2L6I6K.js";
+import "../chunk-ECGJYWNA.js";
+import "../chunk-2CDEETQN.js";
+import "../chunk-FZ5I2NF7.js";
+import "../chunk-PTWPPVC7.js";
+import "../chunk-H3JZIB5O.js";
+import "../chunk-GJO3CFUN.js";
+import "../chunk-33DOSHTA.js";
+import "../chunk-2ZDO52B4.js";
+export {
+  recallCommand
+};

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import { Command } from 'commander';
 import { V as VaultConfig, S as StoreOptions, D as Document, P as PatchOptions, a as SearchOptions, b as SearchResult, c as SyncOptions, d as SyncResult, C as Category, M as MemoryType, H as HandoffDocument, e as SessionRecap, f as VaultSearchConfig } from './types-DslKvCaj.js';
 export { g as DEFAULT_CATEGORIES, h as DEFAULT_CONFIG, E as EmbeddingProvider, i as MEMORY_TYPES, j as PatchMode, R as RerankProvider, k as SearchBackend, T as TYPE_TO_CATEGORY, l as VaultMeta } from './types-DslKvCaj.js';
+import { C as CaptureOptions, a as CaptureStoreResult, b as CaptureCandidate } from './openclaw-plugin--gqA2BZw.js';
+export { c as CaptureMessage, d as CaptureRejection, e as CapturedMemoryType, M as MemorySlot, f as MemorySlotInitOptions, g as MemorySlotRecallOptions, h as MemorySlotSearchOptions, i as MemorySlotStoreOptions, j as MemoryStoreMetadata, k as createMemorySlot, l as createMemorySlotPlugin, m as openclawHookPlugin, r as registerMemorySlot } from './openclaw-plugin--gqA2BZw.js';
 export { setupCommand } from './commands/setup.js';
 export { CompatCheck, CompatCommandOptions, CompatReport, CompatStatus, checkOpenClawCompatibility, compatCommand, compatibilityExitCode } from './commands/compat.js';
 export { GraphSummary, graphCommand, graphSummary } from './commands/graph.js';
@@ -20,12 +22,15 @@ export { InboxAddCommandOptions, inboxAddCommand, registerInboxCommand } from '.
 export { MaintainCommandOptions, maintainCommand, registerMaintainCommand } from './commands/maintain.js';
 export { ReplayCommandOptions, registerReplayCommand, replayCommand } from './commands/replay.js';
 export { MigrateObservationsOptions, MigrateObservationsResult, migrateObservations, migrateObservationsCommand, registerMigrateObservationsCommand } from './commands/migrate-observations.js';
+export { RecallCommandOptions, recallCommand } from './commands/recall.js';
 export { SyncBdCommandOptions, registerSyncBdCommand, syncBdCommand } from './commands/sync-bd.js';
 export { SessionRecapFormat, SessionRecapOptions, SessionRecapResult, SessionTurn, buildSessionRecap, formatSessionRecapMarkdown, sessionRecapCommand } from './commands/session-recap.js';
 export { findNearestVaultPath, getVaultPath, resolveVaultPath } from './lib/config.js';
 export { registerCliCommands } from './cli/index.js';
 import { TaskStatus } from './lib/task-utils.js';
 export { completeTask, listDependentTasks, listSubtasks, updateTask } from './lib/task-utils.js';
+import { R as RecallStrategy, a as RecallQueryClassification, b as RecallOptions, c as RecallResult } from './types-CbL-wIKi.js';
+export { d as RecallSource } from './types-CbL-wIKi.js';
 export { CLAWVAULT_SERVE_PATH, DEFAULT_SERVE_PORT, ServeInstance, TailscalePeer, TailscaleServeConfig, TailscaleStatus, TailscaleSyncOptions, TailscaleSyncResult, VaultFileEntry, VaultManifest, checkPeerClawVault, compareManifests, configureTailscaleServe, discoverClawVaultPeers, fetchRemoteFile, fetchRemoteManifest, findPeer, generateVaultManifest, getOnlinePeers, getTailscaleStatus, getTailscaleVersion, hasTailscale, pushFileToRemote, resolvePeerIP, serveVault, stopTailscaleServe, syncWithPeer } from './lib/tailscale.js';
 export { TailscaleDiscoverCommandOptions, TailscaleServeCommandOptions, TailscaleStatusCommandOptions, TailscaleSyncCommandOptions, registerTailscaleCommands, registerTailscaleDiscoverCommand, registerTailscaleServeCommand, registerTailscaleStatusCommand, registerTailscaleSyncCommand, tailscaleDiscoverCommand, tailscaleServeCommand, tailscaleStatusCommand, tailscaleSyncCommand } from './commands/tailscale.js';
 export { TemplateVariables, buildTemplateVariables, renderTemplate } from './lib/template-engine.js';
@@ -1124,6 +1129,59 @@ interface ReflectResult {
 }
 declare function runReflection(options: ReflectOptions): Promise<ReflectResult>;
 
+declare class LiveCaptureService {
+    captureTurn(messages: unknown[], options?: CaptureOptions): Promise<CaptureStoreResult>;
+    private persistCandidate;
+}
+
+declare function extractTaggedMemoryNotes(text: string): CaptureCandidate[];
+declare function extractHeuristicMemories(text: string): CaptureCandidate[];
+declare function extractMemoriesFromAssistantResponse(text: string): CaptureCandidate[];
+
+interface QualityGateOptions {
+    minConfidence?: number;
+    minQualityScore?: number;
+    dedupThreshold?: number;
+}
+interface QualityGateResult {
+    accepted: boolean;
+    reason?: string;
+    qualityScore: number;
+    plausibilityScore: number;
+    confidenceScore: number;
+    maxSimilarity: number;
+}
+declare function isLikelyJunkMemory(content: string): boolean;
+declare function plausibilityScore(content: string): number;
+declare function evaluateCandidateQuality(candidate: CaptureCandidate, existingContents: string[], stagedContents?: string[], options?: QualityGateOptions): QualityGateResult;
+
+declare function classifyRecallQuery(query: string, knownEntityNames?: string[], forcedStrategy?: RecallStrategy): RecallQueryClassification;
+
+declare function buildRecallResult(vault: ClawVault, query: string, options?: RecallOptions): Promise<RecallResult>;
+
+type EntityKind = 'person' | 'project' | 'org' | 'place' | 'unknown';
+interface EntityRelationship {
+    target: string;
+    strength: number;
+    evidence: string[];
+}
+interface EntityProfile {
+    name: string;
+    aliases: string[];
+    kind: EntityKind;
+    summary: string;
+    relationships: EntityRelationship[];
+    lastMentioned: string;
+}
+
+interface SynthesizeEntityProfilesOptions {
+    writeFiles?: boolean;
+}
+declare function synthesizeEntityProfiles(vaultPath: string, options?: SynthesizeEntityProfilesOptions): Promise<EntityProfile[]>;
+declare function readEntityProfiles(vaultPath: string): EntityProfile[];
+declare function ensureEntityProfiles(vaultPath: string): Promise<EntityProfile[]>;
+declare function readEntityProfile(vaultPath: string, name: string): Promise<EntityProfile | null>;
+
 /**
  * ClawVault 🐘 — An Elephant Never Forgets
  *
@@ -1153,4 +1211,4 @@ declare function runReflection(options: ReflectOptions): Promise<ReflectResult>;
 declare const VERSION: string;
 declare function registerCommanderCommands(program: Command): Command;
 
-export { type ActiveObservationCandidate, type ActiveObservationFailure, type ActiveObserveOptions, type ActiveObserveResult, type ArchiveObservationsOptions, type ArchiveObservationsResult, type BenchmarkFixtureResult, Category, ClawVault, type CompressionProvider, Compressor, type CompressorOptions, type ContextProfile as ConfigDefaultProfile, type SearchBackend as ConfigSearchBackend, type SearchEmbeddingProvider as ConfigSearchEmbeddingProvider, type SearchRerankProvider as ConfigSearchRerankProvider, Document, EmbeddingCache, type ExtractedFact, type ExtractionResult, type FactExtractionMode$1 as FactExtractionMode, FactStore, type FactStoreStats, type FixtureScoringMetrics, type FixtureScoringResult, HandoffDocument, type KeywordRewriteFlag, type LlmAdapter, type LlmAdapterOptions, LlmProvider, type ManagedConfigKey, MemoryType, type MigrateCommandOptions, type MigrateResult, type MigrationAction, MigrationIssueType, type ObservationMatch, type ObserveCursorEntry, type ObserveCursorStore, type ObserveProvider, Observer, type ObserverBenchmarkFixture, type ObserverBenchmarkFixtureConfig, type ObserverBenchmarkProvider, type ObserverBenchmarkReport, type ObserverBenchmarkReportFormat, type ObserverBenchmarkRunOptions, type ObserverCompressionProvider, type ObserverCompressor, type ObserverOptions, type ObserverReflector, type ObserverStalenessResult, PatchOptions, QMD_INSTALL_COMMAND, QMD_INSTALL_URL, QmdConfigurationError, type QmdErrorCode, type QmdErrorDetails, QmdUnavailableError, type ReflectOptions, type ReflectResult, Reflector, type ReflectorOptions, type RouteRule, SUPPORTED_CONFIG_KEYS, type ScoreFixtureOptions, SearchEngine, SearchOptions, SearchResult, SessionRecap, SessionWatcher, type SessionWatcherOptions, StoreOptions, SyncOptions, SyncResult, type Theme, type TransitionEvent, VERSION, VaultConfig, VaultSearchConfig, addRouteRule, appendTransition, archiveObservations, buildTransitionEvent, compareObservationText, cosineSimilarity, countBlockedTransitions, createDefaultAdapter, createFactExtractionAdapter, createGeminiFlashAdapter, createLlmFunction, createVault, embed, embedBatch, extractFactsLlm, extractFactsRuleBased, extractKeywordSetFromTranscript, extractTags, extractWikiLinks, factId, findVault, formatObserverBenchmarkSummary, formatTransitionsTable, getConfig, getConfigValue, getObserverStaleness, getQmdErrorDetails, getScaledObservationThresholdBytes, hasQmd, hybridSearch, isRegression, listConfig, listRouteRules, loadObserverBenchmarkFixtures, matchObservationRecords, matchRouteRule, migrate, migrateCommand, normalizeEntity, observeActiveSessions, parseSessionFile, parseSessionSourceLabel, qmdEmbed, qmdUpdate, queryTransitions, readAllTransitions, reciprocalRankFusion, registerCommanderCommands, registerMigrateCommand, removeRouteRule, resetConfig, resolveFactExtractionMode, runObserverBenchmark, runReflection, scoreFixtureObservations, semanticSearch, setConfigValue, testRouteRule };
+export { type ActiveObservationCandidate, type ActiveObservationFailure, type ActiveObserveOptions, type ActiveObserveResult, type ArchiveObservationsOptions, type ArchiveObservationsResult, type BenchmarkFixtureResult, CaptureCandidate, CaptureOptions, CaptureStoreResult, Category, ClawVault, type CompressionProvider, Compressor, type CompressorOptions, type ContextProfile as ConfigDefaultProfile, type SearchBackend as ConfigSearchBackend, type SearchEmbeddingProvider as ConfigSearchEmbeddingProvider, type SearchRerankProvider as ConfigSearchRerankProvider, Document, EmbeddingCache, type EntityKind, type EntityProfile, type EntityRelationship, type ExtractedFact, type ExtractionResult, type FactExtractionMode$1 as FactExtractionMode, FactStore, type FactStoreStats, type FixtureScoringMetrics, type FixtureScoringResult, HandoffDocument, type KeywordRewriteFlag, LiveCaptureService, type LlmAdapter, type LlmAdapterOptions, LlmProvider, type ManagedConfigKey, MemoryType, type MigrateCommandOptions, type MigrateResult, type MigrationAction, MigrationIssueType, type ObservationMatch, type ObserveCursorEntry, type ObserveCursorStore, type ObserveProvider, Observer, type ObserverBenchmarkFixture, type ObserverBenchmarkFixtureConfig, type ObserverBenchmarkProvider, type ObserverBenchmarkReport, type ObserverBenchmarkReportFormat, type ObserverBenchmarkRunOptions, type ObserverCompressionProvider, type ObserverCompressor, type ObserverOptions, type ObserverReflector, type ObserverStalenessResult, PatchOptions, QMD_INSTALL_COMMAND, QMD_INSTALL_URL, QmdConfigurationError, type QmdErrorCode, type QmdErrorDetails, QmdUnavailableError, RecallOptions, RecallQueryClassification, RecallResult, RecallStrategy, type ReflectOptions, type ReflectResult, Reflector, type ReflectorOptions, type RouteRule, SUPPORTED_CONFIG_KEYS, type ScoreFixtureOptions, SearchEngine, SearchOptions, SearchResult, SessionRecap, SessionWatcher, type SessionWatcherOptions, StoreOptions, SyncOptions, SyncResult, type Theme, type TransitionEvent, VERSION, VaultConfig, VaultSearchConfig, addRouteRule, appendTransition, archiveObservations, buildRecallResult, buildTransitionEvent, classifyRecallQuery, compareObservationText, cosineSimilarity, countBlockedTransitions, createDefaultAdapter, createFactExtractionAdapter, createGeminiFlashAdapter, createLlmFunction, createVault, embed, embedBatch, ensureEntityProfiles, evaluateCandidateQuality, extractFactsLlm, extractFactsRuleBased, extractHeuristicMemories, extractKeywordSetFromTranscript, extractMemoriesFromAssistantResponse, extractTaggedMemoryNotes, extractTags, extractWikiLinks, factId, findVault, formatObserverBenchmarkSummary, formatTransitionsTable, getConfig, getConfigValue, getObserverStaleness, getQmdErrorDetails, getScaledObservationThresholdBytes, hasQmd, hybridSearch, isLikelyJunkMemory, isRegression, listConfig, listRouteRules, loadObserverBenchmarkFixtures, matchObservationRecords, matchRouteRule, migrate, migrateCommand, normalizeEntity, observeActiveSessions, parseSessionFile, parseSessionSourceLabel, plausibilityScore, qmdEmbed, qmdUpdate, queryTransitions, readAllTransitions, readEntityProfile, readEntityProfiles, reciprocalRankFusion, registerCommanderCommands, registerMigrateCommand, removeRouteRule, resetConfig, resolveFactExtractionMode, runObserverBenchmark, runReflection, scoreFixtureObservations, semanticSearch, setConfigValue, synthesizeEntityProfiles, testRouteRule };