clawvault 3.2.1 → 3.4.0

package/dist/index.d.ts

@@ -1,28 +1,36 @@
 import { Command } from 'commander';
-import { V as VaultConfig, a as StoreOptions, D as Document, b as SearchOptions, c as SearchResult, d as SyncOptions, e as SyncResult, C as Category, M as MemoryType, H as HandoffDocument, S as SessionRecap } from './types-BbWJoC1c.js';
-export { f as DEFAULT_CATEGORIES, g as DEFAULT_CONFIG, h as MEMORY_TYPES, T as TYPE_TO_CATEGORY, i as VaultMeta } from './types-BbWJoC1c.js';
+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';
 export { KanbanGroupBy, KanbanImportChange, KanbanImportOptions, KanbanImportResult, KanbanLane, KanbanSyncOptions, KanbanSyncResult, ParsedKanbanBoard, ParsedKanbanLane, buildKanbanLanes, extractCardSlug, formatKanbanCard, generateKanbanMarkdown, importKanbanBoard, kanbanCommand, parseKanbanMarkdown, syncKanbanBoard } from './commands/kanban.js';
+export { BenchmarkObserverCommandOptions, benchmarkObserverCommand, registerBenchmarkCommand } from './commands/benchmark.js';
 export { C as ContextEntry, a as ContextFormat, b as ContextOptions, c as ContextProfile, d as ContextProfileInput, e as ContextProfileOption, f as ContextResult, R as ResolvedContextProfile, g as buildContext, h as contextCommand, i as formatContextMarkdown, j as inferContextProfile, n as normalizeContextProfileInput, r as registerContextCommand, k as resolveContextProfile } from './context-BUGaWpyL.js';
-import { L as LlmProvider } from './inject-DYUrDqQO.js';
-export { I as InjectCommandOptions, a as InjectFormat, b as InjectMatch, c as InjectMatchReason, d as InjectMatchSource, e as InjectResult, f as InjectRuntimeOptions, g as InjectSourceCategory, h as InjectableItem, i as LlmCompletionOptions, M as MEMORY_GRAPH_SCHEMA_VERSION, j as MemoryGraph, k as MemoryGraphEdge, l as MemoryGraphEdgeType, m as MemoryGraphIndex, n as MemoryGraphNode, o as MemoryGraphNodeType, p as MemoryGraphStats, q as buildInjectionResult, r as buildOrUpdateMemoryGraphIndex, s as deterministicInjectMatches, t as getMemoryGraph, u as indexInjectableItems, v as injectCommand, w as loadMemoryGraphIndex, x as registerInjectCommand, y as requestLlmCompletion, z as resolveLlmProvider, A as runPromptInjection } from './inject-DYUrDqQO.js';
+import { L as LlmProvider, a as LlmModelTier } from './inject-DEb_jpLi.js';
+export { I as InjectCommandOptions, b as InjectFormat, c as InjectMatch, d as InjectMatchReason, e as InjectMatchSource, f as InjectResult, g as InjectRuntimeOptions, h as InjectSourceCategory, i as InjectableItem, j as LlmCompletionOptions, M as MEMORY_GRAPH_SCHEMA_VERSION, k as MemoryGraph, l as MemoryGraphEdge, m as MemoryGraphEdgeType, n as MemoryGraphIndex, o as MemoryGraphNode, p as MemoryGraphNodeType, q as MemoryGraphStats, r as buildInjectionResult, s as buildOrUpdateMemoryGraphIndex, t as deterministicInjectMatches, u as getMemoryGraph, v as indexInjectableItems, w as injectCommand, x as loadMemoryGraphIndex, y as registerInjectCommand, z as requestLlmCompletion, A as resolveLlmProvider, B as runPromptInjection } from './inject-DEb_jpLi.js';
 export { ObserveCommandOptions, observeCommand, registerObserveCommand } from './commands/observe.js';
 export { ReflectCommandOptions, reflectCommand, registerReflectCommand } from './commands/reflect.js';
 export { ArchiveCommandOptions, archiveCommand, registerArchiveCommand } from './commands/archive.js';
 export { RebuildCommandOptions, rebuildCommand, registerRebuildCommand } from './commands/rebuild.js';
 import { MigrationIssueType } from './commands/doctor.js';
-export { DoctorCheck, DoctorReport, DoctorStatus, MigrationIssue, doctor } from './commands/doctor.js';
+export { DoctorCheck, DoctorOptions, DoctorReport, DoctorStatus, MigrationIssue, doctor } from './commands/doctor.js';
 export { EmbedCommandOptions, EmbedCommandResult, embedCommand, registerEmbedCommand } from './commands/embed.js';
+export { InboxAddCommandOptions, inboxAddCommand, registerInboxCommand } from './commands/inbox.js';
+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';
@@ -64,20 +72,24 @@ declare class ClawVault {
      * Store a new document
      */
     store(options: StoreOptions): Promise<Document>;
+    /**
+     * Patch an existing document and incrementally refresh index state for that file only.
+     */
+    patch(options: PatchOptions): Promise<Document>;
     /**
      * Quick store to inbox
      */
     capture(note: string, title?: string): Promise<Document>;
     /**
-     * Search the vault (BM25 via qmd)
+     * Search the vault (in-process hybrid by default, qmd fallback optional)
      */
     find(query: string, options?: SearchOptions): Promise<SearchResult[]>;
     /**
-     * Semantic/vector search (via qmd vsearch)
+     * Semantic/vector search (hosted embeddings, qmd fallback optional)
      */
     vsearch(query: string, options?: SearchOptions): Promise<SearchResult[]>;
     /**
-     * Combined search with query expansion (via qmd query)
+     * Combined search entrypoint (currently aliases hybrid search)
      */
     query(query: string, options?: SearchOptions): Promise<SearchResult[]>;
     /**
@@ -164,6 +176,13 @@ declare class ClawVault {
      * Handles Date objects, strings, and undefined values.
      */
     private toDateString;
+    private reindexDocument;
+    private resolveDocumentRelativePath;
+    private splitFrontmatter;
+    private applyPatchToBody;
+    private appendText;
+    private replaceAllOccurrences;
+    private patchMarkdownSection;
     /**
      * Extract the date portion (YYYY-MM-DD) from an ISO date string or Date object.
      * Provides safe handling for various date formats.
@@ -215,8 +234,8 @@ declare function migrateCommand(options?: MigrateCommandOptions): Promise<Migrat
 declare function registerMigrateCommand(program: Command): void;
 
 /**
- * ClawVault Search Engine - qmd Backend
- * Uses qmd CLI for BM25 and vector search
+ * ClawVault Search Engine
+ * In-process hybrid retrieval is default; qmd remains optional fallback.
  */
 
 declare const QMD_INSTALL_URL = "https://github.com/tobi/qmd";
@@ -254,11 +273,13 @@ declare function qmdEmbed(collection?: string, indexName?: string): void;
  * QMD Search Engine - wraps qmd CLI
  */
 declare class SearchEngine {
-    private documents;
+    private readonly inProcess;
     private collection;
     private vaultPath;
     private collectionRoot;
     private qmdIndexName?;
+    private searchConfig;
+    setSearchConfig(config?: VaultSearchConfig): void;
     /**
      * Set the collection name (usually vault name)
      */
@@ -295,15 +316,17 @@ declare class SearchEngine {
     /**
      * BM25 search via qmd
      */
-    search(query: string, options?: SearchOptions): SearchResult[];
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
     /**
      * Vector/semantic search via qmd vsearch
      */
-    vsearch(query: string, options?: SearchOptions): SearchResult[];
+    vsearch(query: string, options?: SearchOptions): Promise<SearchResult[]>;
     /**
      * Combined search with query expansion (qmd query command)
      */
-    query(query: string, options?: SearchOptions): SearchResult[];
+    query(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+    private runSearchWithFallback;
+    private runInProcessQuery;
     private runQmdQuery;
     /**
      * Convert qmd results to ClawVault SearchResult format
@@ -434,12 +457,18 @@ declare const OBSERVER_COMPRESSION_PROVIDERS: readonly ["anthropic", "openai", "
 declare const THEMES: readonly ["neural", "minimal", "none"];
 declare const CONTEXT_PROFILES: readonly ["default", "planning", "incident", "handoff", "auto"];
 declare const FACT_EXTRACTION_MODES: readonly ["off", "rule", "llm", "hybrid"];
+declare const SEARCH_BACKENDS: readonly ["in-process", "qmd"];
+declare const SEARCH_EMBEDDING_PROVIDERS: readonly ["none", "openai", "gemini", "ollama"];
+declare const SEARCH_RERANK_PROVIDERS: readonly ["none", "jina", "voyage", "siliconflow", "pinecone"];
 type ObserveProvider = (typeof OBSERVE_PROVIDERS)[number];
 type ObserverCompressionProvider = (typeof OBSERVER_COMPRESSION_PROVIDERS)[number];
 type Theme = (typeof THEMES)[number];
 type ContextProfile = (typeof CONTEXT_PROFILES)[number];
 type FactExtractionMode$1 = (typeof FACT_EXTRACTION_MODES)[number];
-type ManagedConfigKey = 'name' | 'categories' | 'theme' | 'observe.model' | 'observe.provider' | 'observer.compression.provider' | 'observer.compression.model' | 'observer.compression.baseUrl' | 'observer.compression.apiKey' | 'observer.factExtractionMode' | 'context.maxResults' | 'context.defaultProfile' | 'graph.maxHops' | 'inject.maxResults' | 'inject.useLlm' | 'inject.scope';
+type SearchBackend = (typeof SEARCH_BACKENDS)[number];
+type SearchEmbeddingProvider = (typeof SEARCH_EMBEDDING_PROVIDERS)[number];
+type SearchRerankProvider = (typeof SEARCH_RERANK_PROVIDERS)[number];
+type ManagedConfigKey = 'name' | 'categories' | 'theme' | 'models.background' | 'models.default' | 'models.complex' | 'observe.model' | 'observe.provider' | 'observer.compression.provider' | 'observer.compression.model' | 'observer.compression.baseUrl' | 'observer.compression.apiKey' | 'observer.factExtractionMode' | 'context.maxResults' | 'context.defaultProfile' | 'graph.maxHops' | 'inject.maxResults' | 'inject.useLlm' | 'inject.scope' | 'search.backend' | 'search.qmdFallback' | 'search.chunkSize' | 'search.chunkOverlap' | 'search.embeddings.provider' | 'search.embeddings.model' | 'search.embeddings.baseUrl' | 'search.embeddings.apiKey' | 'search.rerank.provider' | 'search.rerank.model' | 'search.rerank.endpoint' | 'search.rerank.apiKey' | 'search.rerank.weight';
 interface RouteRule {
     pattern: string;
     target: string;
@@ -472,6 +501,7 @@ type FactExtractionMode = 'off' | 'rule' | 'llm' | 'hybrid';
 interface LlmAdapterOptions {
     provider?: LlmProvider | null;
     model?: string;
+    tier?: LlmModelTier;
     temperature?: number;
     maxTokens?: number;
     fetchImpl?: typeof fetch;
@@ -718,6 +748,13 @@ declare class Compressor {
     private readonly fetchImpl;
     constructor(options?: CompressorOptions);
     compress(messages: string[], existingObservations: string): Promise<string>;
+    private sanitizeIncomingMessages;
+    private sanitizeIncomingMessage;
+    private normalizeMessageRole;
+    private isConversationRolePrefix;
+    private shouldDropMessageRole;
+    private stripNoisyData;
+    private isLikelyStructuredNoise;
     private resolveProvider;
     private resolveConfiguredProvider;
     private resolveProviderFromEnv;
@@ -744,9 +781,18 @@ declare class Compressor {
      * Also fixes trailing word fragments fused after closing brackets.
      */
     private sanitizeWikiLinks;
+    private static readonly SCENE_SETTER_RE;
+    private static readonly ACK_NOISE_RE;
+    private isNoiseObservation;
     private enforceImportanceRules;
     private enforceImportanceForRecord;
     private fallbackCompression;
+    private toFallbackCandidate;
+    private shouldDropLowSignalCandidate;
+    private stripConversationLeadIn;
+    private stripTimePrefix;
+    private calibrateFallbackCandidate;
+    private buildRoutineMaintenanceSummary;
     private mergeObservations;
     private mergeRecord;
     private renderSections;
@@ -936,6 +982,124 @@ declare class SessionWatcher {
 
 declare function parseSessionFile(filePath: string): string[];
 
+declare const OBSERVATION_TYPES: readonly ["decision", "preference", "fact", "commitment", "task", "todo", "commitment-unresolved", "milestone", "lesson", "relationship", "project"];
+type ObservationType = typeof OBSERVATION_TYPES[number];
+type LegacyObservationPriority = '🔴' | '🟡' | '🟢';
+type ObservationLineKind = 'scored' | 'emoji';
+interface ParsedObservationRecord {
+    date: string;
+    type: ObservationType;
+    confidence: number;
+    importance: number;
+    content: string;
+    format: ObservationLineKind;
+    priority?: LegacyObservationPriority;
+    time?: string;
+    rawLine: string;
+}
+
+type ObserverBenchmarkProvider = CompressionProvider | 'mock';
+type ObserverBenchmarkReportFormat = 'json' | 'text';
+interface ObserverBenchmarkFixtureConfig {
+    now?: string;
+    existingObservations?: string;
+    compression?: {
+        provider?: ObserverBenchmarkProvider;
+        model?: string;
+        baseUrl?: string;
+        apiKey?: string;
+    };
+    scoring?: {
+        matchThreshold?: number;
+        minimumImportanceForRecall?: number;
+        keywordHints?: string[];
+    };
+}
+interface ObserverBenchmarkFixture {
+    id: string;
+    dir: string;
+    transcriptPath: string;
+    expectedPath: string;
+    transcript: string;
+    expected: string;
+    config: ObserverBenchmarkFixtureConfig;
+}
+interface ObservationMatch {
+    expectedIndex: number;
+    actualIndex: number;
+    similarity: number;
+}
+interface KeywordRewriteFlag {
+    expected: string;
+    actual: string;
+    missingTerms: string[];
+}
+interface FixtureScoringMetrics {
+    precision: number;
+    noiseRatio: number;
+    recall: number;
+    typeAccuracy: number;
+    keywordPreservation: number;
+    overall: number;
+}
+interface FixtureScoringResult {
+    metrics: FixtureScoringMetrics;
+    matches: ObservationMatch[];
+    missedImportant: ParsedObservationRecord[];
+    noiseObservations: ParsedObservationRecord[];
+    keywordSet: string[];
+    missingKeywords: string[];
+    keywordRewriteFlags: KeywordRewriteFlag[];
+}
+interface BenchmarkFixtureResult {
+    fixtureId: string;
+    transcriptPath: string;
+    expectedPath: string;
+    provider: ObserverBenchmarkProvider;
+    model?: string;
+    outputObservations: string;
+    expectedCount: number;
+    actualCount: number;
+    expectedTypes: ObservationType[];
+    actualTypes: ObservationType[];
+    scoring: FixtureScoringResult;
+}
+interface ObserverBenchmarkReport {
+    generatedAt: string;
+    fixturesDir: string;
+    provider: ObserverBenchmarkProvider;
+    model?: string;
+    fixtureCount: number;
+    aggregate: FixtureScoringMetrics;
+    fixtures: BenchmarkFixtureResult[];
+}
+interface ObserverBenchmarkRunOptions {
+    fixturesDir: string;
+    provider?: ObserverBenchmarkProvider;
+    model?: string;
+}
+interface ScoreFixtureOptions {
+    minimumImportanceForRecall?: number;
+    matchThreshold?: number;
+    keywordHints?: string[];
+}
+
+declare function loadObserverBenchmarkFixtures(fixturesDir: string): ObserverBenchmarkFixture[];
+
+declare function runObserverBenchmark(options: ObserverBenchmarkRunOptions): Promise<ObserverBenchmarkReport>;
+
+declare function extractKeywordSetFromTranscript(transcript: string, hints?: string[]): string[];
+declare function matchObservationRecords(expected: ParsedObservationRecord[], actual: ParsedObservationRecord[], threshold?: number): ObservationMatch[];
+declare function scoreFixtureObservations(input: {
+    transcript: string;
+    expectedMarkdown: string;
+    actualMarkdown: string;
+    options?: ScoreFixtureOptions;
+}): FixtureScoringResult;
+declare function compareObservationText(left: string, right: string): boolean;
+
+declare function formatObserverBenchmarkSummary(report: ObserverBenchmarkReport): string;
+
 interface ArchiveObservationsOptions {
     olderThanDays?: number;
     dryRun?: boolean;
@@ -965,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
  *
@@ -994,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, Category, ClawVault, type CompressionProvider, Compressor, type CompressorOptions, type ContextProfile as ConfigDefaultProfile, Document, EmbeddingCache, type ExtractedFact, type ExtractionResult, type FactExtractionMode$1 as FactExtractionMode, FactStore, type FactStoreStats, HandoffDocument, type LlmAdapter, type LlmAdapterOptions, LlmProvider, type ManagedConfigKey, MemoryType, type MigrateCommandOptions, type MigrateResult, type MigrationAction, MigrationIssueType, type ObserveCursorEntry, type ObserveCursorStore, type ObserveProvider, Observer, type ObserverCompressionProvider, type ObserverCompressor, type ObserverOptions, type ObserverReflector, type ObserverStalenessResult, QMD_INSTALL_COMMAND, QMD_INSTALL_URL, QmdConfigurationError, type QmdErrorCode, type QmdErrorDetails, QmdUnavailableError, type ReflectOptions, type ReflectResult, Reflector, type ReflectorOptions, type RouteRule, SUPPORTED_CONFIG_KEYS, SearchEngine, SearchOptions, SearchResult, SessionRecap, SessionWatcher, type SessionWatcherOptions, StoreOptions, SyncOptions, SyncResult, type Theme, type TransitionEvent, VERSION, VaultConfig, addRouteRule, appendTransition, archiveObservations, buildTransitionEvent, cosineSimilarity, countBlockedTransitions, createDefaultAdapter, createFactExtractionAdapter, createGeminiFlashAdapter, createLlmFunction, createVault, embed, embedBatch, extractFactsLlm, extractFactsRuleBased, extractTags, extractWikiLinks, factId, findVault, formatTransitionsTable, getConfig, getConfigValue, getObserverStaleness, getQmdErrorDetails, getScaledObservationThresholdBytes, hasQmd, hybridSearch, isRegression, listConfig, listRouteRules, matchRouteRule, migrate, migrateCommand, normalizeEntity, observeActiveSessions, parseSessionFile, parseSessionSourceLabel, qmdEmbed, qmdUpdate, queryTransitions, readAllTransitions, reciprocalRankFusion, registerCommanderCommands, registerMigrateCommand, removeRouteRule, resetConfig, resolveFactExtractionMode, runReflection, 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 };